GPUG Summit 2011 Las Vegas: Materials now available

November 14, 2011

If you attended any of my training classes or sessions, you will be glad to know that the training and presentation materials are now available from the Learning Resources page on this site. Please feel free to download.

Until next post!

MG.-
Mariano Gomez, MVP
IntellPartners, LLC
http://www.IntellPartners.com/


Mark Polino shows some love for Microsoft Dynamics GP integration tools

October 26, 2011

Like Mark, a lot of the work I do centers around large and complex systems integration with Microsoft Dynamics GP. It’s good to see that Mark addresses some of the glories, pains, and considerations for systems selection and integration to Microsoft Dynamics GP in his new article Dynamics GP Integration Flexibility and Frustration over at his Community column Mad Mark, The GP Road Warrior. In addition, he points out some of the integration tools and methods he’s used to get these to happen.

And speaking of integrations…

Please come join me at the GPUG Summit 2011 for the Optional Academy Training Classes. I will be delivering a full day training class on Data Migration and Integration Techniques where I will be highlighting some of the issues I have faced throughout my career when migrating and integrating data from and into GP.

My training curriculum is almost locked down, but if you are attending this class and want to see a particular topic being discussed please do so by adding a comment at the bottom of this post.

Until next post!

MG.-
Mariano Gomez, MVP
IntellPartners, LLC
http://www.IntellPartners.com/


More Microsoft Dynamics GP Word Templates Articles

July 7, 2011

If you have been keeping up with this blog, you will remember that sometimes around October of 2010 I posted a series of articles related to Microsoft Dynamics GP Word Templates – see Microsoft Dynamics GP 2010 Word Templates summary for more information. These articles focused on “how to’s” and troubleshooting aspects of Word Templates.

Now the Dynamics Support and Services Team Blog has decided to launch a new set of video-articles detailing more common aspects of working with Word Templates. You can now visit the Community Team blog for the release article and the schedule of when these videos will be out. The good news is the first two are out!

Take a look at:

Adding the Developer tab in Microsoft Word after installing the Microsoft Dynamics GP Add-in for Microsoft Word – Video

Helpful tips when modifying Word Templates in Microsoft Dynamics GP 2010 – Video

Please visit the Dynamics GP Support and Services Blog for these videos and to find a collection of very new and interesting articles.

Until next post!

MG.-
Mariano Gomez, MVP
IntellPartners, LLC
http://www.IntellPartners.com/


>Microsoft Dynamics GP Technical Conference 2011 Sessions Materials

March 4, 2011

>

We hope you enjoyed the sessions this year and as promised, here are the materials for our presentations at the Microsoft Dynamics GP Technical Conference 2011.

MSDGPTechConference2011.zip

Here is the summary of each presentation session for added convenience:

Development Troubleshooting with the Support Debugging Tool
Presenters: David Musgrave and Mariano Gomez, MVP

Following the success of this session at Convergence Atlanta 2010, David Musgrave and Mariano Gomez return to the Microsoft Dynamics GP Technical Conference with a number of advanced features included in the now popular Support Debugging Tool. Learn how to debug and trace your customizations, build temporary fixes, and troubleshoot development issues and problems with dictionaries. Discover some of the tricks used by the Microsoft Developer Support team. Presenters will demonstrate real life scenarios and work through their resolutions.

Topics:

– Manual Logging Mode
– Advanced Debugger Mode
– Dictionary Control
– Scripting and Triggers
– SQL Execute and Runtime Execute features
– Exporting and Importing fixes

Introduction to Microsoft Dynamics GP Customization Tools
Presenters: David Musgrave and Mariano Gomez, MVP

New to Microsoft Dynamics GP? Welcome to this jam packed session where Microsoft’s David Musgrave and MVP Mariano Gomez will walk you through the different customization tools available to address your next project. If you have plans for a Microsoft Dynamics GP customization, but you don’t know where to start and are skeptical about future upgrade issues, then this session is for you. Gain some introductory knowledge of Modifier and Report Writer with Visual Basic for Applications, Dexterity and Visual Studio Tools with two of the leading Community experts, who will contrast the tools and help you sort through the complicated terminology, to bring you a clear picture of the choices available for your next project.

Topics:

– Where to start?
– Modifier and Report Writer with Visual Basic for Applications
– Dexterity
– Visual Studio Tools
– Resources

The material will also be available for download from the Learning Resources page on the blog.

Until next post!

MG.-
Mariano Gomez, MVP
IntellPartners, LLC
http://www.IntellPartners.com/


Learning Resources page update

December 1, 2010

I have received a number of emails from many of you requesting I add the Microsoft Dynamics GP 2010 Word Template series and Microsoft Dynamics GP Architectural Foundations series of articles to the Learning Resources page on this site. Your wishes are my command! Please visit the Learning Resources page under the Contents section for links to these series.

Thanks for your continuous readership and for making this site better every day.

Until next post!

MG.-
Mariano Gomez, MVP
Maximum Global Business, LLC
http://www.maximumglobalbusiness.com/


Using SQL Server CLR stored procedures to integrate Microsoft Dynamics GP and Microsoft CRM: Configuring SQL Server and creating table triggers

August 21, 2010

In my previous article I outlined some of the steps and methods needed on the Visual Studio side to create an integration to Microsoft CRM. In particular, the article showed you how to create the SQL CLR methods and how these methods interact with the Microsoft CRM Web services to create or update an item in the Product entity.

Following along, once you have created the assemblies (integration assembly and XML serialization assembly), you must proceed to install these in the Framework directory — the assemblies were created targeting the .NET Framework 3.5, so they were installed there — and also register these in the Global Assembly Cache (GAC) under the %windir%\assembly folder.

Once the assemblies are GAC’ed you can now begin the process of registering these with Microsoft SQL Server 2005, 2008, or 2008 R2. To begin registering the assemblies with SQL Server, we must first define an Asymmetric Key from the signed assembly created in our previous project.

USE master;
GO

CREATE ASYMMETRIC KEY CrmKey
FROM EXECUTABLE FILE = 'C:\Windows\Microsoft.NET\Framework\v3.5\Crm.Integration.dll'
GO

An asymmetric key is a securable entity at the database level. In its default form, this entity contains both a public key and a private key. When executed with the FROM clause, CREATE ASYMMETRIC KEY imports a key pair from a file or imports a public key from an assembly. For additional information on asymmetric keys click here.

Next, you must define a SQL Server login that’s associated to the asymmetric key for code signing purposes. One of the characteristics of the .NET Framework is that all external resources being accessed will require a certain level of trust. SQL Server accomplishes this by using a login for code signing with specific permissions to the outside world.

USE master;
GO

CREATE LOGIN [crmlogin] FROM ASYMMETRIC KEY [CrmKey];
GO

GRANT UNSAFE ASSEMBLY TO crmlogin;
GO

For more information on granting permissions to assemblies click here.

Once we have created the asymmetric key, it’s now time to create the assemblies in your company database.

USE [CompanyDB];
GO

CREATE ASSEMBLY [Crm.Integration]
FROM 'C:\Windows\Microsoft.NET\Framework\v3.5\Crm.Integration.dll'
WITH PERMISSION_SET = UNSAFE;
GO

CREATE ASSEMBLY [Crm.Integration.XmlSerializers]
FROM 'C:\Windows\Microsoft.NET\Framework\v3.5\Crm.Integration.XmlSerializers.dll'
WITH PERMISSION_SET = EXTERNAL_ACCESS;
GO

For more information on creating assemblies, click here.

With the assemblies created, it’s now time to expose our CLR stored procedure to SQL Server. In order to register our CLR method, we use the standard CREATE PROCEDURE statement with a twist:

SET ANSI_NULLS ON
GO
SET ANSI_WARNINGS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE PROCEDURE [dbo].[crmInsertProduct]
  @itemNumber       NVARCHAR(31),
  @itemDescription  NVARCHAR(100),
  @VendorName     NVARCHAR(65),
  @VendorItem       NVARCHAR(31),
  @ItemShipWeight   NUMERIC(19,5),
  @defaultUofM     NVARCHAR(20),
  @defaultUofMSched NVARCHAR(20),
  @defaultPriceList NVARCHAR(20),
  @currencyID       NVARCHAR(15),
  @decimals     INT,
  @quantityOnHand   NUMERIC(19,5),
  @listPrice        NUMERIC(19,5),
  @priceListPrice   NUMERIC(19,5),
  @standardcost     NUMERIC(19,5),
  @currentCost     NUMERIC(19,5),
  @productTypeCode  INT
WITH EXECUTE AS CALLER
AS
EXTERNAL NAME [Crm].[Integration].[clrProcedures].[CreateProduct]
GO
SET ANSI_NULLS OFF
GO
SET ANSI_WARNINGS OFF
GO
SET QUOTED_IDENTIFIER OFF
GO

GRANT EXECUTE ON [dbo].[crmInsertProduct] to [DYNGRP]
GO

Note that the stored procedure must be created with the same number of parameters as the CLR method.

Finally, we can create a trigger on the IV00101 table to call the stored procedure and pass in the parameters required.

Here are some final notes from and things I had to implement at the SQL Server configuration level to make all this work:

1. First, you must enable CLR integration on SQL Server to allow it to execute assemblies. To enable CLR integration, you must change the ‘CLR Enabled’ option in SQL Server configuration.

USE master;
GO
EXEC sp_configure 'show advanced option', '1';
GO
RECONFIGURE;
GO
EXEC sp_configure 'CLR Enabled', 1;
GO
RECONFIGURE;
GO
EXEC sp_configure 'show advanced option', '0';
GO
RECONFIGURE;
GO

2. In order to recreate all the above objects, you must first drop the stored procedure, then drop the assemblies, then login, and finally the asymmetric key, this is, objects need to be dropped in reverse order to avoid dependency errors.

USE [CompanyDB]
GO

IF  EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[crmInsertProduct]') AND type in (N'P', N'PC'))
DROP PROCEDURE [dbo].[crmInsertProduct]
GO

IF  EXISTS (SELECT * FROM sys.assemblies asms WHERE asms.name = N'Crm.Integration.XmlSerializers' and is_user_defined = 1)
DROP ASSEMBLY [Crm.Integration.XmlSerializers]

GO

IF  EXISTS (SELECT * FROM sys.assemblies asms WHERE asms.name = N'Crm.Integration' and is_user_defined = 1)
DROP ASSEMBLY [Crm.Integration]
GO

USE master;
GO

IF  EXISTS (SELECT * FROM sys.server_principals WHERE name = N'crmlogin')
DROP LOGIN [crmlogin]
GO

DROP ASYMMETRIC KEY CrmKey;
GO

I hope you had a good time reading this series. A lot of what you read here I had to learn on the fly, so a lot of reading and research went into building this integration approach. I am sure there are things that could be improved, but this is the down and dirty version.

Until next post!

MG.-
Mariano Gomez, MVP
Maximum Global Business, LLC
http://www.maximumglobalbusiness.com/


Using SQL CLR stored procedures to integrate Microsoft Dynamics GP and Microsoft CRM: Creating a CLR assembly and working with CRM web methods

August 18, 2010

Before we get started, there are a few rules: a) I assume you have good working knowledge of both Microsoft Dynamics GP and Microsoft CRM and that you know enough about the Item Master in GP and the Product entity in CRM, b) you are familiar with Microsoft Visual Studio and can create class libraries and create Web references, c) you have done some coding with either VB.NET and/or C#, and d) you will not ask me if I have the same code snippets in VB.NET. As I have said in multiple occassions — no offense to VB developers — when I work on commercial grade code I will choose C# over VB.NET any day of the week.

A bit of a reminder of the objective of today’s code: a) we will create our CLR methods that will serve as bridge to the Microsoft CRM web methods. The resulting assembly will be registered on SQL Server with the CLR methods exposed as stored procedures that can be called from a trigger, and b) we will create the code that will allow us to establish a connection to Microsoft CRM and in turn insert a new or update an existing Product in CRM.

We begin by creating a class library project and renaming our default class library file to clrProcedures.cs. Once this is done, we can start declaring all namespaces to help us control the scope of class and method names that we will be using throughout the project. In particular, SQL Server CLR methods will benefit from using the Microsoft.SqlServer.Server namespace contained in the System.Data.dll assembly.

clrProcedures.cs

using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Web.Services.Protocols;
using Microsoft.SqlServer.Server;
using Crm.Integration;

Also note that in the above code, I have declared the Crm.Integration namespace. This namespace will be created as a new Class Library file (Crm.Integration.cs) within our project further on in this article.

We must now implement the clrProcedures class. One note about CLR methods is that they are not encapsulated within a namespace and rather begin with the class declaration. This behavior is by design. Within our clrProcedures class, we will create a method, CreateProduct, that can be registered as a stored procedure in SQL Server. We will declare all the parameters that will be passed to the stored procedure. I believe these are pretty self-explanatory, but if you have any questions please follow up with a comment on the article.

public class clrProcedures
{
    [SqlProcedure]
    public static void CreateProduct(
          string itemNumber
        , string itemDescription
        , string vendorName
        , string vendorItem
        , decimal itemShipWeight
        , string defaultUnitOfMeasure
        , string defaultUnitOfMeasureSched
        , string defaultPriceLevel
        , string currencyID
        , int decimalsSupported
        , decimal quantityOnHand
        , decimal unitPrice
        , decimal priceLevelPrice
        , decimal standardcost
        , decimal currentCost
        , int productTypeCode
    )

Now we will proceed to create a few local variables, particularly the CRM server name, the CRM server port, and CRM Organization Name. These will be passed to our connection method to, well, open a connection to CRM. These values are read from a custom SQL table, dbo.crmInfo, in our company database. You may ask, why not create these values in a configuration file? One of the goals for my client was to provide easy access to database administrators to quickly reconfigure CRM server names and organization names without having to bother the network administrators, so it was easier to store this information in a table. In turn, our configuration file would be left to the network adminstrators to configure the address of the CRM web services as needed. My client is a public company and required segregation of duties between database admins and network admins.

    {
        string crmServerName, CrmServerPort, CrmOrgName;
        string sSQL = "SELECT CrmServerName, CrmServerPort, CrmOrgName FROM crmInfo";

        using (SqlConnection connection = new SqlConnection("context connection=true"))
        {
            connection.Open();
            SqlCommand command = new SqlCommand(sSQL, connection);
            SqlDataReader r = command.ExecuteReader();

            r.Read();
            crmServerName = Convert.ToString(r["CrmServerName"]);
            CrmServerPort = Convert.ToString(r["CrmServerPort"]);
            CrmOrgName = Convert.ToString(r["CrmOrgName"]);
        }

Now that we have queried our CRM server settings, we can establish a connection to CRM. Our CRM authentication is done via Active Directory. This is important to know when using CLR methods as the SQL Server service startup credentials will be passed to the CRM connection. Hence, the SQL Server service account must exist in the CRM users and be associated to a role that has access to create Products in CRM. Suffice to say, we will be expanding on the crmIntegration class later and the crmConnection() and crmInsertProduct() methods.

        //create an instance of the crm integration class
        crmIntegration crmInt = new crmIntegration();

        try
        {
            // Establish connection with CRM server
            crmInt.crmConnection(crmServerName, CrmServerPort, CrmOrgName);

            // Insert product
            crmInt.crmInsertProduct(
                    itemNumber.Trim()
                    , itemDescription.Trim()
                    , vendorName.Trim()
                    , vendorItem.Trim()
                    , itemShipWeight
                    , defaultUnitOfMeasure.Trim()
                    , defaultUnitOfMeasureSched.Trim()
                    , defaultPriceLevel.Trim()
                    , currencyID.Trim()
                    , decimalsSupported
                    , quantityOnHand
                    , unitPrice
                    , priceLevelPrice
                    , standardcost
                    , currentCost
                    , productTypeCode
            );
        }
        catch (System.Exception ex)
        {
            if (ex.InnerException != null)
            {
                SqlContext.Pipe.Send("Exception occurred: " + ex.InnerException.Message);

                SoapException se = ex.InnerException as SoapException;
                if (se != null)
                    SqlContext.Pipe.Send("Exception detail: " + se.Detail.InnerText);
            }
        }
        finally
        {
            //do something else here
        }
    }
}

Since one of the main concerns of the client was the ability to upgrade with each new release of CRM, we made use of the CRM web services provided by the Microsoft CRM 4.0 SDK. For this, we will add a new class library to our project and call it Crm.Integration.cs which will implement the Crm.Integration namespace and the CrmIntegration class. But first, we must create two web references: one for the CRM Service, contained under the CrmSdk namespace and one for the CRM Discovery Service, contained under the CrmDiscovery namespace.

Crm.Integration.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Web.Services.Protocols;
using CrmDiscovery;
using CrmSdk;

Now that we have declared our namespaces, we can proceed to implement the crmIntegration class. The first method to be implemented will be the connection method. This method contains all the code needed to use the Discovery service to obtain the correct URL of the CrmService Web service for your organization. The code then sends a WhoAmI request to the service to verify that the user has been successfully authenticated. This method consists of three specific operations: a) instantiate and configure the CRMDiscovery Web service, b) Retrieve the organization name and endpoint Url from the CrmDiscovery Web service, and c) create and configure an instance of the CrmService Web service.

namespace Crm.Integration
{
    public class crmIntegration
    {
        CrmService crmService;

        // Establishes a connection to CRM
        public void crmConnection(string hostName, string hostPort, string orgName)
        {
            try
            {
                // STEP 1: Instantiate and configure the CrmDiscoveryService Web service.

                CrmDiscoveryService discoveryService = new CrmDiscoveryService();
                discoveryService.UseDefaultCredentials = true;
                discoveryService.Url = String.Format(
                    "http://{0}:{1}/MSCRMServices/2007/{2}/CrmDiscoveryService.asmx",
                    hostName, hostPort, "AD");

                // STEP 2: Retrieve the organization name and endpoint Url from the
                // CrmDiscoveryService Web service.
                RetrieveOrganizationsRequest orgRequest = new RetrieveOrganizationsRequest();
                RetrieveOrganizationsResponse orgResponse =
                    (RetrieveOrganizationsResponse)discoveryService.Execute(orgRequest);

                String orgUniqueName = String.Empty;
                OrganizationDetail orgInfo = null;

                foreach (OrganizationDetail orgDetail in orgResponse.OrganizationDetails)
                {
                    if (orgDetail.FriendlyName.Equals(orgName))
                    {
                        orgInfo = orgDetail;
                        orgUniqueName = orgInfo.OrganizationName;
                        break;
                    }
                }

                if (orgInfo == null)
                    throw new Exception("The organization name is invalid.");

                // STEP 3: Create and configure an instance of the CrmService Web service.

                CrmAuthenticationToken token = new CrmAuthenticationToken();
                token.AuthenticationType = 0;
                token.OrganizationName = orgUniqueName;

                crmService = new CrmService();
                crmService.Url = orgInfo.CrmServiceUrl;
                crmService.CrmAuthenticationTokenValue = token;
                crmService.Credentials = System.Net.CredentialCache.DefaultCredentials;

                // STEP 4: Invoke CrmService Web service methods.

                WhoAmIRequest whoRequest = new WhoAmIRequest();
                WhoAmIResponse whoResponse = (WhoAmIResponse)crmService.Execute(whoRequest);

            }
            // Handle any Web service exceptions that might be thrown.
            catch (SoapException ex)
            {
                throw new Exception("An error occurred while attempting to authenticate.", ex);
            }
        }

For more information on using the CRM Discovery service with Active Directory authentication, click here. Following the authentication process, we can now implement the method that will insert or update a product in the Product entity.

        // Insert product method
        public void crmInsertProduct(
            string productNumber,
            string productName,
            string productVendorName,
            string productVendorItem,
            decimal productWeight,
            string defaultUnitOfMeasure,
            string defaultUnitOfMeasureSched,
            string defaultPriceLevel,
            string currencyID,
            int decimalsSupported,
            decimal quantityOnHand,
            decimal listPrice,
            decimal priceLevelPrice,
            decimal standardCost,
            decimal currentCost,
            int productTypeCode)
        {
            try
            {
                string strProductId;
                product crmProduct = new product();

                bool found = crmGetProduct(productNumber, out strProductId);
                if (!found)
                {
                    // is a new product, create
                    crmProduct.productnumber = productNumber;
                    crmProduct.name = productName;

                    // quantity decimal places
                    crmProduct.quantitydecimal = new CrmNumber();
                    crmProduct.quantitydecimal.Value = decimalsSupported;

                    // quantity on hand
                    crmProduct.quantityonhand = new CrmDecimal();
                    crmProduct.quantityonhand.Value = quantityOnHand;

                    // unit price
                    crmProduct.price = new CrmMoney();
                    crmProduct.price.Value = listPrice;

                    // standard cost
                    crmProduct.standardcost = new CrmMoney();
                    crmProduct.standardcost.Value = standardCost;

                    // Current cost
                    crmProduct.currentcost = new CrmMoney();
                    crmProduct.currentcost.Value = currentCost;

                    // Vendor Name
                    crmProduct.vendorname = productVendorName;

                    // Vendor Item
                    crmProduct.vendorpartnumber = productVendorItem;

                    // Shipping Weight
                    crmProduct.stockweight = new CrmDecimal();
                    crmProduct.stockweight.Value = productWeight;

                    //------------------------------------------------//
                    // Product type code                              //
                    //------------------------------------------------//
                    crmProduct.producttypecode = new Picklist();
                    if (productTypeCode != 0)
                        crmProduct.producttypecode.Value = productTypeCode;
                    else
                        crmProduct.producttypecode.IsNull = true;

                    // retrieve guid's for the default unit of measure
                    string strUofM;
                    string strUofMSched;

                    bool isUofM = crmGetUofM(defaultUnitOfMeasure, out strUofM, out strUofMSched);
                    if (isUofM)
                    {
                        crmProduct.defaultuomid = new Lookup();
                        crmProduct.defaultuomid.Value = new Guid(strUofM);
                        crmProduct.defaultuomid.type = EntityName.uom.ToString();

                        crmProduct.defaultuomscheduleid = new Lookup();
                        crmProduct.defaultuomscheduleid.Value = new Guid(strUofMSched);
                        crmProduct.defaultuomscheduleid.type = EntityName.uomschedule.ToString();
                    }

                    // create the product
                    Guid productId = crmService.Create(crmProduct);

                    // create pricelist
                    crmInsertProductPricelist(productNumber, defaultUnitOfMeasure, defaultUnitOfMeasureSched, defaultPriceLevel, currencyID, 1, priceLevelPrice, 0);

                    // Create the column set object that indicates the fields to be retrieved.
                    ColumnSet columns = new ColumnSet();
                    columns.Attributes = new string[] { "productid", "pricelevelid" };

                    // Retrieve the product from Microsoft Dynamics CRM
                    // using the ID of the record that was retrieved.
                    // The EntityName indicates the EntityType of the object being retrieved.
                    product updatedProduct = (product)crmService.Retrieve(EntityName.product.ToString(), productId, columns);
                    updatedProduct.pricelevelid = new Lookup();

                    string guidPriceLevel;
                    bool isPricelevel = crmGetPriceLevel(defaultPriceLevel.ToUpper(), out guidPriceLevel);
                    if (isPricelevel)
                    {
                        updatedProduct.pricelevelid = new Lookup();
                        updatedProduct.pricelevelid.Value = new Guid(guidPriceLevel);
                        updatedProduct.pricelevelid.type = EntityName.pricelevel.ToString();

                    }

                    // update the record
                    crmService.Update(updatedProduct);
                }
                else
                {
                    // Create the column set object that indicates the fields to be retrieved.
                    ColumnSet columns = new ColumnSet();
                    columns.Attributes = new string[] { "productid", "name", "quantityonhand", "price", "standardcost", "currentcost", "defaultuomid", "defaultuomscheduleid" };

                    // Retrieve the product from Microsoft Dynamics CRM
                    // using the ID of the record that was retrieved.
                    // The EntityName indicates the EntityType of the object being retrieved.
                    Guid _productGuid = new Guid(strProductId);
                    product updatedProduct = (product)crmService.Retrieve(EntityName.product.ToString(), _productGuid, columns);

                    updatedProduct.name = productName;

                    // quantity decimal places
                    updatedProduct.quantitydecimal = new CrmNumber();
                    updatedProduct.quantitydecimal.Value = decimalsSupported;

                    // quantity on hand
                    updatedProduct.quantityonhand = new CrmDecimal();
                    updatedProduct.quantityonhand.Value = quantityOnHand;

                    // unit price
                    updatedProduct.price = new CrmMoney();
                    updatedProduct.price.Value = listPrice;

                    // standard cost
                    updatedProduct.standardcost = new CrmMoney();
                    updatedProduct.standardcost.Value = standardCost;

                    // Current cost
                    updatedProduct.currentcost = new CrmMoney();
                    updatedProduct.currentcost.Value = currentCost;

                    // Vendor Name
                    updatedProduct.vendorname = productVendorName;

                    // Vendor Item
                    updatedProduct.vendorpartnumber = productVendorItem;

                    // Shipping Weight
                    updatedProduct.stockweight = new CrmDecimal();
                    updatedProduct.stockweight.Value = productWeight;

                    //------------------------------------------------//
                    // Product type code                              //
                    //------------------------------------------------//
                    updatedProduct.producttypecode = new Picklist();
                    if (productTypeCode != 0)
                        updatedProduct.producttypecode.Value = productTypeCode;
                    else
                        updatedProduct.producttypecode.IsNull = true;

                    // retrieve guid's for the default unit of measure
                    string strUofM;
                    string strUofMSched;

                    bool isUofM = crmGetUofM(defaultUnitOfMeasure, out strUofM, out strUofMSched);
                    if (isUofM)
                    {
                        updatedProduct.defaultuomid = new Lookup();
                        updatedProduct.defaultuomid.Value = new Guid(strUofM);
                        updatedProduct.defaultuomid.type = EntityName.uom.ToString();

                        updatedProduct.defaultuomscheduleid = new Lookup();
                        updatedProduct.defaultuomscheduleid.Value = new Guid(strUofMSched);
                        updatedProduct.defaultuomscheduleid.type = EntityName.uomschedule.ToString();
                    }

                    string guidPriceLevel;
                    bool isPricelevel = crmGetPriceLevel(defaultPriceLevel.ToUpper(), out guidPriceLevel);
                    if (isPricelevel)
                    {
                        updatedProduct.pricelevelid = new Lookup();
                        updatedProduct.pricelevelid.Value = new Guid(guidPriceLevel);
                        updatedProduct.pricelevelid.type = EntityName.pricelevel.ToString();

                    }

                    // create pricelist
                    crmInsertProductPricelist(productNumber, defaultUnitOfMeasure, defaultUnitOfMeasureSched, defaultPriceLevel, currencyID, 1, priceLevelPrice, 0);

                    // update the record
                    crmService.Update(updatedProduct);
                }
            }
            catch (SoapException ex)
            {
                throw new Exception("An error occurred while attempting to insert a record in the CRM product entity.", ex);
            }
        }

In order to establish whether a product should be inserted or updated in the Product entity, you must first lookup the product. That’s accomplished by invoking the crmGetProduct() method (to be implemented below). If the product is not found in the catalog, we can proceed to setup all the attributes to be inserted, then call the crmService.Create() method.

If the product is found, then we can just retrieve all the columns that will be subsequently updated, then invoke the crmService.Update() method to commit the changes.

Finally, the crmGetProduct() method is shown below:

        public bool crmGetProduct(string productNumber, out string pId)
        {
            pId = null;

            ConditionExpression condition1 = new ConditionExpression();
            condition1.AttributeName = "productnumber";
            condition1.Operator = ConditionOperator.Equal;
            condition1.Values = new string[] { productNumber };

            FilterExpression filter = new FilterExpression();
            filter.FilterOperator = LogicalOperator.And;
            filter.Conditions = new ConditionExpression[] { condition1 };

            ColumnSet resultSetColumns = new ColumnSet();
            resultSetColumns.Attributes = new string[] { "productid", "productnumber" };

            // Put everything together in an expression.
            QueryExpression qryExpression = new QueryExpression();
            qryExpression.ColumnSet = resultSetColumns;

            // set a filter to the query
            qryExpression.Criteria = filter;

            // Set the table to query.
            qryExpression.EntityName = EntityName.product.ToString();

            // Return distinct records.
            qryExpression.Distinct = true;

            // Execute the query.
            BusinessEntityCollection productResultSet = crmService.RetrieveMultiple(qryExpression);

            // Validate that an expected contact was returned.
            if (productResultSet.BusinessEntities.Length == 0)
                return false;
            else
            {
                bool productFound = false;
                foreach (product aProduct in productResultSet.BusinessEntities)
                {
                    if (aProduct.productnumber.ToUpper().Trim().Equals(productNumber.ToUpper()))
                    {
                        productFound = true;
                        pId = aProduct.productid.Value.ToString();
                        break;
                    }
                }

                return productFound;
            }
        }
    }
}

The beauty about Microsoft Dynamics CRM platform services is that it provides a number of methods and implementations that facilitate querying any piece of data stored in the platform. The above method shows the use of the ConditionExpression, FilterExpression and QueryExpression classes, that when combined together, form the basis of the query platform. Finally we can create a collection with the filtered Product entity and navigate to see if the product was found.

This completes the first part of our implementation, but here are some final notes and things that I discovered throughout the project:

1. Assemblies that will be registered against SQL Server require signing. You must create a strong name key file that will be used to sign your assembly. To do this, go to the project Properties and select the Signing tab.

2. You cannot simply register an assembly that references a Web service against SQL Server without creating an XML serialization assembly. Serialization assemblies improve the startup performance of the Web service calls. To do this, go the project Properties and select the Build tab. Select On from the Generate Serialization Assembly drop down list.

Keep in mind that the above code is only provided as a sample and that other implementations are required to deal with Unit of Measures and Price Schedules. The bottom line is, the crmGetProduct() method provides the basis for the implementation of the other methods not shown.

Friday, I will show you how to register the assemblies on Microsoft SQL Server and how to implement some basic triggers that will exploit the CLR stored procedures.

Until next post!

MG.-
Mariano Gomez, MVP
Maximum Global Business, LLC
http://www.maximumglobalbusiness.com/