The purpose of this post is to show how to pass parameters when you want a button on a parent form that will open a new related record form.  This seems like it would be a common use case, but I found it hard to find any really clear example of how to do this.  A few articles here and here were helpful but I still spent over an hour trying to work this out for myself.  So in the interest of supporting the community and perhaps saving others an hour or more trying to figure this out on their own, I thought that I’d blog it. 

My use case is pretty simple.  I want a button called Check-In on the Contact Form (see fig.1).  When I click the button, it will open a new custom entity (called rmtc_monthlyclubbookresponse) form with the related contact already filled in (see fig.2). 

Figure 1 – Check-in button on the form.

Figure 2 – Create new related entity form.

The first step to create this is to add the button to the Contact form.  I prefer to use the Visual Ribbon Editor tool that you can pick up on Codeplex.  My approach is to have the button call a webresource javascript script that will open a new browser window, passing the correct parameters.  In the visual editor I added an action for my button to call my javascript webresource (see fig.3).  I reference my webresource library as:

$webresource:rmtc_/Scripts/toolbarCommands

Figure 3. – Visual Ribbon Editor reference to script webresource.

Now for the tricky part – the code to set the correct parameters and to open a new IE window with the related entity form.  I will show you the finished code, and not bore you with the details of how I got it (it is probably what you want anyhow).   

   1:  function Checkin() {

   2:      var serverUrl;

   3:      var errorMessage = "Context is not available.";

   4:      var context;

   5:      if (typeof GetGlobalContext != "undefined") {

   6:          context = GetGlobalContext();

   7:      }

   8:      else {

   9:          if (typeof Xrm != "undefined") {

  10:              context = Xrm.Page.context;

  11:          }

  12:          else {

  13:              alert(errorMessage);

  14:              return;

  15:          }

  16:      }

  17:      var entityId = context.getQueryStringParameters().id

  18:      var entityEtc = context.getQueryStringParameters().etc

  19:      var serverUrl = context.getServerUrl();

  20:   

  21:      if (serverUrl.match(/\/$/)) { serverUrl = serverUrl.substring(0, serverUrl.length - 1); }

  22:      var recordUrl = serverUrl + "/main.aspx?";

  23:      var params = "etn=rmtc_monthlyclubbookresponse";

  24:      params += "&pagetype=entityrecord";

  25:      params += "&extraqs=" + encodeURIComponent("?_CreateFromId=" + entityId + "&_CreateFromType=" + entityEtc) 

  26:      var URL = recordUrl + params; 

  27:      window.open(URL, "_blank", "width=900px,height=600px,resizable=1");

  28:   

  29:  }

Please note that I liberally borrowed pieces of this code from other places.  The key item to look at is line 25.  CRM supports a URL parameter called extraqs.  This is used to pass custom parameters to forms.  It turns out that there are two sub-parameters, _CreateFromId  and _CreateFromType that can be use to pass the related record information into the new entity form.  You will note that the underscore is required.  Also note that you must URI Encode the parameters and that it begins with a required question mark “?”. 

The _CreateFromId parameter is the entity ID of the contact record in my case.  It is easily picked up from the context.  The _CreateFromType is the entity type code of the parent entity, which is contact in my case.  Hardcode that at your own risk, as these type codes will change from one organization to another.  To do it right, I also pick up the ETC from the query string in the context. 

The final stage is to cruft up the URL line 26 and call Window.Open passing in our new URL.  CRM takes it from there, opening the related entity form and pre-filling the lookup field of the contact entity (figure 2). You can see the parameters passed to your form in the IE address bar by pressing CTRL-N.  

Hopefully this is going to save you some time trying to decipher these query string parameters on your own.  As always, please leave me feedback if I missed something or if this helped you. 

This all works great 99.9% of the time.  But today I received an email from a customer where these drag and drop features were not working.  Not only didn’t it work on this gentleman’s computer, but it was broken on every other computer in their office.  So I did a bit of research and some testing and found the problem. 

It turns out that this is not a CRM 2011 issue at all.  Drag and drop is a setting in IE that can be turned off.  See the picture below.  In some large organizations, especially ones that are zealots about security, they may have pushed down a group policy to disable drag and drop.  That was the problem in this case – the IT department had disabled drag and drop in IE.  A simple IE setting change fixes the problem (or in their case, a business case justification with IT Security to change their group policy setting). 

If you are using CRM Online, ensure that the setting for the Internet Zone is set to enable Drag/Drop.  If you are using CRM On Premise then it would be the local intranet zone.  In either case, the setting is in the miscellaneous section on IE Options/Security/Settings for the zone.  Here is a screen shot of the setting. 

Hopefully this will save some other folks some time in the future. 

Microsoft Dynamics CRM Developer Portal

Check it out!

Federated or Multi-tenant Implementations – How to Sync 1 CRM system to another!

There are some large implementations of CRM that are global enough to consider a federated approach to their implementation. There are also some implementations of XRM where 1 or more entities need to be synced between the tenants in the solution. Then there are a few instances where people may want to go from onPremise to online.

Each one of these scenarios can be solved with variations of the code in this blog.

What started me down this path was curiosity about migrating from onPremise to onLine. There were plenty of whitepapers and documents on going from onLine to onPremise, but nothing going the other way. Research led me to the fact that you have to either Scribe, or try to write some custom .NET code instead.

Given that I love to write .NET code, easy choice. But I certainly didn’t want to hardcode everything!! I started to look at the helper classes and the dynamicentitypartialtype.cs file became the anchor of the solution. If you haven’t tried this helper class out yet, try it – the class is pretty cool. Being a self taught C# coder I spent a little time trying to figure out how it was invoked from the sample code since there was no instantiation of the class. Finally I just ran it and realized that because of how it was constructed that it “just starts” all by itself whenever you instantiate an entity that is a DynamicEntity!

That was cool – but when I tried to add the class to my project with 2 different CrmSdk references, all hell broke loose. The namespace on the class is CrmSdk - since the result of the partial type class was the ability to build a dynamic entity on the fly, and it is a target dynamicentity that I want to create (not source) , I decided to put that class in the same namespace as the target CrmSdk, resulting in:

namespace CrmSdkTarget;

A little more digging to figure out how it really worked and I came across the code where it takes the passed in value and creates an object of the correct type and places the passed in value where it was supposed to go. If you have tried to update or create an entity through the dynamicentity route you have found where an attribute of a certain property has to be set to a value of the correct type. As an example, in order to create a property of type CrmLookupProperty that you have to first create a CrmLookup object and then set the value property of the CrmLookupProperty to this object, like this:

   1: Lookup myLU = new Lookup();

   2: myLU.name = “John Smith”;

   3: myLU.Type = “contact”;

   4: myLU.value = “348145F4-B2F3-DD11-BCF9-00C09F2C80B1”;

   5: LookupProperty myLUProp = new LookupProperty();

   6: myLUProp.Name = “contactid”;

   7: myLUProp.Value = myLU;

Authentication

In my solution I had 2 web references – one called CrmSdkTarget which was for my target – and one called CrmSdkSource which was my source. I called 2 different routines to get an instance of each and inside each routine is the authentication required of each. When I first wrote this I was going from a VPC image on my laptop to my own online system so I needed one AD authentication and one Live. Changing this part of the code should be trivial to match your authentication requirements.

When is DynamicEntity NOT equal to a DynamicEntity?

This is really the crux of the problem. You have an account on system A and want to sync it to system B. In one .NET project you can set up web references to both of the systems and authenticate to them easy enough – but you still can’t grab an account object as a DynamicEntity from System A and set a DynamicEntity from System B equal to it. What’s worse is that when you do anything in your code you have to qualify what you are doing because you now have multiple references to the same object.

In order for this to work I had to add the reference to the Source CrmSdkSource to the dynamicentitypartialtype class – which caused every reference to CrmSdk objects to turn red and ugly because of VS not knowing which one I meant.

So something like:

Public static object GetPropertyValue(Property property)

becomes

Public static object GetPropertyValue(CrmSdkTarget.Property property)

Every single reference to a CRM object had to be typed correctly. Since you can download my code, you don’t have to do it!

Next I tackled the real meat of the solution – the code in the CreateInstance method. This code is where an object is passed and turned into a CRM DynamicEntity Property. Once again – a CrmSdkTarget.Lookup object does NOT equal a CrmSdkSource.Lookup object! So in order for this to work I had to build a CrmSdkTarget.Lookup object by getting the values out of the CrmSdkSource.Lookup object.

This same concept was applied for each CRM property type. The place where things a little more interesting is the DynamicEntityProperty – the property used by activities for things like email to’s and from’s. That can actually be several properties in 1 so the code is a lot messier. Also where it gets confusing is that not all properties on an activityparty are ok for create. For instance while processing the to property for emails the source system will pass you a property within the dynamicentityproperty for donotfax. That is not a valid property for create.

Excluding other properties

In the main driver program there were more issues similar to the to for emails – not every property is ok for create. For instance any of the created and modified properties are read only fields. So I added a switch to exclude these fields. I called the metadata service to get a list of which fields are valid for create and created an ArrayList full of them. The driver program looks at each property in the source and if it is in the ArrayList, it passes it on for creation on the target side.

Finally the code that is used to grab all of the accounts or other entities is pretty much straight from the SDK.

A couple more Gotcha’s

If you are migrating a fully used system then there is a definite order that is required for your migration. For instance Lead has to be done before Account because Accounts have a field called originatingleadid that will throw an error if the lead doesn’t exist yet. There are countless other instances of this. Some of them have to be handled by watching the order – and some a little different.

One that is a little different is the primarycontactid field on account. In my solution I load an account and then save off the primarycontactid field. I then process all of the contacts for the account I just processed and when I find the one that has the same GUID as my saved off primarycontactid, I do an account update.

Another gotch is status and statecode’s. After you create the entity in many cases you have to call a SetState message to get the status to be something other than “New”. The code here accounts for that for all of the entities that are covered.

Finally – activities are just a strange beast no matter how you slice it. A source system will give you a cc or bcc with nothing in it, and creating that same thing isn’t easy. What I decided to do is to check the length of the dynamicentity array and if it is greater than 0 deal with it, otherwise don’t even send it to the target system.

Federation and Multi-Tenancy Timing Considerations

In these scenarios while there are a few options I think I can make a case that there is only one real option. The one option using this code that I would not suggest is to use plug-ins. I don’t suggest this for two reasons – the first is that a web service dynamic entity is not the same as the ICrmService that you get when you do a plug-in. While this is a minor inconvenience and I’m sure could be overcome – the larger issue is one that is more serious.

My background for CRM is in auditing. When you are doing an audit application you cannot “miss” a transaction. As soon as you do that, your application isn’t worth anything. I don’t see anything any different with trying to keep information in sync than in auditing. If you “miss” a transaction, then it is gone and you can’t ever get it back. The one you “miss” could be the one that updates the most important piece of information that someone else really needed to have. Once users lose confidence in your application, then it is a real bear to get it back. How could you “miss” one with a plug-in? If the target system is down for maintenance, in the middle of an IISReset or something similar then your create or update will fail.

So the solution is to ensure delivery by offloading the process. Step 1 is to create a plug-in that just writes out the transaction to a table in a non CRM database. Grab the transaction type, objectId, ObjectTypeCode, preXml, PostXML and timestamp it. If the database write fails, write it all out to a text file. This should never fail to capture the transaction and save it for later processing.

Step 2 is to create a windows service that has a timer. When the timer goes off – first look for text files and then look to the database. Load the text files into the database to ensure first in first out processing.

Step 3 is to create a DLL that the windows service can call that actually does the work – and pass it the transaction. Let that .dll have the multiple web references and be the workhorse. Sprinkle in some heavy duty logging and notifications to folks should things stop working and you have a solution that you know won’t miss any transactions.

The code for this article is posted on MSDN Code Gallery. 

My team wanted to put more context around XRM for our Public Sector customers.  Many customers are familiar with CRM software, but XRM is a new idea.  So I was honored to be a guest blogger on our Microsoft State and Local Government blog – Bright Side of Government.  In my guest blog post I explain more about XRM, how it is the platform that underlies our CRM product, and how our customers and partners are using it to build awesome applications for government. 

Check it out.  But please don’t make fun of my picture! 

It took me several weeks to find the time to get to really work with the image.  I needed it last week to delve into the Event Management Accelerator for a customer.    I am impressed with many things about it – it is faster and more complete than any previous VPC that I’ve seen.  I’m also glad to have Visual Studio 2008 with .NET 3.5 SP1 installed.  And having SQL Server 2008 is an added bonus. 

Anyway, all of this brings me to the purpose of this post.  I was planning to add an enhancement to the image around integrating Virtual Earth with CRM when I realized that I didn’t have an internet connection from within the VPC image.  It took me quite a while to figure out how to get the internet access working correctly and so I thought that I’d share that info with the community. 

The simple answer is that the default “Local Area Connection” has a hard-coded IP address, gateway, and DNS server.  You should blank out the Default gateway setting.  This forces the VPC to use the gateway from “Local Area Connection 2”.  Local Area Connection 2 should be mapped to your host PC’s active internet connection. 

I spent quite a while trying to enable one connection and disabling the other.  CRM requires the hardcoded internet IP address connection but the gateway was preventing windows server from accessing your true internet gateway via the second adapter.  So, blanking out the gateway was all that it took to fix the problem. 

Hopefully this will save someone else time.   If you haven’t done so, I strongly recommend that you download and check out the new image. 

The Wikipedia definition reports that ALM is the marriage of business management and software development.  The “ALM Lifecycle Management” whitepaper takes a much broader view than most of the industry.  It proposes that ALM encompasses the entire lifespan of an application, not merely the software development lifecycle.  ALM includes the entire time that the organization is spending money on the application. 

I have seen this pattern over and over again in our industry.  Tools that support ALM are not new, but I think that the term ALM is.  Of course  tools supporting SDLC activities have been around for many years.  But there is a certain buzz that is happening with ALM these days. The big analysis firms are now evaluating ALM tools.  You can read Gartner’s report online.  

With any new category there is often some early confusion about the category definition. I think that David’s approach is by far the most comprehensive because it includes not just SDLC activities, but also governance and operations management.  This paper is well worth taking a few minutes to read. 

The initial solution offerings are:

• Public Records Tracker. Public Records Tracker organizes and automates the public records request process for state, local and federal government organizations that must respond to Public Records Act and Freedom of Information Act requests.
• FastTrackGov Citizen Service Solutions. FastTrackGov is a hosted subscription-based system that provides a full suite of automated community development applications for licensing, permitting, code enforcement and inspection management.
• Agenda Builder. The Agenda Builder on-demand solution provides organizations with electronic review and approval capability for agenda items, resulting in significant time and paper savings.
• Constituent Manager. The Constituent Manager on-demand solution provides elected officials and their staffs with case management tools that facilitate timely responses to constituent requests.
• Inspection Manager. The Inspection Manager on-demand offering provides organizations with a Web-based case management solution that gives field inspectors and inside office staff the tools needed to schedule and perform field inspections and manage the abatement process when violations are found and citations are issued.
• Backpack 2008 Student Information System (SIS). Backpack is the first on-demand social student information system of its kind, designed to revolutionize SIS technology and provide the ability to centrally manage all aspects of an entire school district.

In addition to these solutions we established a community engagement site called Public Sector Idea Bank.  Public Sector Idea Bank was developed by Neighborhood America.  Neighborhood America has over ten years experience developing award-winning social networking solutions for government and industry.  Idea Bank provides a central place for Microsoft, customers and partners to collaborate around these solutions, collect feedback, and create new ideas for future on demand solutions. 

Congratulations to Carmel Hinkle, Amir Capriles, Scott Mannina on our US Public Sector Business Solutions Team.  These guys put in a tremendous amount of great work over many months to get this launched.  Also a big "Thank-You" to our partners, Eskel Porter Consulting Inc., Mitchell Humphrey, Information Strategies Inc., Metaphor Software, and Neighborhood America all of whom worked very diligently to deliver their excellent solutions.

It uses a new macro feature of Live Search to scope your search down to only MSCRM blogs.  It is especially cool that you can add this search to your browser search box. 

And if you don't like mine, you can create your own!  If you create your own MSCRM macro, please comment on this post to share it with me and the rest of the community.