Akezyt on MSDN

Moving to Thailand

Akezyt — Sat, 17 May 2008 17:02:00 GMT

As some of you might already know, I will be moving toThailand to join Health Solutions Group team. It was a great pleasure working with CRM team and I will continue to be CRM's biggest fan. Please let me know if you have question about CRM and/or my previous blog posts.

Debugging Plug-in

Akezyt — Wed, 07 May 2008 04:38:25 GMT

During MSCRM plug-in development, developer would want to test his/her plug-in before putting in production server to make sure it works as designed. One way to do it is to have a development environment to test plug-in. However, the turn around time between deploy-test-debug-build-deploy is very significant even putting plug-in on disk. It would be nice if we can test plug-in locally without deploying it on CRM server. The approach I am going to show is to execute plug-in in a small EXE container. Since IPluginExecutionContext is just interface, we can mock the context in our test container. Effectively, you will be able to rapidly develop/test/debug plug-in without ever leaving Visual Studio until you are ready.

I created a sample solution containing a simple test context and a test plug-in on code.msdn (http://code.msdn.microsoft.com/MSCRMPluginDebugger). This sample shows you how to populate relevant input parameters and how to create CrmService behind context. You might need to add more implementation to TestContext to suite your need but this sample should be a foundation you can build on for example pre/post image or MetadataService.

Developer can use this approach for both debugging during development or for writing unit test. It would enable ISV to write unit test and run it from test harness/framework such as one provided by TFS.

Even though mocking IPluginExecutionContext can emulate container that plug-in will execute in, it is only approximation. Other differences can still make running in production different from test context, for example:

- Security context. CRM runs plug-in in service account (usually network service). Test contain runs plug-in in currently logged in user context. Files/registries may be accessible from log in user but service account may not , and vice versa.

- HttpContext. Accessing HttpContext.Current is not recommended. If you need something that is available only HttpContext.Current, please let us know. Ideally, plug-in should be able to get everything from IPluginExecutionContext.

NOTE: Depending on currently logged in user, you may or may not be able to impersonate a particular user. Only AD user in PrivUserGroup can impersonate other user in CRM.

CRM plug-in registration tools

Akezyt — Wed, 13 Feb 2008 09:43:00 GMT

Ajith and friends had posted article about plug-in registration tools on CRM blog (http://blogs.msdn.com/crm/archive/2008/02/04/crm-registering-plug-ins-made-easy.aspx). Ajith is our tester on plug-in framework so he knows the ins and outs of plug-ins. This tools should make plug-in developer's life much easier.

Microsoft Dynamics CRM 4.0 Ready for Download.

Akezyt — Wed, 19 Dec 2007 05:26:00 GMT

After 2 years in the making, now CRM 4.0 is ready to roll.

Microsoft announced Monday that it has released to manufacturing the long-awaited update to its Dynamics-branded customer relationship management software (CRM).
Previously codenamed "Titan," the latest version of Microsoft Dynamics CRM actually has two names in its final form. For on-premise, customer-hosted, as well as partner-hosted deployments, the product has been dubbed Dynamics CRM 4.0. The company will also be offering the package on-demand in a Microsoft-hosted environment that it has named Dynamics CRM Live.

From: Internewnews

CRM Plug-in that exposes explicit method for each event.

Akezyt — Tue, 27 Nov 2007 09:23:00 GMT

Eventing framework in CRM v4.0 is designed from the ground up to be generic not just for Create,Update,Delete messages. As a result, IPlugin interface exposes only one generic Execute method. This allow CRM to support a large number of events without exploding the interface. The drawback is, this leave a considerably large gap between generic developer-focused infrastructure and specific business-oriented usage case.

However, a thin layer of wrapper can be created to wrap generic Execute and extract relevant input and output parameters. This sample covers only Create, Update, Delete, Assign, and SetState. However, some other events such as Send, Deliver, or Route can be easily added with the same pattern.

To use it, developers can create new plug-in (e.g. MyPlugin) by

Adding ExplicitPlugin.cs to their plug-in project.
Deriving MyPlugin from ExplicitPlugin.
Override methods that are relevant to your project

In addition to the part that expose PreCreate/PostCreate style methods, this code sample also shows how to generically access primary key of an entity inside DynamicEntity without using metadata. This can be useful when you don't have access to metadata.

I tested it on some messages so please let me know if there are some problems so I can update it.

As usual, this code is provided as-is....

MyPlugin.cs

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Crm.Sdk;
namespace MyPluginProject
{
    public class MyPlugin : ExplicitPluginBase
    {
        protected override void PreCreate(Moniker moniker, DynamicEntity entity, IPluginExecutionContext context)
        {
            CreateTask(moniker, entity, context);
        }
        protected override void PostCreate(Moniker moniker, DynamicEntity entity, IPluginExecutionContext context)
        {
            CreateTask(moniker, entity, context);
        }
        protected override void PreUpdate(Moniker moniker, DynamicEntity entity, IPluginExecutionContext context)
        {
            CreateTask(moniker, entity, context);
        }
        protected override void PostUpdate(Moniker moniker, DynamicEntity entity, IPluginExecutionContext context)
        {
            CreateTask(moniker, entity, context);
        }
        protected override void PreDelete(Moniker moniker, IPluginExecutionContext context)
        {
            CreateTask(moniker, context);
        }
        protected override void PostDelete(Moniker moniker, IPluginExecutionContext context)
        {
            CreateTask(moniker, context);
        }
        protected override void PreAssign(Moniker moniker, SecurityPrincipal assignee, IPluginExecutionContext context)
        {
            CreateTask(moniker, context);
        }
        protected override void PostAssign(Moniker moniker, SecurityPrincipal assignee, IPluginExecutionContext context)
        {
            CreateTask(moniker, context);
        }
        protected override void PreSetState(Moniker moniker, ref string state, ref int status, IPluginExecutionContext context)
        {
            CreateTask(moniker, context);
        }
        protected override void PostSetState(Moniker moniker, string state, int status, IPluginExecutionContext context)
        {
            CreateTask(moniker, context);
        }
        private void CreateTask(Moniker moniker, IPluginExecutionContext context)
        {
            CreateTask(moniker, null, context);
        }
        private void CreateTask(Moniker moniker, DynamicEntity entity, IPluginExecutionContext context)
        {
            ICrmService service = context.CreateCrmService(true);
            DynamicEntity task = new DynamicEntity("task");
            string prefix = "pre";
            if (context.Stage == MessageProcessingStage.AfterMainOperationOutsideTransaction)
            {
                prefix = "post";
            }
            Guid id = Guid.Empty;
            if (moniker != null)
            {
                id = moniker.Id;
            }
            task["subject"] = prefix + " - " + context.MessageName + " : " + id.ToString();
            if (entity != null
                && entity.Properties.Contains("firstname"))
            {
                task["description"] = entity["firstname"];
            }
            service.Create(task);
        }
    }
}

ExplicitPluginBase.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Globalization;
using Microsoft.Crm.Sdk;
namespace MyPluginProject
{
    public abstract class ExplicitPluginBase : IPlugin
    {
        public void Execute(IPluginExecutionContext context)
        {
            AdapterBase adapter = CreateConcreteAdapter(context);
            if (adapter != null)
            {
                if (context.Stage == MessageProcessingStage.BeforeMainOperationOutsideTransaction)
                {
                    adapter.ExecutePre(this, context);
                }
                else
                {
                    adapter.ExecutePost(this, context);
                }
            }
            else
            {
                ExecuteGeneric(context);
            }
        }
        private AdapterBase CreateConcreteAdapter(IPluginExecutionContext context)
        {
            switch (context.MessageName)
            {
                case MessageName.Assign:
                    return new AssignAdapter();
                case MessageName.Create:
                    return new CreateAdapter();
                case MessageName.Update:
                    return new UpdateAdapter();
                case MessageName.Delete:
                    return new DeleteAdapter();
                case MessageName.SetState:
                case MessageName.SetStateDynamicEntity:
                    return new SetStateAdapter();
                default:
                    return null;
            }
        }
        protected virtual void PreCreate(Moniker moniker, DynamicEntity entity, IPluginExecutionContext context)
        {
            ThrowNotImplementedException();
        }
        protected virtual void PostCreate(Moniker moniker, DynamicEntity entity, IPluginExecutionContext context)
        {
            ThrowNotImplementedException();
        }
        protected virtual void PreUpdate(Moniker moniker, DynamicEntity entity, IPluginExecutionContext context)
        {
            ThrowNotImplementedException();
        }
        protected virtual void PostUpdate(Moniker moniker, DynamicEntity entity, IPluginExecutionContext context)
        {
            ThrowNotImplementedException();
        }
        protected virtual void PreDelete(Moniker moniker, IPluginExecutionContext context)
        {
            ThrowNotImplementedException();
        }
        protected virtual void PostDelete(Moniker moniker, IPluginExecutionContext context)
        {
            ThrowNotImplementedException();
        }
        protected virtual void PreAssign(Moniker moniker, SecurityPrincipal assignee, IPluginExecutionContext context)
        {
            ThrowNotImplementedException();
        }
        protected virtual void PostAssign(Moniker moniker, SecurityPrincipal assignee, IPluginExecutionContext context)
        {
            ThrowNotImplementedException();
        }
        protected virtual void PreSetState(Moniker moniker, ref string state, ref int status, IPluginExecutionContext context)
        {
            ThrowNotImplementedException();
        }
        protected virtual void PostSetState(Moniker moniker, string state, int status, IPluginExecutionContext context)
        {
            ThrowNotImplementedException();
        }
        protected virtual void ExecuteGeneric(IPluginExecutionContext context)
        {
            throw new Exception("The method or operation is not implemented.");
        }
        #region Implementation details
        private void ThrowNotImplementedException()
        {
            throw new NotImplementedException();
            // throw new NotImplementedException(string.Format(CultureInfo.InvariantCulture, "{0} is not implemented.", methodName));
        }
        #endregion
        private abstract class AdapterBase
        {
            public abstract void ExecutePre(ExplicitPluginBase plugin, IPluginExecutionContext context);
            public abstract void ExecutePost(ExplicitPluginBase plugin, IPluginExecutionContext context);
            protected Moniker GetEntityMoniker(DynamicEntity entity)
            {
                foreach (Property property in entity.Properties)
                {
                    KeyProperty key = property as KeyProperty;
                    if (key != null)
                    {
                        return new Moniker(entity.Name, key.Value.Value);
                    }
                }
                return null;
            }
        }
        private sealed class CreateAdapter : AdapterBase
        {
            public override void ExecutePre(ExplicitPluginBase plugin, IPluginExecutionContext context)
            {
                DynamicEntity entity = (DynamicEntity)context.InputParameters[ParameterName.Target];
                plugin.PreCreate(GetEntityMoniker(entity), entity, context);
            }
            public override void ExecutePost(ExplicitPluginBase plugin, IPluginExecutionContext context)
            {
                DynamicEntity entity = (DynamicEntity)context.InputParameters[ParameterName.Target];
                Moniker moniker = GetEntityMoniker(entity);
                if (moniker == null)
                {
                    moniker = new Moniker(entity.Name, (Guid)context.OutputParameters[ParameterName.Id]);
                }
                plugin.PostCreate(moniker, entity, context);
            }
        }
        private sealed class UpdateAdapter : AdapterBase
        {
            public override void ExecutePre(ExplicitPluginBase plugin, IPluginExecutionContext context)
            {
                DynamicEntity entity = (DynamicEntity)context.InputParameters[ParameterName.Target];
                plugin.PreUpdate(GetEntityMoniker(entity), entity, context);
            }
            public override void ExecutePost(ExplicitPluginBase plugin, IPluginExecutionContext context)
            {
                DynamicEntity entity = (DynamicEntity)context.InputParameters[ParameterName.Target];
                plugin.PostUpdate(GetEntityMoniker(entity), entity, context);
            }
        }
        private sealed class DeleteAdapter : AdapterBase
        {
            public override void ExecutePre(ExplicitPluginBase plugin, IPluginExecutionContext context)
            {
                Moniker moniker = (Moniker)context.InputParameters[ParameterName.Target];
                plugin.PreDelete(moniker, context);
            }
            public override void ExecutePost(ExplicitPluginBase plugin, IPluginExecutionContext context)
            {
                Moniker moniker = (Moniker)context.InputParameters[ParameterName.Target];
                plugin.PostDelete(moniker, context);
            }
        }
        private sealed class AssignAdapter : AdapterBase
        {
            public override void ExecutePre(ExplicitPluginBase plugin, IPluginExecutionContext context)
            {
                Moniker moniker = (Moniker)context.InputParameters[ParameterName.Target];
                SecurityPrincipal assignee = (SecurityPrincipal)context.InputParameters[ParameterName.Assignee];
                plugin.PreAssign(moniker, assignee, context);
            }
            public override void ExecutePost(ExplicitPluginBase plugin, IPluginExecutionContext context)
            {
                Moniker moniker = (Moniker)context.InputParameters[ParameterName.Target];
                SecurityPrincipal assignee = (SecurityPrincipal)context.InputParameters[ParameterName.Assignee];
                plugin.PostAssign(moniker, assignee, context);
            }
        }
        private sealed class SetStateAdapter : AdapterBase
        {
            public override void ExecutePre(ExplicitPluginBase plugin, IPluginExecutionContext context)
            {
                Moniker moniker = (Moniker)context.InputParameters[ParameterName.EntityMoniker];
                string stateName = (string)context.InputParameters[ParameterName.State];
                int status = (int)context.InputParameters[ParameterName.Status];
                plugin.PreSetState(moniker, ref stateName, ref status, context);
                context.InputParameters[ParameterName.State] = stateName;
                context.InputParameters[ParameterName.Status] = status;
            }
            public override void ExecutePost(ExplicitPluginBase plugin, IPluginExecutionContext context)
            {
                Moniker moniker = (Moniker)context.InputParameters[ParameterName.EntityMoniker];
                string stateName = (string)context.InputParameters[ParameterName.State];
                int status = (int)context.InputParameters[ParameterName.Status];
                plugin.PostSetState(moniker, stateName, status, context);
            }
        }
    }
}

CRM V3.0 Service Scheduling Performance and Scalability White Paper

Akezyt — Sat, 22 Sep 2007 21:54:21 GMT

Our Business System Architecture (BSA) published Service Scheduling: Optimizations and Considerations white paper. It presented prescriptive guidance about what can customers/ISVs do to improve performance and scalability of Service Scheduling in CRM V3.0. It is based on their test and performance tuning on large deployment. It can be downloaded at http://www.microsoft.com/downloads/details.aspx?familyid=4E077F9F-A712-4CDC-BDEF-FB9969E46F2B&displaylang=en.

Service scheduling was my first team in CRM when I joined 3 years ago so I always have a special place for it. I should write more about it in the future.

Microsoft released Windows Live ID SDK

Akezyt — Thu, 23 Aug 2007 08:44:00 GMT

Last week Microsoft released Windows Live ID SDK. It is an update of the alpha it released sometimes ago. Last time I check the alpha, it still use IDCRL (unmanaged DLL). I will check this new update and post more details. Hopefully they release something that we can use from JScript.

SDK can be downloaded at http://dev.live.com/liveid/

CRM Queue Gadget passed 900 downloads

Akezyt — Mon, 20 Aug 2007 23:04:00 GMT

CRM queue gadget that I posted on gotdotnet 2 weeks ago now passes 900 downloads. Thank you everyone who downloaded and tried it out.

College students from Thailand won Microsoft Imagine Cup 2007

Akezyt — Wed, 15 Aug 2007 01:38:29 GMT

A team of college students from Thailand won Microsoft Imagine Cup 2007. This is really cool and should give more visibility to Thailand in IT and computer science arena.

By the way, one member of this team comes from my school (Chulalongkorn University).

From: Microsoft Announces Imagine Cup 2007 Winners

SOA in the Real World

Akezyt — Fri, 10 Aug 2007 19:43:37 GMT

While checking Loosely Couple Thinking, I found that an interesting eBook about Service Oriented Architecture, SOA in the Real World, now available.

You can download it from http://www.microsoft.com/downloads/details.aspx?FamilyID=cb2a8e49-bb3b-49b6-b296-a2dfbbe042d8&displaylang=en.

CRM Queue Gadget

Akezyt — Fri, 03 Aug 2007 19:40:00 GMT

Introduction

Microsoft CRM 3.0 shipped with an extensive web service API that can be used by various types of applications. Here is a sample Windows sidebar gadget (or just gadget) that retrieves queue items related to the currently logged in user every predefined interval. Since the gadget is always available on the desktop but small in size, the ideal information to display on gadget should be something dynamic and concise. In Microsoft CRM context, the queue item entity fits squarely as it is changed quite frequently and requires immediate attention from a user.

The code is provided at http://www.gotdotnet.com/Community/UserSamples/Details.aspx?SampleGuid=A6791FE6-5A4C-4432-8FBD-BBD8A499120B

Figure 1 "In progress" queue items

Figure 2 "Assigned" queue items

Figure 3 Settings window

Developing CRM Gadget

For more information about developing gadget in general, please refer to MSDN article in the resource section. This article will focus more on CRM specific aspects.

Retrieving data from CRM

Gadgets are composed of HTML and Jscript. We can use XmlHttp from JScript to send hand crafted SOAP message to the CRM server. Then we use an Msxml2.DOMDocument to parse the response to get the result. We need not do it asynchronously as the user is not blocked by the gadget anyway and it will be much more complicated to do it asynchronously.

In keeping with best practices, this sample retrieves only columns that are needed to reduce server load.

Reading and writing settings through the gadget infrastructure

The gadget infrastructure provides a nice API for reading and writing settings. Be careful about storing sensitive information though. In this case, we just store the CRM server name, polling interval, and queue type so we are okay.

For reading settings

var currentServerName = System.Gadget.Settings.readString("crmServerName");

For writing settings

var temp = serverName.value;

System.Gadget.Settings.writeString("crmServerName", temp);

Securing gadget

Gadgets also subject to all sorts of cross site scripting vulnerabilities, since they are also web applications. All user input should be validated before using it. All external data (including data from the CRM server) must be properly encoded before rendering.

Using standard style sheet

This sample utilizes template.css to make the gadget look consistent with the CRM web application. For example the server name label is shown as a required field. This template.css file is shipped with CRM SDK. You can download it from Microsoft.com.

Deploying gadget

Because this gadget is a real application though it looks cute; there will be a time that you will want to patch it after you ship. The best way to enable gadget patching is to deploy it with MSI. However, for simplicity of our sample, I just use the zip approach. All you need to do is zip all HTML, JScripts, CSS, and the manifest (gadget.xml) together and change the resulting file’s extension from .zip to .gadget. Then the user can install it by double clicking.

Resources

- MSDN Windows Sidebar Gadget Development Overview (http://msdn2.microsoft.com/en-us/library/aa965850.aspx)

- System.Gadget.Settings in MSDN (http://msdn2.microsoft.com/en-us/library/ms723661.aspx)

- Other CRM Windows sidebar gadgets

- CRM SDK (http://www.microsoft.com/downloads/details.aspx?familyid=9C178B68-3A06-4898-BC83-BD14B74308C5&displaylang=en).

Presenting at TechReady 5

Akezyt — Fri, 27 Jul 2007 01:38:00 GMT

This is the first time I present/demo in front of audience this size, quite an experience for me. Last time I checked, one of the session I presented/demoed is one of the top 5 session in business solutions.

For those who don't know, TechReady is Microsoft event about preparing partners and field sales for new products being launched.

Nice article about BizTalk Crm Adapter

Akezyt — Sun, 03 Jun 2007 17:50:00 GMT

I found this nice blog posts about BizTalk Crm Adapter. Check it out.

Another View of CRM Data

Akezyt — Sat, 24 Feb 2007 06:19:00 GMT

Cross posted from CRM team blog. I wrote this article last week and it was published this week.

Another View of CRM Data

[Code examples are on the CRM Sandbox in the downloads section.] MS Dynamics CRM shipped with grid view and form view for displaying data such as account or contact information. However, that does not mean it is the only way to present CRM data. This article will show a way to represent CRM accounts on a map.

Populating account's coordinate. Before we can show the account on the map, we first need to populate account's location into CRM. Most account/contact already contains shipping or billing address. However, they are not in the format that is easy to map or locate. Out of the box, account already contains 'latitude' and 'longitude' attributes that we can use but they are not automatically populated by CRM. So we need to convert the human readable street address into latitude and longitude coordinate. This process is called geocoding. For existing CRM deployment where accounts and contacts are created without latitude and longitude, we need to mass-populate them using web service information in the CRM SDK. The are several providers that offer geocoding service such as:

In this example, we use the MapPoint web service. It is free of charge but you need to register for developer account before you can use it. There are some restrictions on developer account so double check before using it on commercial system. For new account that will be created after this initial mass-populating, we could incrementally populate latitude/longitude for them using JavaScript on form's OnSave event or using server side callout. Sometimes, it might be easier to geocode each account's address on the fly and plot them on the map every time. However, doing so would cause serious performance and unnecessary load time. Moreover, after getting location data into CRM, we can do something interesting such as optimizing delivery/service truck route based on sales order's account/contact address. Displaying Account on the Map In this sample, we will just show each account on map using Virtual Earth map control (http://dev.live.com/virtualearth/sdk). It is quite easy to use after we get account’s latitude and longitude. Another interesting part is how do we query actual accounts from saved query. The steps are like this:

- Retrieve the actual fetch XML on savedquery entity. - Convert that fetch XML into QueryExpression object using FetchXmlToQueryExpressionRequest. - Use the QueryExpression to retrieve list of accounts.

For better performance, we can also cache the QueryExpression so we don't have to look it up every time and save 2 web service calls but we are not doing it for simplicity. JavaScript then use XmlHttpRequest to send request XML to our QueryService and gets back XML. I manually created request XML and parsed response XML. However, you can use ASP.Net AJAX to create JavaScript proxy and save some more time. Showing account in map view is just one of another way to use CRM data. We hope to publish some more examples in the near future. But for now, we trust this example will provide some interesting concepts and ideas to consider for your implementation of CRM.