Development Matters Blog

We are back for our next installment of “The Benefits of Offshore Development and Local Project Management.”

In our previous posts, we have discussed the benefits of our “nearshore location” in Eastern Europe, and the ability to take advantage of our scalable resources. In this article, we will discuss the benefits of our 24/7 virtual operations.

There is a natural time differential of 7 hours between our onshore (Chicago) and offshore (Belgrade) locations. This development model translates into a virtual 24/7 kind of operation for our projects. Leveraging our distributed resources in both locations, we are able to provide clients with maximum visibility into our software development lifecycle. We also ensure that team members, regardless of location, have overlapped work timings for day-to-day communication. We utilize video conferencing, instant messaging, web portals, and other online collaboration tools to maximize internal productivity. This enables fast and efficient client communication.

I have Microsoft Office 2007 on Windows Vista Enterprise and a few days ago, the mouse just stopped working in Word, so I could not select, copy, paste, edit. The reason was an automatic update for Word 2007 on Windows Vista-based computer.

Microsoft has confirmed that this is a problem in the Microsoft products and published resolution for this problem on their support site:

 http://support.microsoft.com/default.aspx?scid=kb;en-us;940791

Microsoft Dynamics AX 2009 WorkFlow can cause an error when setting up a workflow on Win2008R2.

If you receive this error when you run Workflow infrastructure configuration wizard:

The request failed with HTTP status 405: Method Not Allowed.

Then you should change the Application pool for your workflow (which is by default MicrosoftDynamicsAXWorkflow50) to enable 32 bit applications:

Recently I received a request from a customer to join a transferring order to an invoice and print a packing slip form after transferring the order to the invoice on the SOP Entry form. This form has already been modified and some processes have been added to it through triggers. At first, it looked like a small request, but after the first testing process I realized that it worked correctly only in simple situations. The main problem was that the original print button of the Dynamics GP window needed to be in focus before it is called. When a few operations which call different windows are joined, the focus can be lost because of the delay of opening windows or printing reports. There are also some unexpected windows which pop up and stay open, disturbing some of the following operations.

Another problem appeared when I tried to debug the code I wrote. During debugging process it worked worse than in the previous situation. Using the debugger, the focus is always kept on the debug script and none of the focuses can be reached, which means that none of the reports can be printed.

The main problem was printing reports from different forms. We needed the possibility to join one printing report from one form to another printing report from a different one. There is a small delay between the moment when options for printing are chosen and the moment of printing the report, especially if the screen is chosen for report destination. In that case, the second window already gets a focus on the print button when the first report starts to be printed. Focus on the second window is lost so the printing and processes added to that window through triggers would not be done completely.

In such situations, the only way I found to be efficient is good knowledge about processes we are working with. We need to count every possible situation which can happen during the process we need to implement, which is in most situations pretty complicated and sometimes impossible.

A couple of days ago, Microsoft announced that Microsoft Office 2010 Beta is available for download.
In order to get started you need to first visit this link where you will find a option to get it. Since this is a Microsoft Product you will be asked to first login to your live account, after which you will need to confirm your personal details following which you will get a 25 digit MAK Product Key which will activate your product.

After you register, a new window will open with a download service within it which will start downloading the files from the Microsoft Server. It supports resumed downloads, so you can safely start it and walk away from it. If your download gets interrupted, it will restart where it left off. The total download size is 684.48Mb and it contains the complete MS Office 2010 Package on your PC. This includes Word, OneNote, InfoPath, PowerPoint, Access, SharePoint Workspace, Outlook, Publisher, Communicator & Excel. There are two activation options for the 2010 Microsoft Office products. The MAK key described above is one activation method. Another activation option for an IT administrator is to set up a Key Management Server (KMS). Just choose the version (Microsoft recommends 32-bit which runs great on both 32-bit and 64-bit versions of Windows) and pick your software language to download the Beta software. Downloading the Office Professional Plus 2010 Beta can take an hour or more. The exact time will depend on your provider, bandwidth, and traffic.

Once the download is complete, launch the downloaded file and follow the set up instructions.

After you have installed Microsoft Office Professional Plus 2010 Beta, please follow these steps:

1. Open Microsoft Word 2010 Beta and click on the “File” tab. This will take you to the Backstage view. Next click “Help” in the set of tabs on the left.
2. Click “Change Product Key” on the right side of the screen.
3. Enter the Multiple Activation Key (MAK). Check the box to activate automatically or restart the app to activate using the activation dialog box.
4. That’s all you need to do. Entering the MAK key in Microsoft Word 2010 Beta automatically activates all the Office Professional Plus 2010 Beta applications. Click on the “File” tab to return to the Document view.

That’s it!

InfoPath form templates in MOSS are widely used because there are many reasons that empower both servers.

The most common situation is that you need to pick-up some user information from MOSS and show / manipulate it on an InfoPath form. There are a few possible ways to make it work, with or without coding. The most powerful thing is by using web services provided by MOSS.

To be able to use web services in InfoPath, you should create a new Data Connection (Tools-> Data Connection). When the wizard starts, define what you would like to do with the data: submit or receive. Select Web services as a source of data and define the web service’s location. For getting user profile information (email, phone number, preferred name, etc) use MOSS services located at http://MOSSServerName/_vti_bin/UserProfileService.asmx.

• This service is not available if you are using Windows Share Point Services but only Microsoft Offices SharePoint Server.
• Some of available public methods are listed below:
  • AddColleague
  • AddLink
  • AddMembership
  • AddPinnedLink
  • CreateMemberGroup
  • CreateUserProfileByAccountName
  • GetCommonColleagues
  • GetCommonManager
  • GetUserLinks
  • GetUserProfileByGuid
  • GetUserProfileByIndex
  • GetUserProfileByName
  • ModifyUserPropertyByAccountName
  • RemoveMembership
  • UpdatePinnedLink, etc.

Moving forward, you can take the profile data for any current or other MOSS user. For users currently logged on, you should be able to pick-up some profile info when the form is loading. For non-current users, you have a lot different cases and you can pick data on the field value changed or drop down list value selected or something else.

If you need to handle some of the available events, you should have VSTA installed (Visual Studio Tools for Applications). If you do not have it, you will not be able to create event handlers at all. To enable it, find Microsoft Office in list of Add/Remove programs. Select Change option and add find those tools for InfoPath. Select the option to install it.

Now you can create event handlers by selecting a control, right click on it, then Programming and selecting the desired event. The most interesting case is if you have a drop down list with a few names and you would like to send an email to the selected one. Before we continue, just to note that the drop down list item has a Value and a Display Name. This can give us the possibility to hide non user-friendly data. So, if you decide to get email defined in MOSS for selected user, assign the Account Name as Value for each item in the drop down. Display value can be as you wish…

When VSTA is running, add reference to UserProfileService and name it. Code in the event handler should look like:

XPathNavigator XPathNav = MainDataSource.CreateNavigator();

ServiceReferenceName.UserProfileService profile = new ServiceReferenceName.UserProfileService();

   profile.UseDefaultCredentials = true; 

   profile.PropertyData[] userProperties = null;

    try {

              userProperties = profile.GetUserProfileByName(SelectedDDLValue);

    }

    catch { }

    if (userProperties == null || userProperties.Length == 0) {

        return;

    }

    for (int i = 0; i < userProperties.Length; i++) {

        XPathNavigator node = null;       

            case “workemail”:

                node = XPathNav.SelectSingleNode(“/my:emailField/my:userEmail”, NamespaceManager);

                break;

            default:

                continue;

        }

       ServiceReferenceName.ValueData[] values = userProps[i].Values;

        if (values.Length > 0) {

            if (node != null && string.IsNullOrEmpty(node.Value)) {

                node.SetValue(values[0].Value.ToString());

            }…

The email field can be hidden or visible, it depends on what information you would like to share with the user.

• In some cases, you can experience that drop down list events do not react as you expect. Try to avoid this by setting “Always Postback” option on drop down list property.

I found a useful link for getting into naming conventions for physical names in Dynamics GP. There is a good explanation how table and field names are created in the Dynamics GP original code and we should use the same rules for new ones. You can find the article on MSDN:

 Understanding How Microsoft Dynamics GP Works With Microsoft SQL Server Continued

Below is a list, with descriptions, of the most commonly used XML Documentation Tags.

<summary> / <remarks>
The <summary> tag is used to describe a type or a member. The <remarks> tag is used to add supplemental information to a type or member description.

/// <summary>Type or member description.</summary>
/// <remarks>Supplemental Information.</remarks>

<param>
The <param> tag is used for documenting the method parameter. The <param> tag is always used with the name attribute.

/// <summary>…</summary>
/// <param name=”arg1″>Describe arg1 parameter.</param>
/// <param name=”arg2″>Describe arg2 parameter.</param>
public void XmlDocumentationMethod(string arg1, int arg2) { … } 

<returns>
The <returns> tag is used for describing the return value from a method.

/// <summary>…</summary>
/// <returns>Return value description.</returns>
public int XmlDocumentationMethod ( ) { … }

<see>
The <see> tag is used for adding links to your documentation. It can only be used inside other tags. Also, it has to be used with one of two attributes, href or cref. Href attribute is used for specifying the external hyperlinks. This is actually any link that a browser can recognize, including links to .doc and .pdf documents. Cref attribute is used for specifying an internal hyperlink. Internal hyperlink is linking to any item in the installed MSDN library on your local machine.

You can also use the langword attribute for documenting the language words such as true, false, null, etc.

/// <summary>
/// Various links inside text:
/// <see cref=”System.Exception”/>
/// <see href=”http://www.microsoft.com”/>
/// <see langword=”true”/>
/// </summary>
public void XmlDocumentationMethod ( )  { … }

<exception>
The <exception> tag is used in describing the exceptions that might be thrown by a member.

/// <summary>…</summary>
/// <exception cref=”SerializationException”/>
public void XmlDocumentationMethod ( )
{
            throw new SerializationException ( ) ;
}

 <c> / <code> / <example>
The <c> tag describes the in-line code. The <code> tage describes the code block. The <example> tag introduces the example section.

/// <summary>…</summary>
/// <example>
/// You have to clear the data before you can
/// execute the <c>Helper.Load()</c> to load data.
/// <code>
/// Helper.Clear();
/// Helper.Load();
/// </code>
/// </example>
public void Load() { … }

<list>
The <list> tag is used for formatting the text into a list. The List tag has to be used with the type attribute. The type attribute can be bullet (bulleted list), number (numbered list), or table.

/// <summary>…</summary>
/// <remarks>
/// Bulleted List:
/// <list type=”bullet”>
/// <item>item 1</item>
/// <item>item 2</item>
/// </list>
/// Numbered List:
/// <list type=”number”>
/// <item>item 1</item>
/// <item>item 2</item>
/// </list>
/// Table List:
/// <list type=”table”>
/// <listheader>
///     <term>item</term>
///     <description>description</description>
/// </listheader>
/// <item>
///     <term>item 1</term>
///     <description>description</description>
/// </item>
/// <item>
///     <term>item 2</term>
///     <description>description</description>
/// </item>
/// </list>
/// </remarks>
public void XmlDocumentationMetho ( )  { … }

Writing code documentation has always been a time consuming process. Additionally, reflecting code changes in the already finished documentation proved to be even more time consuming.

Since the beginning of time, code documentation existed only inside the code itself in the form of the in-line comments. However, modern programming languages introduced syntax for the in-line code comments (XML documentation syntax) and brought the capability of generating the external humanly-readable code documentation from these comments.

Visual Studio has a fully integrated support for the XML documentation. In order to use it inside your .NET project you need to enable it on the Build tab of the Properties page of the project.

Once you build the project with the XML documentation option enabled, a list of warnings will be populated with the additional warnings informing you about the missing XML comments.

You can remove these warnings by simply adding the XML comments to each of the publicly visible types from the list. To add XML comment to the publicly visible type, simply type /// on top of it. Visual Studio will automatically generate the required XML comment syntax and all that is left for you to do is to describe it.

XML documentation supports a wide range of the XML tags used for formatting. I will describe these tags in detail in the second part of this post.

Resource Information is one of the Standard mode features of the Support Debugging Tool.

By selecting Resource Information from the Options button drop list on the main window of the Support Debugging Tool, you can open the Resource Information window.

You can use the Resource Information window to show technical, display, and physical names and resource IDs for any form, window, field, table, table group or report resource in any dictionary currently installed in the Microsoft Dynamics GP application.

If you know any information about a resource, you can enter it into the appropriate field and the rest of the fields will be populated with the details for that resource.

For example, entering a window’s display name will identify the window’s technical name and resource ID; or entering a table’s physical name as it appears in SQL Server will identify the table’s dictionary,
technical and display names as well as the resource ID.

This window can be useful when working with table and column names in SQL Server, because it will quickly convert the physical names used in SQL back to the technical names used in Modifier, Report Writer and Dexterity.