CRM 2011 support multiple browsers

Microsoft Dynamics CRM 2011 Update Rollup 12 or the December 2012 Service Update has introduced additional browser compatibility for Firefox, Chrome, and Safari.

Browser flexibility will apply to all functions within Microsoft Dynamics CRM for both end users and administrators alike. The list of devices, operating systems and specific browser versions is detailed in the table below.

Platform	Internet Explorer	Firefox	Chrome	Safari
Windows XP	Version 7* and 8	Latest Version	Latest Version	Not Supported
Windows Vista	Version 7, 8, and 9	Latest Version	Latest Version	Not Supported
Windows 7	Version 8, 9, and 10	Latest Version	Latest Version	Not Supported
Windows 8	Version 10 for the desktop**	Latest Version	Latest Version	Not Supported
Apple OS X 10.7 (Lion)	Not Supported	Not Supported	Not Supported	Latest Version
Apple OS X 10.8 (Mountain Lion)	Not Supported	Not Supported	Not Supported	Latest Version

*Internet Explorer 7 is not supported for Microsoft Dynamics CRM Online. Windows XP users must use Internet Explorer 8 for Microsoft Dynamics CRM Online.

**Internet Explorer 10 compatibility is limited to the desktop browser and does not extend to the touch-based version.

***Windows RT is not currently supported.

Why Dynamics CRM Complements SharePoint

Dynamics CRM 2013 is about to be released and if you have already made a large investment into SharePoint as a development platform, you may be asking yourself why Dynamics CRM matters.  After all, you are already using a wildly successful platform that underpins collaboration tools, intranets, your ‘corporate’ social media and quite likely a base of custom applications and tools. Why would you need yet another platform if SharePoint is capable of handling everything you throw at it?

First off, let’s clear up a misconception that everyone generally has the first time they hear about Dynamics CRM: it’s not “Dynamics versus SharePoint,” it’s “Dynamics AND SharePoint.” Dynamics CRM offers some pretty significant benefits that are not available when using the SharePoint platform alone. Likewise, SharePoint has capabilities that Dynamics CRM simply wasn’t designed to even begin to replicate. The trick is knowing when and how to best leverage the benefits of each tool. Simply put, both tools need each other to offer a truly complete platform that offers you the best of everything: a collaboration tool, an intranet and content management tool, a repository for unstructured data, an application platform, and a quick and easy way to rapidly and efficiently build applications to manage structured data.Let’s look at the benefits of each tool to see how they complement each other:
A quick summary would boil down to: SharePoint is great at managing unstructured data; Dynamics CRM is great at managing structured data. Both systems quickly run into limitations when you try to force either one to interact with the type of data that they were not designed to manage. When trying to manage structured data with complex relationships in SharePoint, you often need to resort to writing custom code and standing up external (non-SharePoint) databases. While this is still quicker than writing a completely custom application, the fact is that you are now engaged in software development and all the risks and costs that development entails.
Dynamics CRM is not intended to support the constant rapid provisioning of separate ‘sites’ like SharePoint and in fact, it simply relies on SharePoint to manage any unstructured data. Knowing the fundamentally different type of data that each system is meant to manage, we can establish when and how we would use both together to provide us with the best combination – a platform which meets our all of our needs as efficiently as possible.


Common Scenarios for SharePoint

Intranet:  Your organization needs to provide controlled and secured access to private information, such as policies, standard operating procedures, guides, wikis, knowledge bases, etc. SharePoint easily adapts to the wide variety and types of data and is the best solution in this case.
Collaboration Portal: Teams in your organization need to work with each other by sharing documents, information and strategies, all while ensuring that team members do not step on each other’s toes. SharePoint allows you to quickly provision these portals, configure them for each team, and subsequently manage the data that they generate.
Aggregating and Exposing Information: Most organizations have data stored over multiple systems, with no common way to expose it for users to interact with.  SharePoint provides advanced data aggregation, manipulation and exposure capabilities by interacting with SQL Server, Microsoft Excel Services, and other data management solutions.

 

 

Common Scenarios for Dynamics CRM

Building Agile Applications:  One of the most significant risks of software development is the fact that most applications are built against outdated or incorrect requirements because it takes too long between gathering requirements and producing the application. Agile methodologies attempt to address this, but they often rely on the same tools that necessitate a lengthy development cycle before the user can see anything that looks remotely like the application. Dynamics CRM allows developers to incrementally build applications, with functionality added over time, yet constantly remain in a ‘usable’ state which users can review.

Building Data Management Applications: Every organization has to manage some complex data. Example of these applications include HR/Employee Management tools, Asset and Inventory Tracking, Case Management, Tasker Management, and Activity Tracking, among many, many others.  Dynamics CRM allows these tools to be built using a “point and click” interface, eliminating the need for dedicated developers.
Rewriting Legacy Applications: Every organization has a legacy application that “needs” to be re-written. This need is often ignored because these applications are complex, were developed over years of evolving requirements, and are still limping along. Rather than waiting until the need is critical, organizations can use Dynamics CRM to re-write the application in a small fraction of the time required to completely re-write the tool from scratch.
 

It’s not a question of which system is best – it’s a question of which system is right for a particular job. Both SharePoint and Dynamics CRM have their strengths, but they ultimately end up complementing one another and provide balance and support for the weaknesses that each tool has under varying scenarios. Building a holistic platform that combines both Dynamics CRM and SharePoint is the first step. Using each tool to gain the utmost advantage from the combined platform is the second step. How well organizations do that depends on how well they appreciate the respective strengths of each component, how mature their governance process is for choosing the solution for each problem, and how comfortable their solution architects are using both platforms.  Once an organization successfully implements both SharePoint and Dynamics CRM, they will find that they have a platform that allows them to further reduce development costs and risk, and also provides solutions that their users genuinely want to use.
 

 

 

E-mail to Case/Lead Using CRM 4 Workflow

A frequently asked question is about converting an incoming email into a case (or a lead). If you open an email activity, it has actions to convert it into a case or a lead or opportunity. More commonly, there is a need to automate this process.
In this blog, I’ll give a walkthrough’ of how you can use CRM 4.0’s workflow capabilities to automatically convert emails into cases. Say you want to automatically create a case for every email sent to: support@mycompany.com
At a high level, you need to:

1) Create a queue and map it to the email address at which email messages will be received (support@mycompany.com in this example)
2) Configure the queue to automatically create email activities for incoming email.
3) Create a workflow rule on email activity create. This workflow rule will be defined to create a case based on the email activity being created.

Create/Configure a Queue

You can create a queue by going to Settings -> Business Management -> Queues. For email integration to work with Queues, it is important that email integration be setup correctly. http://blogs.msdn.com/crm/archive/2008/02/07/crm-4-0-e-mail-integration-overview.aspx has a good overview of how to do this.
In my example, I’ve named the queue ‘MyCompany Support Issues’ and configured it to automatically create email activities for all emails received at support@mycompany.com

Define Workflow Rule

For this blog, I want to use only the workflow UI to define the workflow rule and avoid having to use custom workflow assemblies. Here is an outline of the logic we want to execute in the workflow:

When an email activity is created
{
If the email is sent to: ‘support@mycompany.com’ then
{
Create a case. Set fields on the case based on the fields of the email activity.
Update the email activity – set the email activity as regarding the case that was created above.
}
}

Here is how to do this thru’ the workflow UI editor:
1. From settings -> Workflow, select create a new blank workflow and select the Entity as E-mail

2. Configure properties of the workflow – I’ve set the scope to be organization and made it available for on-demand execution. If the workflow is marked as available to run on-demand, On-demand execution makes it easy for me to test the workflow
3. Add a check condition step and configure the step. This step will check if the email was sent to the support queue.

a. Select Email from the first drop-down list.
b. The 2^nd drop-down now lists all the fields available on the Email activity. You can select the To field or the To Recipients field. The To Recipients field is useful if the email is sent to multiple recipients.
c. Select the Equals operator for the 3^rd drop-down
d. To set the value that the To field should equal, click on the lookup, select ‘Queue’ for the Look For drop-down and search. You should find the queue that you created.

e. If you decided to use the To Recipients field, simply type in the email address as shown below.
f. Save and Close the condition.

4. Add a create record step if the above condition is true and configure it. This step will create a case and properties of the case will be set based on the incoming email.

a. Select ‘Case’ as the entity to be created and use the ‘Set Properties’ button to configure how the case should be created.
b. For the case title, I used the workflow editor’s ‘Dynamic Values’ capability to set the title of the case to be the same as that of the incoming email activity’s subject. The online help for the workflow page has more details on how to use dynamic values.
c. Creating a case requires at least a customer and a subject to be specified. If the email is from someone who isn’t already in the system, you might want to have the workflow rule create a contact for the sender. To keep the example simple, I’ve opted to use a default contact (a contact named Test) if the sender is not recognized.
d. Save and close the create case step.

5. To link the email activity to the case created, add an update step on Email entity. Update the email’s regarding field to be the case that was created in the previous step.

a. On the form assistant, select ‘Create Case (Case)’ for the LookFor drop-down. The next drop down will now show the fields on the case record that are available (such as the case itself, or the customer with which the case is associated etc). Select ‘case’ for the second drop down, hit the ‘Add’ button and ‘ok’ to finish the association.

6. Hit the ‘Publish’ button to publish the workflow.

7. Test the workflow by creating an email activity. Set the To field on the email to be the queue. You should find that a case has been created for the email and the email activity is now regarding the case that has been created as shown below.

The above workflow is an example of a simple email to case conversion. If you have more complex conversion requirements, you might find that you might need to write a custom workflow assembly to implement your requirements.

CMS or ECM – What is the difference?

The whole world often seems full of unfathomable jargon, and no one tops the information technology industry for its love of the Three Letter Acronym (TLA). Two TLAs that cause much confusion in our industry are CMS and ECM. Although there are similarities between the two, there are crucial differences that should be cleared up.

Despite what your web content management system (CMS) vendor may tell you about their ‘enterprise’ capabilities, rest assured that there is a huge difference between having an ‘enterprise content management’ (ECM) strategy and implementing a CMS. Unfortunately, despite considerable vendor and analyst literature on the subject, it appears that many CIO’s, CTO’s and IT Directors dive straight into CMS procurement without considering the bigger picture.

Definitions

Let us start of with some definitions before we head into a more in depth examination:

CMS     Content Management System
              Software used to create, edit, manage, and publish content in a        
              consistently organized fashion.

(Source: Wikipedia)

ECM     Enterprise Content Management
              The technologies used to capture, manage, store, preserve, and deliver
              content and documents related to organizational processes. ECM tools
              and strategies allow the management of an organization's unstructured
              information, wherever that information exists.

(Source: AIIM)

The first obvious difference we see here is that the CMS definition explicitly mentions software; it’s a software system (or systems) for a specific use (managing and publishing content – whatever that is!).  On the other hand, the ECM definition mentions both strategies and tools. So let us take a look at the roots and history of our two TLA’s.

Etymology and history

CMS as a term has been around longer, and its use is generally considered to address a system which manages content that requires publishing ‘to the web,’ be that the public Internet, or an internal company intranet.  So in this context, ‘content’ can refer to news items, marketing collateral, employee handbooks, etc.  Usually (but not always) this web publishing role means that the content is in web-focused formats, such as HTML, XHTML, etc., although as the web evolves, audio and video formats are becoming more prevalent.
A CMS can possibly provide many different features and tools, mostly around the ‘management’ part of the equation, but we will return to this later. More recently, the term Web Content Management System (WCMS) has been used to differentiate these systems from the other CMSs, but more on that later too.
ECM as a term is much younger, but it has a more convoluted history. As we have seen from the AIIM definition, ECM is as much about strategy as software, and you can have a strategy that addresses the creation (or capture), storage, management, preservation, and delivery of your content and documents without having a particular software system (or systems) to help you do it.
Notice that the AIIM definition also explicitly states ‘documents’ as well as content.  This is where the history comes into play, as many of the big ECM vendors have their roots in document capture (scanning) and document management rather than web content.

Content or documents?

Although this is really semantics, most experts would suggest that within the overall heading of ‘information’ the term ‘content’ usually applies to any form of ‘unstructured’ information ( as opposed to structured information  which is the stuff held in nicely ordered rows and columns in a database). So to apply some hierarchy to this the following can be seen as ‘sub-types’ of content:

• Web content (HTML / XHTML / DHTML / Flash files)
• XML (of various flavors, including its pre-cursor SGML)
• Documents (MS Office, PDF, etc.)
• Records (as in official documents, not old fashioned vinyl!)
• Digital assets (audio, video files)

But of course all of these definitions are just meant to help us categorize our ‘stuff’ and are interchangeable to one extent or another. For example MS Office can save files in an XML format which can be ‘published’ on a web site or in print.

ECM and CMS similarities and differences

Let us look at some of the similarities between a CMS and an enterprise content management system (ECMS): They will both provide facilities generally termed ‘library services’ (i.e., check in/out, version control, workflow etc.) so let us use the categories from the AIIM definition:

AIIM category	CMS	ECMS
Capture / Create	Built in editors and integration with MS Office	Built in editors and integration with MS Office, plus integrated scanning or imaging
Manage	Library services and metadata management, approval or editorial workflows	Library services and metadata management, plus records retention and disposal. Complex workflow as part of Business Process Management
Store	Work in progress, staging and ‘live’ environments may all hold copies of same version	Sophisticated storage management including integration with storage hardware plus ‘single instance’ storage or other de-duplication technologies
Preserve	Snapshots of websites and content	Long term archiving and digital preservation, more integrated with storage
Deliver	To the web including mobile devices	To the web, to the desktop client, to other software and systems, to print, etc.

So, as we can see, generally a CMS provides features to manage web content, and an ECMS will take these features and facilities further by extending them into different areas such as:

• Document imaging
• Document management
• Records management
• Digital asset management
• Workflow management / Business process management
• Web content management
• Knowledge management
• Collaboration

You will note that there are point solutions that each major on managing a single one of these content types, whereas an EMCS is a ‘suite’ of software aiming to manage them all. One of the major differences between a CMS and an ECMS is in the area of Business Process Management (or BPM) or ‘workflow’. While a web-focused CMS may have workflows ranging from simple to quite complex based around editorial processes and authorization of what reaches the live web site, an ECMS is likely to have a full visual workflow design tool and a much heavier weight feature set for designing whole business processes.
Finally, on the Web 2.0 / enterprise 2.0 / social media front, a CMS might offer you the ability to build such features into a site, whereas an ECM system usually offers web or ‘fat’ clients to allow users to collaborate around the content in the ECM repository.

Summary and conclusions

In the end it all comes down to your particular context, and what your business requirements are. If you’re a small to medium company manufacturing widgets and you want a better website to sell more widgets, and a better intranet to improve employee communications, then your probably in the market for a CMS.
If you’re a medium to large enterprise, and most of your staff come under the heading of ‘knowledge workers,’ and terms such as Enterprise Information Management, or Information Lifecycle Management are not completely alien to you, then you probably need a ECM strategy as part of your wider information management efforts – you may buy a an ECM suite from one of the big vendors, or you may implement your strategy using multiple ‘best of breed’ products (some of which you may already have), including a CMS. However, all content management requires planning; see the article by Toby Ward, Content Management Proves Costly Without Planning for some more information on that topic.
The main point here is to think holistically about your requirements.  If you think you need a new CMS, check around and see if other departments need a document management solution, and ask your legal and compliance people if they are investigating records management. Think strategically about information management and cast a wide net.  This does not mean you have to ‘bite it all off’ in one go and have a massively complex implementation. ‘Think globally, act locally’ is a good analogy; a phased implementation with pilot projects is established good practice.
In conclusion, implementing ECM is more about strategy, it will require more work than implementing a point solution using a CMS, but in the long run its ‘more pain, for more gain’ – in this digital age, competitive advantage awaits those organizations which realize information is a key asset, and manage it accordingly.
Whichever journey you’re on, Prescient Digital Media has the expertise and experience to help you to both understand your requirements and fulfill them. See our CMS Blueprint for some more information on our services.

Control Architectures

The spectrum of control architectures (Figure 1) goes from centralized to decentralized structures. Movement in any direction implies a trade-off between oversight and efficiency, on the one hand, and local autonomy and operational flexibility, on the other. The following are the most common control architectures.

Figure 1: The spectrum of control architectures



Centralized – Has the advantage of relatively simple control; however, if the situation for which it is configured changes, then a massive effort is required to reconfigure it. Is characterized by a single point of failure, resulting in a lack of general robustness.
Heterarchical (or fully decentralized) – Relatively robust because there is very little to break, but this lack of structure also makes it very difficult to control and makes undesirable chaotic behaviour possible.
Hierarchical – Consists in a top-down decomposition of control. Is efficient in that it forces an expected behavior; but is inflexible and branches can become uncontrollable if an intermediate element is incapacitated. Autonomy of nodes is quite limited.
Federated – A compromise between hierarchical and heterarchical structures. Like the latter, the nodes have a high degree of autonomy but communicate through specialized middle nodes. Has improved robustness and flexibility over the other architectures, but does not allow for dynamic restructuring.
Holarchical (or holonic) – A hybrid, recursive and hierarchical structure which is able to generate dynamic linkages to form an impromptu control structure. Couples the flexibility of fully decentralized architecture with the stability and predictability of a centralized and hierarchical control.

The control structure defines the performance of an organization to the extent that it defines its authority structure; it affects task and resource allocation (MacMillan et al. 2002); it indirectly affects performance by influencing collaborative processes; and it defines the external fit of the organization, that is, its adaptability to changing situations (Hollenbeck 2000). Given that they involve several organizations, MOS preclude control structures that assume a single chain of command, such as centralized, hierarchical, or holarchical architectures. In fact, MOS are constituted of autonomous and sovereign organizations that try to exploit a networked environment, and this entails the use of a decentralized architecture, where generally an administration board is used as means of governance. However, when a new entity is created, the latter, as a new organization, can have a centralized or hierarchical command, which can sometimes become problematic. Control structure in MOS must be rather defined in terms of the intensity of control (partial or full) of partner organizations on their representatives in the collaboration space, endowing it with more or less autonomy as a new organization. Another issue is the power relationships between the partner organizations, which can give one party more decision making authority and thus more global control over the mission of the newly created MOS.

Microsoft Dynamics CRM Upgrade Vs. Re-Implementation

As a veteran of many Dynamics CRM upgrades, I’ve come to identify and expect many of the pitfalls and opportunities that come with upgrading CRM from one version to the next. However, a recent experience caused me to re-evaluate these assumptions.
We had a client with a mature CRM 4.0 deployment moving from their host company to a brand new start up. They needed to transition their on-premise Sales CRM 4.0 instance in its entirety to Dynamics CRM 2011 online, with new reporting servers, new Active Directory (Office 365), etc.
What finally moved them to decide upon a re-implementation was the move from on-premise to online. There is currently no easy way to achieve this short of a full data migration effort (potentially using the new Microsoft Instance Adapter), and because a data migration effort was going to be involved anyway, the client decided to take advantage of the opportunity to revise their data model and code base, hence the re-implementation.
Comparing CRM Re-Implementation With CRM Upgrade
The benefits of a re-implementation for this client were:
a.  Scrub of the schema. 5 years of accumulated fields and forms were all cleaned up outside of the CRM application
b.  Selective import of data. Inactive contacts older than 3 years were not imported at all. The same logic applied to activities, leads, deactivated accounts, and attachments.
c.  Optimization of code for 2011. Rather than fix the code prior to the upgrade occurring, or during the import process of the 4.0 DB to a 2011 DB, the code can be optimized offline.
d.  An opportunity to manage and include different data sets other than the Sales CRM instance into the data migration prior to load.
e.  For migrations of instance from on-premise to the cloud, where a migration is essential, the opportunities identified above are too good to miss!
Not all of these are mutually exclusive when compared to an upgrade, but are significantly easier to manage when dealing with a tabula rasa style environment.

For parity, the upgrade path offers the following benefits:
a.  Automatic migration of data.
b.  Mapping of Users to the new domain users, and historical mapping of old, unmatched users.
c.  A transition of all client side code and database stored plugins.
d.  A transition of workflows.
The Process
Re-implementation forces a deep dive into the minutiae of the existing CRM environment. This is otherwise only really done when an environment is initially set up, or for certain key releases of functionality. (In the case of the latter, it is still unlikely that the entire application is reviewed.)
Accordingly, a data-map was constructed for all entities in the source application that needed to be migrated. In addition, this data map also contained details of all forms and views currently in use, and the sequencing and labeling of the included fields.
What followed was a painstaking process of field by field examination by Madrona and the client to evaluate the use and label of each of these fields (sample below). Due to the scale of the project, we identified a single resource on the Madrona team to own the schema map process and document. We all contributed, along with the client, and the schema master ensured that our versioning was maintained.
Sample: The red highlights indicate a field no longer needed. Note the schema renaming:





Once the data map was confirmed, we began planning the migration of the existing CRM data into the new application. Clearly the sequencing of this was key, as we were not simply inserting rows into SQL, we were migrating to the online CRM 2011, and so we need to use the API at all times.
Final Post Re-Implementation Thoughts
Having recently completed this project, we had some key takeaways as it relates to this debate that we will take into our next project of this type:
1.  Set expectations early that the process of re-mapping, as time consuming as it is, needs to be replicated at the testing phase by the client so as to ensure the data migrations occur exactly as planned
2.  The ability to manage the dataset outside of a CRM environment, and to include new data into the mix during the transition, is an opportunity that is unique to the re-implementation process. If you have a great deal of data normalization to perform, and are due an upgrade, it is worth considering re-implementation for this alone. In this case, we on-boarded a Support function into CRM along with the Sales team, and used this process to merge Account and Contact data
3.  Code transition was excellent. Being able to do this independent of the data migration was a great plus. This and the schema change opportunity are the stand-out advantages of the re-implementation.
4.  The relationship between CRM and external reporting teams (in this case, a data warehouse team that had been doing weekly extracts from CRM) needs to be established early and considered a key part of the process. With schema renaming and fine tuning of the data migration process, large impacts can be seen downstream for reporting especially if they are using GUIDs as key identifiers.
Finally, based on our experience, here is a comparative table of each:

Area	Upgrade	Re-implementation
Moving from on-Premise to Online.	Not applicable. Even if you upgrade to match the current version you still need to migrate to the cloud via re-implementation.	Essential.
Data Migration.	No risk.	Complicated. Complete field mapping required, plus design of the migration process itself and sequencing of the imports.
Data integrity.	No risk.	Higher risk due to re-structure of data. Not able to fully replicate all deactivated system users in CRM online either (need to map to a service account instead).
Data model changes.	Complicated. Can only be completed either live in the source application pre-deployment, or once upgraded.	Easier.
Removal / culling of data.	Done only via the CRM user interface and bulk deletes, or a third party API tool.	Easier.
Merging and adding additional Data.	Complicated. Traditional data migration with downstream effects (data clean up and de-duplication).	Managed outside of CRM, much simpler insertion into the CRM application.
CRM SSRS Reports.	Reports are moved over into the new instance automatically. The reports are not tested automatically.	Reports have to be optimized offline and deployed anew to the re-implemented instance.
Other Reports.	Aside from a change of Organization name or hardware, the data model and guides will all remain identical.	Potentially complicated dependent upon reporting model. If a schema re-structure has occurred, commensurate work may be required with reporting model.
Code Optimization.	Either let the upgrade process tell you where you code has failed (or the upgrade may even fail!) and then fix.	Re-implementation forces a code review, due to schema revision. Code situation will not prevent successful data migration. Easier for developers.
Workflows.	Upgraded automatically. May need fixing is dependent code breaks.	Need to be manually re-created.

Integrating Microsoft Dynamics CRM 2011 with BizTalk 2010

As I told in my previous post, I am working at a customer where we are trying to integrate Microsoft Dynamics CRM 2011 using BizTalk 2010. Since CRM 2011 does not have a BizTalk adapter anymore, we have to use the webservices it exposes, which can be used in BizTalk in 2 ways. I first tried to use the untyped option, where you would have to use mappings with custom XSLT for your communication to the CRM service. I ran into a lot of problems with this, and then decided to use the typed option instead. Using this option, you will create a helper class that does the communication to CRM, which you can then use from your orchestrations. While looking for more resources on this, I ran into this video Peter Kelcey created, which I used as my basis for my solution. The full source for my solution can be found here.

Get CRM Types

The first thing you will need to do is to get the CRM 2011 SDK if you have not done so yet. In the SDK you will find a file called crmsvcutil.exe. Using this, you create a helper class containing all your CRM entities. To use this, execute it from the command line as following:

"C:\Location\Of\Microsoft Dynamics CRM 2011 SDK\bin\crmsvcutil.exe" /url:https://company.crm.ms-hosting.nl/XRMServices/2011/Organization.svc /out:CRMHelper.cs /username:user@company.com /password:Pass@word1

The first parameter, url, is the URL where your organization service is living. The second parameter, out, is the class that will be created. The username and password parameters are the credentials of a user in CRM with enough rights to actually use the webservice. Once you have created the helper class you can add this to your BizTalk project.

Service Wrapper

Next we are going to create a new class, that will hold various helper classes used communicate with CRM. I simply call this class HelperMethods.cs. Make sure you add a reference to microsoft.xrm.sdk.dll, which can be found in the CRM 2011 SDK.

using System; using System.Collections.Generic; using System.IO; using System.ServiceModel.Description; using System.Text; using System.Xml; using System.Xml.Serialization; using Microsoft.Xrm.Sdk.Client; using Microsoft.Xrm.Sdk.Query;   namespace Company.BizTalk.CRM.BusinessComponents { /// <summary> /// Methods used to communicate with Microsoft Dynamics CRM 2011. /// </summary> internal static class HelperMethods {   } }

The first method we are going to set up is where we create a connection to CRM. As always, I have extensively commented my code, so it should be pretty easy to see what everything does. I have a seperate Constants class, where I have stored several strings for username, password, etc. The method finally returns a connection to our CRM system.

/// <summary> /// This method opens a connection to CRM 2011 and returns a proxy object that can be used to create, update, read, delete and execute events in CRM. /// </summary> /// <returns>The proxy used to connect to the CRM webservice.</returns> internal static OrganizationServiceProxy CreateServiceProxy() { // The proxy used to connect to the CRM webservice OrganizationServiceProxy serviceProxy; // Set the URL for the CRM organization webservice Uri organizationUri = new Uri("https://" + Constants.CRMOrganizationName + ".crm.ms-hosting.nl/XRMServices/2011/Organization.svc");   // The user credentials we need to provide are the credentials that we use to access CRM ClientCredentials credentials = new ClientCredentials(); credentials.UserName.UserName = Constants.CRMUserName; credentials.UserName.Password = Constants.CRMPassword;   // This is only used when you want to connect to CRM online // Seeing how I use the on-promise CRM I will not be using this, but I will let it in for reference purposes // The device credentials that we use must have been generated by the CreateCRM2011Device application, which is available at http://code.msdn.microsoft.com/CRM2011Beta/Release/ProjectReleases.aspx?ReleaseId=4944 // If you do not have these credentials, download the application, run it and a new Device username and Device password will be generated for you ClientCredentials devicecredentials = new ClientCredentials();   // Create the service proxy serviceProxy = new OrganizationServiceProxy(organizationUri, null, credentials, devicecredentials);   // This next method enables support for early bound types // If you forget this line, you'll get a "value cannot be null" exception serviceProxy.EnableProxyTypes();   // Return the proxy return serviceProxy; }

And here is what the constants class looks like.

using System; using System.Collections.Generic; using System.Linq; using System.Text;   namespace Company.BizTalk.CRM.BusinessComponents { /// <summary> /// Class containing all constant values used in the helper classes. /// </summary> internal static class Constants { /// <summary> /// The name of the column with the email addresses for contacts. /// </summary> internal static string ContactEmailAddressColumnName { get { return "emailaddress1"; } }   /// <summary> /// The name of the organization used to connect to the CRM webservice. /// </summary> internal static string CRMOrganizationName { get { return "company"; } }   /// <summary> /// The username used to connect to the CRM webservice. /// </summary> internal static string CRMUserName { get { return "eldert.grootenboer@company.nl"; } }   /// <summary> /// The password used to connect to the CRM webservice. /// </summary> internal static string CRMPassword { get { return "Pass@word1"; } } } }

Converting schema’s to C# classes

To be able to easily use the schema’s from BizTalk in our code, we should create C# classes to do this. For this the xsd.exe tool can be used. This tool can be found in the folder

Program Files (x86)\Microsoft SDKs\Windows\v7.0A\Bin\NETFX 4.0 Tools

Using this tool you can create a C# class with schema by running the following from a commandline:

Program Files (x86)\Microsoft SDKs\Windows\v7.0A\Bin\NETFX 4.0 Tools\xsd.exe C:\Location\Of\YourSchema.xsd /c /o:C:\Location\Of

If you use the same output folder as the where the input xsd file is located, you can attach it to the schema in Visual Studio by using the Show All Files button, and then including it in the project. Do this for all schema’s you will be receiving from your orchestration (probably your canonicals), which will contain the objects you want to transfer to or from CRM.

C# to XML Documents

Since we only want to use XMLDocuments in BizTalk itself, we are also going to create a class which is used to create XMLDocuments from our classes representing the schema’s (which we created in the previous chapter). To do this, we will add another method to the class we just created. This method will take a C# object, and serialize it to a XML document.

/// <summary> /// Create an XML document from a C# object. /// </summary> /// <param name="objectToMakeXmlDocument">The object to be serialized.</param> /// <returns>The serialized object as an XML document.</returns> internal static XmlDocument CreateXmlDocument(object objectToMakeXmlDocument) { // The serializer we will use var xmlSerializer = new XmlSerializer(objectToMakeXmlDocument.GetType());   // Create a new StringBuilder, that will create a string with the XML document var stringBuilder = new StringBuilder();   // Serialize the object into the StringBuilder xmlSerializer.Serialize(new StringWriter(stringBuilder), objectToMakeXmlDocument);   // Create an XML document XmlDocument document = new XmlDocument();   // Load the XML from the StringBuilder document.LoadXml(stringBuilder.ToString());   // Return the XML document return document; }

CRM Actions

The next class we are going to create will contain the actions we want do on CRM, like retrieve, insert, update and delete.

using System; using System.Collections.Generic; using Microsoft.Xrm.Sdk; using Microsoft.Xrm.Sdk.Query;   namespace Company.BizTalk.CRM.BusinessComponents { /// <summary> /// Class containing the various actions that can be done in CRM, like select, create, update, etc. /// </summary> internal static class CRMActions {   } }

My first method in this class will be used to look up entities. CRM has to retrieve functions, one uses the ID of an entity, the other can use a custom condition. Since we wanted to be able to find contacts by using the email address, I used the second option. This method creates the query to be used, sends this to CRM, and returns the entities that were returned by CRM.

/// <summary> /// Retrieves multiple entities using a query. /// </summary> /// <param name="entityName">The logical name of the entity which we want to work on.</param> /// <param name="conditions">The query to be used.</param> /// <returns>A collection of entities.</returns> internal static DataCollection<Entity> RetrieveMultipleEntities(string entityName, List<ConditionExpression> conditions) { // Create the proxy var serviceProxy = HelperMethods.CreateServiceProxy();   // Execute the query and return the result return serviceProxy.RetrieveMultiple(HelperMethods.CreateRetrieveMultipleQuery(entityName, conditions)).Entities; }

As you can see a list of ConditionExpression is used, which is used to set up a filter. It contains a column on which we want to filter, the operator to be used (f.e. equals or like), and the value we want to find.
Also I use a method called CreateRetrieveMultipleQuery in the HelperMethods class. This method is used to create the QueryExpression that will be sent to the CRM webservice, and looks like this:

/// <summary> /// Create a query that will retrieve multiple entities from CRM. /// </summary> /// <param name="entityName">The logical name of the entity.</param> /// <param name="conditionExpressions">The conditions that make up the query.</param> /// <returns>A query that can be used to retrieve multiple entities.</returns> internal static QueryExpression CreateRetrieveMultipleQuery(string entityName, IEnumerable<ConditionExpression> conditionExpressions) { // Create a new FilterExpression var filterExpression = new FilterExpression();   // Add the conditions to set up the filter filterExpression.Conditions.AddRange(conditionExpressions);   // Create the new Query expression and return it return new QueryExpression { EntityName = entityName, ColumnSet = new ColumnSet { AllColumns = true }, Criteria = filterExpression }; }

This next method is used to create a new entity, and returns it’s ID.

/// <summary> /// Create a new entity in CRM. /// </summary> /// <param name="entityToCreate">The entity that should be created.</param> /// <returns>The GUID of the new entity.</returns> internal static Guid CreateEntity(Entity entityToCreate) { // Create the proxy var serviceProxy = HelperMethods.CreateServiceProxy();   // Create the entity, and return it's GUID return serviceProxy.Create(entityToCreate); }

We also want a method we can use to update an entity.

/// <summary> /// Update an existing entity in CRM. /// </summary> /// <param name="entityToUpdate">The entity that should be updated, with it's new values set.</param> internal static void UpdateEntity(Entity entityToUpdate) { // Create the proxy var serviceProxy = HelperMethods.CreateServiceProxy();   // Update the entity serviceProxy.Update(entityToUpdate); }

The last method in this class will be used to delete an entity in CRM.

/// <summary> /// Delete an entity in CRM. /// </summary> /// <param name="entityToDelete"></param> internal static void DeleteEntity(Entity entityToDelete) { // Create the proxy var serviceProxy = HelperMethods.CreateServiceProxy();   // Delete the entity serviceProxy.Delete(entityToDelete.LogicalName, entityToDelete.Id); }

Contact proxy

For this blogpost I will only show the code I use for working on one entity, contact. All code up to this point can be re-used for all entities, so you only need to to create the class I am going to describe now for each entity you want to work on from BizTalk. Seeing how this is the class you will actually be using in your orchestration, you have to make it serializable, so BizTalk can write it to the database.

using System; using System.Linq; using System.Xml; using Microsoft.XLANGs.BaseTypes; using Microsoft.Xrm.Sdk.Query; using System.Collections.Generic;   namespace Customer.BizTalk.CRM.BusinessComponents { /// <summary> /// Proxy class used for working on contacts in CRM. /// </summary> [Serializable] public class CRMServiceProxyContact {   } }

This is where you will use the C# classes you created of your schemas. In this class, add an attribute for the type of schema you will be getting from BizTalk.

/// <summary> /// Canonical representation of the contact. /// </summary> ContactCanonical _contact;

The schema looks as following. Here IsProcessed is a boolean indicating if the message has allready been processed by a orchestration, and is promoted so it can be used on the filters. Action is an enumerator where a value of retrieve, create, update or delete can be used.

Next we are going to create the constructor. This takes in a XLANGMessage, which is the message from the orchestration in BizTalk. To be able to use this type add a reference to Microsoft.XLANGs.BaseTypes.dll which is located in the BizTalk 2010 installation folder.

/// <summary> /// Constructor. /// </summary> /// <param name="serviceRequest">The XML document from BizTalk with the canonical contact.</param> public CRMServiceProxyContact(XLANGMessage serviceRequest) { // Cast the XML document to a canonical contact _contact = (ContactCanonical)serviceRequest[0].RetrieveAs(typeof(ContactCanonical));   // We have processed the contact, so make sure it does not get picked up by this orchestration again _contact.Header.IsProcessed = true; }

The next method is used to determine the action that should be done in CRM by looking into the message we got. We return the message with it’s new contents to the orchestration.

/// <summary> /// Work on the contact. /// </summary> /// <returns>XML document with the result.</returns> public XmlDocument DoWorkOnContact() { // Check what type of work we want to do on the contact. switch (_contact.Header.Action) { case ContactCanonicalHeaderAction.retrieve: return RetrieveContact(); case ContactCanonicalHeaderAction.create: return CreateContact(); case ContactCanonicalHeaderAction.update: return UpdateContact(); case ContactCanonicalHeaderAction.delete: return DeleteContact(); default: throw new Exception("Invalid action."); } }

Here is the code to retrieve a contact. We look up the contact by using it’s email address, then we enrich the message with the data we got from CRM.

/// <summary> /// Retrieve a contact from CRM. /// </summary> /// <returns>The contact that was retrieved.</returns> private XmlDocument RetrieveContact() { // Get the contact we want to retrieve var retrievedContact = GetContactByEmailAddress();   // Set the values from the retrieved contact on the contact that will be returned as an XML document // Basicly, we do a mapping from the result of the query to the BizTalk document _contact.Body.ID = retrievedContact.Id.ToString(); _contact.Body.Name = retrievedContact.LastName;   // Return the contact as an XML document return HelperMethods.CreateXmlDocument(_contact); }

As you can see, we use a method called GetContactByEmailAddress, which is used to retrieve all contacts with a certain email address. Since we assume the email address is unique, this should return one contact.

/// <summary> /// Get a contact by looking it up by email address. /// </summary> /// <returns>The contact belonging with the email address specified in the BizTalk message.</returns> private Contact GetContactByEmailAddress() { // Get the contact by looking it up by email address // The email address should be treated as a primary key, and therefor should never change var contacts = CRMActions.RetrieveMultipleEntities(Contact.EntityLogicalName, GetEmailAddressFilter());   // Check if any contacts were found if (contacts.Any()) { // Seeing how the email address should be unique, we can simply get the first contact return contacts.First() as Contact; }   // The contact could not be found throw new Exception("No contact exists with this email address."); }

We use another method here, GetEmailAddressFilter. This method simply creates a list of ConditionExpressions which will be used to set up the query.

/// <summary> /// Create a filter that uses the email address. /// </summary> /// <returns></returns> private List<ConditionExpression> GetEmailAddressFilter() { return new List<ConditionExpression> { new ConditionExpression { AttributeName = Constants.ContactEmailAddressColumnName, Operator = ConditionOperator.Equal, Values = { _contact.Body.EmailAddress } } }; }

The next method will be used to create a new contact. We insert the new contact into CRM, and return the message with the new ID set we got from CRM.

/// <summary> /// Create a contact in CRM. /// </summary> /// <returns>The contact we just created, including the new ID.</returns> private XmlDocument CreateContact() { // Create a new contact Contact contactToUpdate = new Contact();   // Set the values of the contact // Basicly, we do a mapping from the BizTalk document to a CRM contact contactToUpdate.LastName = _contact.Body.Name; contactToUpdate.EMailAddress1 = _contact.Body.EmailAddress;   // Create the contact _contact.Body.ID = CRMActions.CreateEntity(contactToUpdate).ToString();   // Return the contact as an XML document return HelperMethods.CreateXmlDocument(_contact); }

Now let’s create a method used to update an existing contact. We first retrieve the contact by looking it up in CRM using it’s email address. We then set the new data, and then update the contact in CRM.

/// <summary> /// Update a contact in CRM. /// </summary> /// <returns>The contact we updated with it's new values.</returns> private XmlDocument UpdateContact() { // Get the contact we want to update var contactToUpdate = GetContactByEmailAddress();   // Set the new values on the contact contactToUpdate.LastName = _contact.Body.Name;   // Update the contact in CRM CRMActions.UpdateEntity(contactToUpdate);   // Return the updated contact return HelperMethods.CreateXmlDocument(RetrieveContact()); }

And finally, the method to delete a contact. This again looks up the contact in CRM by using it’s email address, and then deletes the contact. Since we use the IsProcessed variable in the message to determine if a message has been processed, we create a new canonical contact to return to the orchestration.

/// <summary> /// Delete a contact in CRM. /// </summary> /// <returns></returns> private XmlDocument DeleteContact() { // Get the contact we want to delete var contactToDelete = GetContactByEmailAddress();   // Delete the entity from CRM CRMActions.DeleteEntity(contactToDelete);   // Return a new contact to BizTalk, which just specifies that processing succeeded var doc = new ContactCanonical(); doc.Header.IsProcessed = true; return HelperMethods.CreateXmlDocument(doc); }

That was all the code we need. Now to be able to use all this, we need to create an orchestration.

On my receive I use the following filter:

(BTS.MessageType == "http://www.company.com/BizTalk/Schemas/v100#ContactCanonical") && (Company.BizTalk.Algemeen.Schemas.IsProcessed == false)

And in my expression I use this:

crmServiceProxyContact = new Company.BizTalk.CRM.BusinessComponents.CRMServiceProxyContact(contactIncoming); contactResponse = crmServiceProxyContact.DoWorkOnContact();

That is all, you can use this framework do do your communication with CRM. As you can see it is some more work then we are used to by using adapters, but it does work quite nicely. I have uploaded the entire solution here. Hopefully it can save you some time when integrating CRM 2011.