CRMScape

The new MS CRM 2011 64 bit VM and VirtualBox

2011-06-02T16:15:00.001-04:00

I’ve gotten a number of emails asking what was needed to get the new Partner Source MS CRM 2011 64bit Virtual Machine to work in Virtual Box in Windows 7.

The compatibility issue appears to be the default hard disk settings. The following is a workaround that has worked for many people. I’ve been told this doesn’t work on Windows 2008 Servers, but on a 2008 server you could also run Hyper-V.

Change your VHD to run from an IDE controller:

Open up your storage settings and add the vhd as an IDE drive. Click the right + icon to create a new virtual hard drive. Choose an existing drive.

Select the VHD file the you decompressed and open it.

Now remove your SATA drive

Now Click OK.

Memory

This VM likes 2.5Gb or more RAM to operate in. As always more is better especially if you are going to demonstrate both CRM and SharePoint together.

Now Start it up!

Addendum

You should enable hardware virtualization when running 64-bit OS’s. This is a firmware setting on your motherboard. This is normally called “Intel Virtualization”, “VT-x” or “Intel VT” and AMD has an equivalent setting. Laptops frequently have this disabled by default.

CRM 2011 OData, JSON and CRM Forms

2011-03-08T08:10:00.001-05:00

1. Generating OData queries

OData commands can easily be tested out in IE. To help with this, you will want to turn off the feed reading view in IE.

The first thing that you will want is the name of the Sets that you will be calling on. If you use a path like the following it will provide a listing of the names of your sets. http://crmdev:5555/CRMDEV/XRMServices/2011/OrganizationData.svc

You will see a list of them in the following format.

- <collection href="AccountSet">
  <atom:title>AccountSet</atom:title> 
  </collection>

Since these names are case sensitive you will want to look at the names of your custom entities. Your stock items like AccountSet and ContactSet will be camel cased, but your custom entities will likely show up as new_myentitySet.

http://crmdev:5555/CRMDEV/XRMServices/2011/OrganizationData.svc/AccountSet

As you can see the field names use the Schema Name in CRM rather than the lowercase name the is used on the CRM forms. This is something that can cause confusion.

<d:Address1_Name m:null="true" />
<d:Address1_Telephone2 m:null="true" />
<d:OverriddenCreatedOn m:type="Edm.DateTime" m:null="true" />
<d:Telephone3 m:null="true" />
<d:DoNotBulkPostalMail m:type="Edm.Boolean">false</d:DoNotBulkPostalMail>

If you specify the guid of that entity, the results returned will be for that one entity. All fields are returned whether they are null or not. This listing will show you the exact case of each attribute name that you may want to query.

http://crmdev:5555/CRMDEV/XRMServices/2011/OrganizationData.svc/AccountSet(guid'3D37ACD3-5846-E011-8AE1-080027131692')

You can save bandwidth by only selecting the fields that you need and only those fields will be returned. Below will only return the AccountNumber and AccountName

http://crmdev:5555/CRMDEV/XRMServices/2011/OrganizationData.svc/AccountSet(guid'{3D37ACD3-5846-E011-8AE1-080027131692}')?$select=AccountNumber,AccountName

There are numerous references from MS explaining how to build OData Queries, however, Rhett Clinton’s recent addition to Codeplex is probably the easiest way to generate these queries. His tool can be found at the link below.

http://crm2011odatatool.codeplex.com/

Screen shot of his Query Designer

2. Using OData Queries with JSON

To use any of the following in a javascript library as webresource in CRM 2011 solution, you will first need to include a jquery library and a json library. The jquery1.4.1.min.js and json2.js files can be found in the most recent MS CRM SDK. sdk\samplecode\js\restendpoint\jqueryrestdataoperations\jqueryrestdataoperations\scripts. Add these a libraries and include them above the JavaScript library that you put your code in. Click here to see what that looks like in the Forms Property page.

To utilize these OData queries in a CRM Form using JSON, there is a pretty standard template to use. Just set the odataSelect below to your OData select url, and use the appropriate return method.

var odataSelect = "Your OData Query";

$.ajax({
       type: "GET",
       contentType: "application/json; charset=utf-8",
       datatype: "json",
       url: odataSelect,
       beforeSend: function (XMLHttpRequest) { XMLHttpRequest.setRequestHeader("Accept", "application/json"); },
       success: function (data, textStatus, XmlHttpRequest) 
           { 
               // Use only one of these two methods

               // Use for a selection that may return multiple entities
               ProcessReturnedEntities(data.d.results); 

               // Use for a single selected entity
               ProcessReturnedEntity(data.d);
           
           },
       error: function (XmlHttpRequest, textStatus, errorThrown) { alert('OData Select Failed: ' + odataSelect); }
   });

Notice the two methods:

ProcessReturnedEntities(data.d.results)
ProcessReturnedEntity(data.d)

When selecting what could be any number of entities, there will be an array returned, and you want to look at the data.d.results. When selecting a specific Guid there is no results array created, and you will need to just look at the data.d that is returned.

For example:

function ProcessReturnedEntities(ManyEntities)
{
  for( i=0; i< ManyEntities.length; i++)
  {
     var oneEntity = ManyEntities[i];
     var accountNumberAttribute = oneEntity.AccountNumber;    
     
     var accountNumberValue = eval(oneEntity.AccountNumber);
  }
}

function ProcessReturnedEntity(OneEntity)
{  
     var oneEntity = OneEntity;
     var accountNumber = oneEntity.AccountNumber;
     
     var accountNumberValue = eval(oneEntity.AccountNumber);     
}

Entity Attributes

As you can see the JavaScript entity objects returned have attributes named with matching camel casing in the OData query.

In that case of simple CRM attributes like:

string
memo
decimal
double
integer

You can get the value from them by simply using eval like shown in the example above.

For the following CRM attributes there is more involved.

optionset
money
datetime
lookup

For example:

var moneyValue = eval( oneEntity.new_MoneyAttribute.Value);
var optionSetValue = eval ( oneEntity.new_OptionSet.Value);

Setting CRM Form Fields with Queried Values

This gets a bit more complex when setting values to CRM form controls.

The form field names are all lower case, so the retrieved names do not match.
The form fields have validation and maintain more types than the returned OData values have.
There is some conversion required between them.

You can find out the type of a form control as follows:

var attrType = Xrm.Page.getAttribute("accountnumber").getAttributeType();

With the type you can then use the appropriate means to set form controls.

string, memo fields:

Xrm.Page.getAttribute("accountnumber").setValue(eval(oneEntity.AccountNumber));

decimal, double fields:

Xrm.Page.getAttribute("new_float").setValue(parseFloat(eval(oneEntity.new_Float)));

integer fields

Xrm.Page.getAttribute("new_integer").setValue(parseInt(eval(oneEntity.new_Integer)));

money fields

Xrm.Page.getAttribute("new_moneyattribute").setValue(parseFloat(eval(oneEntity.new_MoneyAttribute.Value)));

optionset fields

Xrm.Page.getAttribute("new_optionset").setValue(eval(oneEntity.new_OptionSet.Value));

date fields

var fieldValue = eval(oneEntity.new_DateTime);                       
var dateValue = new Date(parseInt(fieldValue.replace("/Date(", "").replace(")/", ""), 10));
Xrm.Page.getAttribute("new_datetime").setValue(dateValue);

The addition of support for JSON, OData queries in MS CRM 2011 has

added some great power to what can be done easily in the JavaScript of a CRM form. This should reduce the number of solutions that require web applications running in iframes dramatically. This is a good thing since MS is phasing out the ISV folder for web applications running in the same app pool on a web server and there is currently no support for aspx files in CRM solutions.

CRM 2011 Set Default Transaction Currency in JavaScript

2011-03-04T10:23:00.001-05:00

The following function uses JSON and OData to select the first Currency entity that is configured on your system and then sets the transactioncurrencyid lookup to be that currency.

This particular feature is just as relevant for CRM 2011 as it was for CRM 4.0, but it is easier to implement now.

The OData selection for this consists of the following:
/TransactionCurrencySet?$select=TransactionCurrencyId,CurrencyName

If you have multiple currencies, you can always add a filter to OData select to grab the specific currency that you need. This function uses the first currency returned.

function SetDefaultCurrency()
{
    var context = Xrm.Page.context;
    var serverUrl = context.getServerUrl();
    var ODataPath = serverUrl + "/XRMServices/2011/OrganizationData.svc";   
    var odataSelect = ODataPath + "/TransactionCurrencySet?$select=TransactionCurrencyId,CurrencyName";

    $.ajax({
        type: "GET",
        contentType: "application/json; charset=utf-8",
        datatype: "json",
        url: odataSelect,
        beforeSend: function (XMLHttpRequest) { XMLHttpRequest.setRequestHeader("Accept", "application/json"); },
        success: function (data, textStatus, XmlHttpRequest)
        {            
            var myCurrency = data.d.results[0];
            var idValue = eval('myCurrency.TransactionCurrencyId');
            var textValue = eval('myCurrency.CurrencyName');    
            var thisEntityType = 'transactioncurrency';            
            Xrm.Page.getAttribute("transactioncurrencyid").setValue([{ id: idValue, name: textValue, entityType: thisEntityType }]);         
        },
        error: function (XmlHttpRequest, textStatus, errorThrown) { alert('OData Select Failed: ' + odataSelect); }
    });
}

In order to use this. You need to make sure that you include jquery1.4.1.min.js and json2.js as libraries first since this script relies on them. Create another library with the above function. If you just call the SetDefaultCurrency function in the OnLoad event of your form, the currency will be set as the form opens and will be be ready for you to set any currency values that rely on this.

The jquery1.4.1.min.js and json.js files can be found in the most recent MS CRM SDK. sdk\samplecode\js\restendpoint\jqueryrestdataoperations\jqueryrestdataoperations\scripts

CRM 2011 RTM VM Installation Differences

2011-03-02T09:46:00.001-05:00

There are a few differences between the RTM installation and the Beta installation I have documented in earlier blog articles. Starting with the following: http://crmscape.blogspot.com/2010/09/creating-ms-crm-2011-vm-part-1-of-2.html

1. There are minor appearance changes in the CRM 2011 Installation screens, but everything else looks close enough that the Beta instructions still work.

2. The entire section of my instructions called SQL Reporting Services ( Configure Data Source ) is unnecessary, which is an improvement. However I did add my Admin user account to the PrivUserGroup and PrivReportingGroup and then everything worked great.

Otherwise the instructions still worked well for me. I’ll look over the updated installations instructions shortly to make sure there isn’t anything of importance that needs to be added.

I’m also using the latest Virtual Box 4.0.4 release for this which is working well. The only reason I used it instead of VMWare is that I had an existing VM just waiting for MS CRM to be installed with all the prerequisites in place.

I’ve been “living on a cloud” for the past few months in CRM Online and Windows/SQL Azure land, but now that the 2011 On Premises release is out, I’m back on terra firma working with that again too.

MS CRM 2011, the “Cloud”, Azure and the future

2010-12-15T20:56:00.001-05:00

Something really important is happening right now, and if you are involved in MS CRM take notice or fall by the wayside! This is a real game changer!

Almost all of my MS CRM installations were on premises installations until just this Fall. Sure there were IFD configurations and web portals with Silverlight etc., but the customer was always in tight control of the servers, even if the servers were hosted.

I thought the next big thing would be the tighter SharePoint 2010 integration with MS CRM 2011 and to be fair I have seen interest in that and it will be a growing thing.

What I didn’t expect is that suddenly I would almost exclusively be working with hosted MS CRM systems, MS CRM Online and Windows Azure and SQL Azure. BTW I’ll be working with the new SQL Azure Reporting Services CTP this week as well.

What is pretty obvious is that MS has a lot of technologies coming together at about the time that MS CRM 2011 is hitting the scene. Frankly I thought it all looked interesting, but I didn’t expect the market to react so quickly or for it all to fit together so well.

What I also didn’t expect was how much I would enjoy this transfer of responsibility. I enjoy being in control of things, but I also love abstracting away busy work to concentrate on solving real problems. That is the point of MS CRM. System administration work is not where the fun is, at least for me.

I was also pleasantly surprised at how easy using SQL Azure is. Just make sure you are using SQL 2008 R2 Management Studio and it is really nothing more than setting up an IP range you will be connecting through in the Azure portal, and changing your connection string. All of your tables need to have Clustered indexes as well and you have to use SQL scripts for all of your modifications, but otherwise it is just like the SQL you already know. Another thing to beware of is that the Web database is 1-5Gb and if you expect to grow beyond that you need to start with a Business Database which starts at 10Gb and can grow to 50Gb.

I’m currently working on a project that is using an Azure 10Gb database, the new to SQL 2008 geography fields and spatial indexes. I imported about 7Gb of data in about 3.5 hours. The database has been very responsive. I did notice that when I ran a very intensive task like generating a Spatial index across 9.2 million records that it would occasionally idle my process, but it still finished in a respectable time.

Windows Azure, likewise, was very easy to set up. Install the Azure SDK, create a Cloud Service Project, setup the Diagnostics and build a web application. If you make the Cloud Service your Start project it can be debugged locally as it will be deployed. There are a few configuration switches, but then again you are abstracting away all of the IIS administration.

Where this all gets interesting is that additional instances of your application can be added with a few key clicks and without purchasing equipment or understanding anything about network load balancing. Adjust the amount of CPU cores and memory your application needs as it grows. Scale it back during the off season or grow though the ceiling.

I have customers who want to scale up quickly to compete with some pretty large competitors with a better product, but without the infrastructure or small army to maintain it. The Azure platform allows a small guy with a better mousetrap to take on the world.

As a lone gun for hire, without a staff of sysadmins, what this means to me is that I can create some really really big solutions very quickly and without the setup time normally involved, or the meetings with IT departments to budget for servers, and schedule for installation and configuration.

What this also is going to do is let a lot more killer apps actually see the light of day. I think we are going to see a new wave of enabled developers make a lot of really cool things happen.

The cost of admission to see if something will stick has really dropped and if your solution is really that good and your website is nailed with traffic, all you need is a few key clicks to give you more bandwidth, memory and processing power.

I was a bit skeptical at first, but as the saying goes, “People vote with their wallets”. Based on what I am seeing the people are voting and much quicker than I expected!

MS CRM Custom Workflow CreateCrmService permissions

2010-11-11T14:23:00.001-05:00

If you are writing custom workflows and calling CRM services, you are probably familiar with the following code which creates a service with system administrator access to all data. ( true = administrator access )

ICrmService service = context.CreateCrmService(true);

You may have noticed that any entities created by a custom workflow using this administrator access default to being created and owned by the account that your Microsoft CRM Asynchronous Processing Service runs as.

This has some trickle down depending on the account your async service is using.

For example if you are using the Local System Account which “typically” does not have a CRM user account dedicated to it, there are some things that you won’t have permission to do.

For example the Local System account doesn’t have permission to send an email and the following will fail even with a service having administrator access.

var sendRequest = new SendEmailRequest
             {
                 EmailId = emailId,
                 IssueSend = true,
                 TrackingToken = String.Empty
             };

sendEmailService.Execute(sendRequest);

This will give you the following SoapException:

<error>
<code>0x80040216</code>
<description>An unexpected error occurred.</description>
<type>Platform</type>
</error>

You could create another service reference like below just to send email with which will work as long as the user running the workflow can normally send an email from a workflow.

ICrmService sendEmailService = context.CreateCrmService(false);

You could also use a CRM user CAL and create a CRM user for the account your async service runs as.

The important thing to realize is that any service request that requires user configuration in order to function beyond security role permissions will be dependent on whether there is a CRM user assigned to the account the acync service is running under and how that CRM user is configured. For example: whether the email access type is E-mail Router.

Developing for CRM 2011 and SharePoint 2010 Foundation

2010-09-29T08:58:00.001-04:00

If you are a MS CRM person looking at SharePoint as something new here are a few things that may be of interest.

The SharePoint 2010 Foundation is free and will work with the MS CRM list component but it is limited to database sizes of 4Gb. This makes it much easier to leverage some of the power of SharePoint for your CRM customers. Your customers by default already have licensing for Windows Server and SQL Server in order to run MS CRM and SharePoint Foundation can share that same server.

In addition the new Business Connectivity Services (BCS) are also supported by SharePoint Foundation: http://msdn.microsoft.com/en-us/library/ee557646.aspx

BCS will allow you to expose data from other databases to show up in SharePoint, but not take space in the SharePoint database, this of course includes CRM data. There is obviously a performance penalty depending on the interface to access this external data, but it also allows maintaining legacy databases while having access to that data in SharePoint without passing the 4Gb database limit in the SharePoint database.

If you are looking at SharePoint integration using their web services, you can see from the following link which services are supported by both SharePoint Foundation and by SharePoint Server and just by SharePoint Server. http://msdn.microsoft.com/en-us/library/ee705814.aspx

As an obvious guideline it would make sense to write your base code to support SharePoint Foundation to let customers try out SharePoint functionality, and to have any features that require SharePoint Server features be switchable at a later time if your customer upgrades.

SharePoint Server has a number of useful features shown in this version comparison that you may or may not need: http://sharepoint.microsoft.com/en-us/buy/Pages/Editions-Comparison.aspx

As a practical note, SP 2010 is built on .NET 3.5 and CRM 2011 is built on .NET 4.0, so while most of you will not have a lot of .NET 4.0 legacy code at this point, is will be important to make sure your libraries with logic that will be shared between SP and CRM components are all kept at .NET 3.5.

Connecting to MS CRM 2011 outside the VM

2010-09-26T12:10:00.001-04:00

While the CRM 2011 VM created so far works well by itself, you will most likely want to access MS CRM web site, web services and endpoints from outside the VM for development purposes.

To do this you will need to set up VirtualBox to allow access from your host computer.

1. With your VM shutdown, modify the Network Settings and enable the second Adapter. As shown below:

Attached to: Host-Only Adapter
Name: VirtualBox Host-Only Ethernet Adapter

Note: when a VM is created from scratch it appears to select the correct network adapter type. When I copied the VDI file to my laptop and setup a VM based on that VDI file, it picked a different adapter by default and the networking didn’t work until I made it match the original Network settings that I had when I first configured it.

2. Start up your VM, open up a command prompt and run ipconfig. Notice the new Local Area Connection 2 should be in your local network. The other is the default NAT adapter that allows your VM to see the Internet as your host computer.

3. On your host computer go to C:\Windows\System32\drivers\etc and edit your hosts file and add the new IP address to your hosts file.

4.You may want to add a new Credential to your Credential Manager to reduce your login time under Control Panel since you are not in the domain of the VM.

Use the Hosts alias created above, then add a domain\username, and password. This will give you a mostly filled out login when you try to reach the website for the first time.

5. Test the connection out by bringing up MS CRM on your host. I’m using the alias in my hosts file pull up CRM. http://w2008r2crmdev:5555/CRMDEMO

6. Now make sure you can access the endpoints through the browser

http://w2008r2crmdev:5555/CRMDEMO/xrmservices/2011/organizationdata.svc/$metadata
http://w2008r2crmdev:5555/CRMDEMO/xrmservices/2011/organizationdata.svc/

7. If the endpoints show up in the browser than they should be available to add a reference to a Silverlight project as shown below.

Side Note: I have found that this VM is capable of running with 2.3Gb of RAM and on one core on my 2 year old Core Duo laptop. There is just enough memory to run VS 2010 on the host and connect to the guest VM’s endpoints as shown above in the 4Gb of RAM my laptop has. This is by no means an optimum configuration, but it is possible to demonstrate CRM 2011 beta with SharePoint integration and write code against both SDK’s.

MS CRM 2011 SharePoint List Component Installation

2010-09-21T11:04:00.001-04:00

Warning if you downloaded the file just as this was introduced it contains an unsigned assembly that will give you an error message shown when you would see it during the installation below. A fix was put out by MS a few days later. If in doubt download it again.

Download the SharePoint List Component
CRM2011-SharePointList-ENU-amd64.exe file and run it on your VM.

Accept the Conditions

Pick a place to unpack the contents. You will be browsing to the crmlistcomponent.wsp file from SharePoint later.

Before installing the List component you need to relax the Browser File Handling to “Permissive” for the Web application that you are sharing with MS CRM 2011.

Go to SharePoint Central Administration and click on Manage web applications.

Select the web application that you are sharing with MS CRM and click on General Settings.

Scroll down to Browser File Handling and click on permissive then scroll to the bottom and click OK.

Now visit your SharePoint Site and click on Site Actions then Site Settings.

Click on Solutions under Galleries

Click the Solutions Tab, and a ribbon will appear. Click on Upload Solution in that Ribbon.

Now browse to the crmlistcomponent.wsp file that was unpacked earlier and click OK.

Now you need to Activate this solution.

Note: The error below will only happen if you are still using the Initial download of the CRM2011-SharePointList-ENU-amd64.exe file.

You should see this if you have the right version.

The SharePoint List Component is now in place.

To test this in CRM.

Go to Settings, Document Management and click on Document Management Settings. Enter your shared SharePoint site. Click Next

You can pick Account, Contact or not select where you Document Library will be based. I selected Account below. Click Next

When it is all done, click finish.

Create a Test Account if you don’t already have one. Add a document of some kind. It will prompt you for a location to automatically create a SharePoint Folder the first time you do this per Account. Click OK.

Click the Open SharePoint link to see the document in SharePoint. Both sides can now work with documents in this folder.

MS CRM 2011 Beta VM Continued.. Customizations

2010-09-19T15:30:00.001-04:00

As my instructions left off, trying to publish a CRM customization and exporting customizations will fail with a SQL error. This is because the administrator currently doesn’t have adequate permissions.

Since the Administrator account has the Administrator security role this should not be an issue.

In a production system we should not be giving the Administrator account direct access the <orgname>_MSCRM database as dbo in SQL Management Studio, but that will work for the VM. However I believe the user should instead belong to a group with the proper permissions. In this case I added the Administrator user to the SQLAccessGroup as shown below which had adequate permissions.

MS CRM 2011 Beta VM continued…

2010-09-15T12:02:00.001-04:00

There is going to be plenty more to this VM and the CRM beta to work on as we learn more about this new release.

More Building Blocks are needed.

Using steps in the previous section make sure that the SharePoint websites are stopped. Also stop the SharePoint services below. This will dramatically speed things up.

Unpack the Beta SDK

Install the CRM 2001 SDK, using MicrosoftDynamicsCRM2011BetaSDK.exe

Double click and pick a folder to use. I chose C:\CRM2011BETASDK

Build the Plug-in Registration Tool

Open VS 2010
Open the solution in C:\CRM2011BETASDK\sdk\tools\pluginregistration

Debug the solution to make sure it works.

Enter the URL of your CRM website, and check Use Saved Credentials and click connect.

Click Connect again and you should see that the Plug-in Registration tool is working.

For testing purposes you can just run the copy out of the bin debug folder or put a copy on a folder on your desktop.

SQL Reporting Services ( Configure Data Source )

Now that CRM is installed we need to revisit Reporting services and configure the MS CRM_DataSource

Go to Reporting Services in Internet Explorer:
http://w2008r2crmdev/Reports

Click on SharedReports
Click on 5.0.xxxx
Click on Details View since the datasources are hidden by default.

Click on MSCRM_DataSource. (obviously adjust the following for your organization name and server name )

Change the Data source type to: Microsoft SQL Server
Change the Connection string to: Data Source=W2008R2CRMDEV;Initial Catalog=CRMDEMO_MSCRM;Connection Timeout=60;Integrated Security=SSPI
Click on Windows integrated security.
Click on Apply
Click on Test Connection

You should see: Connection created successfully. as shown below.

You should now be able to test out a CRM report.
I just pulled up the Account Distribution Report at the top of the list.

That wasn’t really impressive since this VM has almost no data in it, but there were no SSRS errors and that is the important part.

Creating a MS CRM 2011 VM Part 2 of 2

2010-09-12T12:31:00.001-04:00

Performance Note: VirtualBox allows you to set more CPU’s for your virtual machine than you should. I ended up using 3 CPU’s for my i7 although it is a hyperthreading and shows 8 cores. I found it MUCH faster set to 3 CPU’s instead of say 4.

To speed the installation up turn off the SharePoint Websites for now. Go to IIS Manager and stop the SharePoint sites. You may want to leave this off until installing the SharePoint List component in MS CRM and you will probably only want these turned on when you are using SharePoint, otherwise they

Visual Studio 2010 Installation

VS 2010 is a very straight forward installation. It also installs a number of other prerequisites needed for MS CRM 2011 like .NET 4.0.

Mount your VS 2010 iso image and select it.

When that is complete you may want to make another snapshot of your VM.

At this point your VM’s dvi file should be about 21Gb in size.

Reporting Services Installation

Go to the Start button and click on All Programs

Microsoft SQL Server 2008 R2 –>Configuration Tools –> Reporting Service Configuration Manager

Click Connect

Click Web Service URL then Click Apply

Click on Database and Change Database

Create a new report server database

Click Next

Click Finish

Click on Report Manager URL and click apply.

Once again this is a test VM, so I gave this my Administrator account. You probably won’t be be using connectivity to remote servers anyway.

This is good enough for the MS CRM installation to finish successfully.

MS CRM 2011 Beta Installation

Included in the download area is the file MicrosoftDynamicsCRM2011BetaIG.zip containing: MicrosoftDynamicsCRM2011BetaInstallingGuide.doc

You can refer to that document if there is anything in my instructions below that you need more information about. Page 13 starts “Install Microsoft Dynamics CRM 2011 Server on a server without Microsoft Dynamics CRM installed”

Start by going to you shared folder where you need to copy the CRM2011 executables that you need and copy them to the VM’s desktop. For now we just want the CRM Server and the SharePoint List component.

Create a CRM2011Beta folder on your desktop and click on the CRM2011-server-ENU-amd64.exe file and extract the contents into this folder.

Open the CRM2011Beta folder –> server –> amd64
Double click on setserver.exe

The Beta was just released so there is no point in getting any updates yet.

MS CRM Workgroup (5 CAL limit): FF2JM-QX9PG-HXT8M-MMHXG-4MF32
MS CRM Server (no CAL limit): 4FDTK-3HYV2-D9CCJ-4MF9Q-QJ32X

Next put in the appropriate key above. Notice the 270 day expiration period!

Accept the license agreement.

Install the prerequisites.

Select an installation location or keep the default.

Click Next and install all of the roles.

Type in the name of your VM Server.

Click Browse and just select the top node. Click OK and Next.

Specifying a Security Account. For a production system you will not want to do this, but for our demo system, just select Network service account. There is an additional step required for the SharePoint document management feature when doing this.

You want to create a new website to avoid any conflict with SharePoint and other sites. Keep 5555 for the port. You should have selected 9999 for the SharePoint site if you followed the instructions.

We are NOT going to set up an Email router at this time. Notice the note. This can be done later. (Setting up Exchange Server and Outlook on a test environment is worth doing especially with the new multi-tenant support in Outlook)

Pick an organization name for your system. It will name the Database automatically. Leave the rest alone.

Take the default reportserver name unless you have installed it somewhere else.

Decide if you want to take part in the use experience and click Next.

Next Installation

It may sit like this for a while. Be patient…

Getting close now. Check the box to set up the SSRS extensions, and click Finish!

Installing the SSRS Connector

If you decided not to start this when the CRM installation finished. On your desktop go to the srsdataconnector folder CRM2011Beta\server\amd64\srsdataconnector and Double click on the file SetupSrsDataConnector.exe

Click Next

Accept the license agreement

The warnings are OK for a demo, development box. Click Next.

The Moment of truth….

At this point I shut the system down. It was apparent that it was running out of memory with 4Gb RAM. So I shut it down to make a snapshot and to increase the memory to about 6Gb to see if that was usable.

It seemed much faster after the reboot. It is interesting to note that it is only using about 2.5Gb of RAM without SharePoint running.

Now turn on the SharePoint Sites again.

Create a SPList folder on your desktop. Copy the CRM2011-SharePointList-ENU-amd64.exe file from the Shared Folder areato the VM’s desktop and double click on it.

Browse to your new folder, and click OK.

Read the following inside the SPList folder for instructions to install the SP List Component.

Microsoft_Dynamics_CRM_2011_List_Component_Readme.htm

More to come. I have to do something else for a little while…

Good luck with the new Beta!

Creating a MS CRM 2011 VM Part 1 of 2

2010-09-11T19:50:00.001-04:00

I needed both a demo box and development environment to run on Win7 64 bit computers to show customers and to write code against the MS CRM 2011 beta using the SharePoint 2010 connectivity and Visual Studio 2010 to write WP7 applications against the new WCF services in MS CRM.

The new SharePoint List Connectivity in MS CRM 2011 is a feature a number of my customers are interested in and I expect to have a lot more CRM/SharePoint integration projects coming up. Assuming this is an indication of a general interest, this would be a great time to start learning SharePoint if you haven’t already so I consider this an important piece to build into this VM.

Two points:

The world is going 64bit everywhere. There is no point trying to set up a 32bit box. It is time to just say no to 32 bit.
Virtual PC doesn’t support 64bit applications which effectively makes it useless!

Options to Host a Virtual machine in Windows 7 64 bit

Virtual Server on a W7 box as shown here (unsupported by MS)http://tfl09.blogspot.com/2009/08/windows-7-and-virtual-server.html
VMware http://www.vmware.com/
VirtualBox http://www.virtualbox.org/wiki/Downloads

I chose Virtual Box 3.2.8 based on many recommendations. It can run 64bit VHD’s and VMWare VMs but will create a VDI file and it’s a free open source solution.

VirtualBox installation in Windows 7 64bit

Stop IP Helper Service ( this will keep the VBox installation from working)
Install VirtualBox from the downloaded exe. VirtualBox-3.2.8-64453-Win.exe

What you need before beginning to build your VM:

Time: Expect at least a full day to get everything set up and that’s on a reasonably fast system. My host system ( i7 12Gb RAM running the VM image off of RAID 0 10,000rpm drives, (VM 6Gb RAM, and 4 cores)) took a full day. Plan accordingly!
Windows 2008 R2 64 bit iso image
SQL Server 2008 R2 64 bit iso image (recent copy 5/3/2010)
- Note: Older SQL iso files may require SQL Server 2008 R2 SP1 and the following Hot Fix SQL Server SP1 Cumulative Update 2 http://support.microsoft.com/kb/970315/
- They will give you this error message during the SharePoint Installation.
- Save yourself the trouble and download the latest SQL 2008 R2
SharePoint Server 2010 64 bit iso image
VS 2010 iso image

The current CRM 2011 beta downloads are here you will need the following:

MS CRM 2011 Server CRM2011-server-ENU-amd64.exe
CRM2011-SharePointList-ENU-amd64.exe
MicrosoftDynamicsCRM2011BetaSDK.exe

Credit where credit is due:

I am going to defer to the good work of the folks at Critical Path Training for their excellent instructions and links to video for setting up a SharePoint 2010 VM, so please visit their site http://www.criticalpathtraining.com create an account (it’s free), then go to the Members Section and download their pdf document:
“SharePoint Server 2010 RTM Virtual Machine Setup Guide”.

These instructions will walk you through setting up Windows Server 2008R2, SQL Server 2008 R2, and SharePoint 2010 which is covers a good chunk of what we are installing.

Their instructions start with setting up a Hyper-V vhd which you can skip unless you are setting this up on a Microsoft Virtual Server system. You should be able to run a vhd created on a Virtual Server system on a Windows 7 64bit box using VirtualBox.

Since my intent is to create this VM on a Windows 7 64bit system here are my VirtualBox instructions.

Start VirtualBox and Click on New, click Next

Give your machine a name: W2008R2CRMDEV
Operating System: Microsoft Windows
Version: Windows 2008 (64 bit)

Give it a minimum of 4Gb of memory or more if you can spare it.

Create a new hard Disk. Click Next and Next again at the Create Virtual Disk Wizard.

Select Dynamically expanding storage

The virtual disk is only 324Mb while empty and will only use as much disk space as it needs so give it 100Gb.Click the folder button to choose where you want to store this image.

Click Next and then click Finish.
Now you will want to make a few more adjustments.

Click on System then click on the Processor tab and add some CPU’s if you can so the installation will go faster. You can always reduce the memory or CPU’s later.

Click on Display and set the video memory to 128Mb.

Click on the Shared Folders and point to an area to access files. You will need this to install the SQL Server SP1 and Hotfix and for moving files around later.

Next Click Start

Click on the Folder and Browse to your ISO image of the Windows 2008R2 DVD
You can use a DVD, but it will be much slower.

Once you have your iso images added, you can run any of them for installations, by just selecting the .iso file and clicking the Select Button.

Once you have Windows 2008 installed make sure to install the Guest additions just so that the mouse transitions better.

Devices –> Install Guest Additions

When you need to reach the CRM executables access the shared drives in Windows Explorer Network –> VBOXSVR –> \\VBOXSVR\Shared

Use the Critical Path instructions starting with the section to install Windows 2008R2 then SQL Server 2008R2 and SharePoint 2010.

Notes:

When the Farm configuration Wizard is running, it could take an hour or longer and the IE screen can time out. When the CPU finally calms down it is done. My VM was running about 100% on each CPU while this was running.
The first time you bring up your default site it may time out a couple times and then finally work.

This gives you a great starting point to install the MS CRM 2011 Beta.

Important!!!! I would highly recommend that you make a copy of your VDI file at this point! You may want to install various MS CRM 2011 release candidates and then the final RTM on this system later, or my might want to install MS CRM 4.0 on this system as well. Also Visual Studio is great for a Development system, but you may want to create a DEMO system at some point without VS installed.

MS CRM 4.0 LINQ Support in CRM SDK 4.0.12

2010-08-06T16:48:00.001-04:00

So far I really like what I have seen in this new SDK release MS CRM SDK.

It solves real problems and will actually make life better for CRM developers.

The new LINQ support can be used by people customizing their own propriety CRM systems and for integrators and xRM developers with software to deploy across different CRM schemas.

How they got it right and made life easier!

The attributes can be directly accessed as simple types!

bool? instead of CrmBoolean
Guid instead of Key
etc..

The related entities are associated as a list of entities like you would expect with LINQ

IEnumerable<contact> instead of a BusinessEntityCollection.
Many less queries need to be coded greatly simplifying code.

Even though the additional queries are generated internally, they are done on the SQL side rather then requiring multiple web service calls which should be faster.

The related entity list names are predictable!

ex. acct.account_contacts
ex. acct.new_account_contact

Note: This is a significant improvement from the LINQtoSQL model that would just name related entities contacts, contacts1, contacts2 without any way to predict which related list is which and wouldn’t give you a permanent way to set naming behavior. Adding an additional relationship to an entity that was already related could ruin your existing LINQ, requiring manual editing of the model xml.

There is now much less of a reason to need to use the much more primitive Fetch type syntax. string xmlResults = crmService.Fetch(xmlQuery);
Entity classes do NOT need to be identical to the CRM schema for Selects!
Entity classes do NOT need to be identical to the CRM schema for Updates!

According to MS the Update operation sends only modified attributes back to the server so you don’t have to care about anything else that’s been added.

In a nutshell

Strong typing and compile time errors
No web reference required
Easily regenerated Entity classes

Simple Maintenance

From a command line all you have to do is use the new crmsvcutil.exe to generate and update the LINQ Entity class source files. More information here. MSDN reference

C:\> crmsvcutil /server:http://crm/Contoso /out:MyLinqEntities

One of the reasons I really appreciate this is that I wrote a utility to read all of the MS CRM Metadata and generate (Data Transfer Objects) or DTO’s for RIA services about a year ago along with all of the associated attributes for validation. Idea for MS: If we had a switch on this utility to dynamically generate validation criteria attributes from the MS CRM metadata so that we could bind a control to it, that would be great for MVVM Silverlight apps! Or generate them by default and just comment them out.

Getting Started:

David Yack has an explanation of how to set up MS CRM LINQ on your system and use it in a hello world project. There is no point duplicating his effort.

Sample Solution:

The following is a very simple sample solution 7.5Mb that is little more than the sample in the explanation link above. However the SDK libraries are included in the solution as are the Entity class files generated from the stock MS CRM 4.0 Contoso VM with a couple additions to the Account entity.

Since it ONLY accesses a couple standard fields in the Account entity it should work out of the box on any CRM 4 box once the Server name is set in the app.config file. Just change the line below to whatever your local server name/orgname is and it should work.

Server=http://crm/Contoso;"/>

This is good stuff and the sooner you start using this the more time it will save you!

MS CRM 4.0 Sending Attachments to the Browser

2009-10-03T07:01:00.001-04:00

In a previous blog article I covered how to take files and make them attachments to emails. Creating Attachments to emails and annotations

Recently I’ve been spending more time building portals to MS CRM, and have needed to make attached files available to the user by browser.

From a custom web app running with MS CRM you can always create a link like the following that will call the annotation editor screen which will let you download the attachment or delete it or add an additional attachment to the annotation.

string link = String.Format(@"{0}{1}/notes/edit.aspx?id={2}", crmServerBaseUrl, orgname, thisNote.annotationid.Value);

However sometimes when working with an external application you don’t have the ability to call the MS CRM functionality or for aesthetic reasons you want things to look differently. In this case I have a Silverlight 3 application with a completely different look and feel and I just need to retrieve annotation attachments from a list associated with an entity or contact. The ExportFile() method below would work just as well with an activitymimeattachment for email attachments.

The following aspx file simply takes an annotationid querystring, retrieves that annotation ( you provide the query) and sends the attached file to the user’s browser. The user will then be able to download the file or open the file in an appropriate application.

using System;
using System.Web;
using Passport.Web.Services.Logic;

namespace YourProject
{
    public partial class SendAnnotation : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {           
            if (Request.QueryString["id"] != null)
            {                
                Guid annotationId = new Guid(Request.QueryString["id"].Replace("{", "").Replace("}", ""));

                // Get annotation
                annotation fileContainer = // fill in the query logic you need here.
                
                // Call method to write
                ExportFile(fileContainer.filename, fileContainer.documentbody, fileContainer.mimetype);             
            }
        }

        /// <summary>
        /// This method takes the annotation documentbody and writes it back to the browser
        /// with a file name and mimetype so that your browser knows how to intelligently 
        /// handle the file being sent to it.
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="content"></param>
        /// <param name="type"></param>
        private void ExportFile(string fileName, string content, string type)
        {
            byte[] fileContent = Convert.FromBase64String(content);
            Response.ClearContent();
            Response.AddHeader("content-disposition", "attachment; filename=" + fileName);
            Response.ContentType = type;
            Response.BinaryWrite(fileContent);
            Response.End();
        }
        
    }

}

MS CRM 4.0, xRM and building blocks

2009-07-30T09:46:00.001-04:00

I have spent a number of years working with MS CRM as the end solution while integrating it with many other systems to make it the center of an organization’s business processes, data tracking and communication.

Change is good.

My emphasis has changed over the last year from business analysis, configuration, integration and customization of MS CRM to xRM systems that use MS CRM as a framework to build non-CRM solutions, and now leveraging MS CRM and xRM systems as a part of larger solutions.

My change in direction has also made me seriously think about what can be data driven and abstracted away to allow much more powerful solutions. I’m looking at MS CRM’s metadata in a completely new way these days as I integrate MS CRM with EF, RIA services and Silverlight 3. Taking a page from MS CRM’s form designer I’m now building Silverlight XAML based on metadata.

I’m also working on creating a developer level product out of my MS CRM import framework. (Think Scribe but for developers with complete control over everything for one time data migrations and for scheduled synchronizations.)

Enamored with MS

A real credit to the MS CRM framework is that I’m always looking at the holes in other technologies compared to what MS CRM allows as a development framework. It seems like they are all playing a game of catch up.

As a person who loves finding interesting ways to bend and mold MS CRM to do amazing things for businesses, I think the latest developments in EF, RIA and SL3 are really exciting. MS is really giving us great building blocks to create better and more powerful solutions that really improve the user experience. MS should be blushing right now and waiting for me to pucker up and give them a kiss.

Didn’t always feel this way

Now don’t get me wrong. I didn’t drink the MS Kool-Aid early in my career. I was focused around UNIX technologies for over a decade, QNX (digital Mastering console with proprietary parallel processing backplane), SCO UNIX (tracking nuclear waste shipments by satellite) and (Continuous Emissions Monitoring systems), Interactive, AIX ( Medical Systems ). I also touched HP/UX, IRIX, Coherent and Linux to a lesser extent.

At one point all serious work was done in UNIX, period. Now that am creating business solutions, I really can’t see any competitors to the business infrastructure and products that MS has and is developing. MS has so many technologies that really deliver and connect together easily that I rarely feel like I can’t create a solution to any problem. Maybe I’m just having some really good development days lately, but it just seems like a lot of new technologies are really evolving well.

So how does this impact my blog?

I’m still working with all of the MS CRM API’s, but have noticed that a lot of things are so second nature that I don’t even think about them any more. The result is that I have less urges to write a blog articles. I continue to read and answer questions in the newsgroup microsoft.public.crm.developer which is sometimes a source of inspiration for blog articles, and I expect to add some content soon on using the MS CRM metadata web service, so time will tell.

I’m also considering creating a secondary blog dealing with the fun of global development, virtual dev teams, finding talent, maximizing personal productivity, tools and lessons learned.

Of course the trick is keeping balance in my life while doing this. I’ve been very fortunate that I continue to be found by some great customers who have been fun to work with and have very interesting and challenging work. I am even more fortunate to have a great wife who pulls me away from the computer to play ( cycling, mountain biking, hiking, etc.. ).

Looking forward to the road ahead!

RFC822 Import to MS CRM email activity utility

2009-06-22T19:24:00.001-04:00

When migrating from Goldmine and some other CRM systems to MS CRM there is sometimes a need to import historical email. This is frequently stored in a SQL database in rfc822 format. RFC822 is an email format standard.

What I am providing is a single class along with a file from the MS CRM SDK that this class currently uses. This single class is consolidated from a number of other classes in my import framework and is intended to give you a nearly complete rfc822 import solution that you can modify for your needs. Every place that you need to make a modification according to your particular system has a //TODO: comment explaining what you need to adjust particular to your configuration. In addition assume that there will be some tweaking required, and make sure to do thorough debugging and testing to verify that your email records are being properly generated.

You can download the source code here.

There are 2 steps to using this class.

Part 1: Initialize a new RFC822ToEmailActivity object.

var emailConversion = new RFC822ToEmailActivity("Contoso"); // Your Orgname

Part 2: Calling the CreateEmailFromRfc822Record() method

CreateEmailFromRfc822Record() should be called in your loop that is reading the rfc822 records

var emailEntity = emailConversion.CreateEmailFromRfc822Record(     rfc822Record, // This is the string holding the whole 822 record     localEmailDomainName, // This is the local email domain name ex. onecrmpro.com      emailOwnerId, // systemUserId of email entity owner     relatedEntityName, // contact or account or....     relatedEntityId // id of the entity to regard the email to
)

Calls parsing method
Creates email attachments from pathnames returned from parsing method.
Writes to an error log file with all attachments that are not found and other errors.
Makes any other changes to the email entity before saving it.
Sets Email State as completed (sent or received) based on local domain name.

Called Internally: ParseRFC822() parsing and email activity creation.

Parse an rfc822 record
Create an email activity based on that record.
Compare email addresses, both To: and From: with a local domain name to decide if the email is incoming or outgoing.
Create ActivityParties for To:, CC:, BCC:, From: related to CRM users, Contacts, Accounts and Leads in that match order precedence.
Return a list of pathnames to any attachments.

RFC882 Email Attachments

Products like Gold Mine are storing email bodies in the database but they only have pathnames to the attachments. These attachment paths are frequently on the end user’s local computer which can be unreliable. These attachments may have been renamed, moved or deleted.

Hint1: Create a single shared folder on a file server with a separate tree branch for each computer that has attached files in the email history and modify the pathnames programmatically to match the structure you create on the file server.

Example:
S:\importattachments\C\Documents and Settings\mkovalcson\My Documents

Hint2: Comment out or create a test mode where nothing is written into the CRM database, but missing attachments are still written to a log file where you can see what isn’t found and decide how important it is to hunt attachments down before the final import.

You may want to look at this before you get started.
MS CRM Data Import (Cleaning up the Mess)

MS CRM 4.0 Entity Mapping and Hidden Mappings

2009-06-13T08:41:00.001-04:00

Microsoft has a powerful way to manage automatic attribute mappings from entities created from other entities. Typically we see this in the QOI process where an Opportunity is created, and then a Quote, Order or Invoice can be created from the Opportunity and much of the information is automatically copied from the Opportunity to that Quote, Order or Invoice.

Entity Mapping

If you open up your Opportunity from Customize Entities and look at 1:N Relationships, you can see the opportunity_quotes relationship.

If you double click on that you will see mappings. This shows you the names of each source opportunity attribute that is “Mapped” to a target quote attribute when a Quote is created from an opportunity.

This is very useful if you want to add custom fields and have those automatically propagated too or if you want to disable any default mappings.

So what about mapping the opportunityproduct? or quotedetail, salesorderdetail, and invoicedetail for that matter?

Hidden Entity Mapping

Step 1. You need the EntityMapId for the relationship that you want to map.

You can manually scan the EntityMapBase table matching against the SourceEntityName and TargetEntityName.

Or you can write a select like the one below to get a nice list of Guids to copy and paste into a temporary form.

Select TargetEntityName, EntityMapId from dbo.EntityMapBase
where SourceEntityName = 'opportunityproduct'

Step 2. Take the following URL and replace your server name and the EntityMapId of your choice to gain access to the rest of the mappingList editors.

http://localhost:5555/Tools/SystemCustomization/Relationships/Mappings/mappingList.aspx?mappingId=3A116CD4-A5EE-DD11-BDF0-0003FFEB167C

CRM Demos, SSD Drives and Virtual Machines

2009-05-23T06:38:00.001-04:00

When doing a demo you never want the software to look slow, and when doing CRM development against virtual machines performance is always critical to being efficient.

The Hardware
Samsung recently released their new 256Gb SSD drive and for me this drive signals that SSD drives have become mature. Intel has had very fast SSD drives available, but they were not very large. Like most other SSD drives they suffered from a condition where over time the drive would drop dramatically in performance. Samsung’s new drive has algorithms to minimize this to the point of it being of it being much less noticeable while still performing very similarly to the Intel SSD’s in access time and throughput.

So hoping that this drive lived up to my expectations, I replaced my laptop’s 7200 rpm 160Gb drive with Samsung’s new 256Gb SSD drive. My main concern was that running my VM’s off the system drive would still be unacceptable.

Virtual Machines
Before: I have run my vhd files from separate Firewire 800 Raid 0 drives. Keeping the system drive separate from the VHD was critical to getting good virtual machine performance.

After: The MS CRM 4.0 VHD 2009 now loads up in a mere 14 seconds while still running on the system drive versus 52 seconds on my external Firewire 800 drive. VS 2008 loads up after a clean boot(nothing cached) in 17 seconds and closes in 2 seconds compared with 57 and 13 seconds on my old drive.

Developing against a VM while on battery
This allows real development work to be done while running on battery power. The new SSD drive uses less power than the original drive did, and lugging around external drives for demos is now unnecessary.

As I write this the new Samsung drive is currently available at Dell as part 341-9999 for $699.99. For this you get 256Gb at the speed of a 10,000 rpm RAID system that fits in a laptop while sipping at your batteries. In some ways, especially average access time, it actually blows an expensive and bulky RAID system away.

Even MORE Speed Possible
I’ve seen reports twin drive laptops getting transfer rates of 300 MB/sec with two of these Samsung drives in a RAID 0 configuration. For comparison a single Samsung drive has a transfer rate of 200MB/sec which is still a lot faster than the 60Mb/sec of a 7200rpm internal laptop drive my less than a year old laptop was using.

The Installation
The replacement was easy. I used my Acronis backup software to make a complete disk backup to one of my external RAID drives. For my Dell M6300 I had to remove 4 screws, pull the drive out. Remove two more screws for the surrounding case. Screw the new drive into the case, slide it into the computer and put the 4 attaching screws back in. Boot from the Acronis CD. It recognizes all of my external drives USB and Firewire. Use the Acronis software to “add a drive” and partition it. Then restore the backup, remove the CD and reboot. The backup and restore(much faster) took me about 2.5 hours. Everything else took about 15 minutes.

MS CRM 4.0 Generate SSRS reports by webservice ( pdf , HTML , CSV , etc..)

2009-05-18T09:12:00.001-04:00

Below is a Generic SSRS web service reporting method that generates a byte[] perfect for use in an annotation or email attachment. The example method above it shows how to call this method and how to create an annotation attachment.

You can combine this with my post on driving email templates and generating email attachments to create some very powerful solutions. If you need a primer on activity parties see my post on creating activity parties.

Generating SSRS reports by web service is a very valuable tool. I frequently use this to generate custom reports from custom web applications running in iframes such that the report is run with the permissions of the user running the report. To take advantage of this the reports must be run against MS CRM’s filtered views.

To Generate an SSRS report by web service do the following:

1. Add a report execution web reference to your solution. Make sure this link is accessible. The url should be something like the following:
http://<SRS_Server_Name>/ReportServer/ReportExecution2005.asmx

2. Build up the parameters that you need to generate the report.

3. Select the Report Name of your Report

4. Specify the Type of Report

5. Specify the Device information ( formatting )

The example method CallReport() below demonstrates these steps. It in turn calls GenerateSRSbytes which makes the actual web service call.

using System.Net;
using Microsoft.Win32;
using ReportExecutionService;


public class SRSReporting
{

    public void CallReport()
    {
        string reportServiceUrl = "http://<SRS_Server_Name>/ReportServer/ReportExecution2005.asmx";

        // Create the Report Service Url from the registry
        RegistryKey key = Registry.LocalMachine.OpenSubKey("Software\\Microsoft\\MSCRM", false);

        if (key != null)
        {
            reportServiceUrl = (string)key.GetValue("SQLRSServerURL") + @"/ReportExecution2005.asmx";
        }

        // Report parameter Name and Value fields are strings.

        string reportParameter = "type";
        string reportValue = "annual";

        // Create as many parameters as you need.
        var parameters = new[]
         {
             new ParameterValue {Name = "entityid", Value = "0031a390-0d42-de11-9aa9-0003ff517b20"},
             new ParameterValue {Name = reportParameter, Value = reportValue}
         };

        // Pathname to the report from Reporting Services, where TestReport is the rdl uploaded using http://<SRS_Server_Name>/Reports
        // Make sure that you set the Data Source properly
        // Make sure to set security properly
        string reportName = "/AutomatedCRMReporting/TestReport";

        // Specify what type of report you want to create HTML,PDF, CVS, Excel, Word, XML, MHTML, Image
        string reportFormat = "PDF";

        // Specify the device information to control the output of your report.
        //For device information See http://msdn2.microsoft.com/en-us/library/ms155397.aspx
        string deviceInformation = "<DeviceInfo><DpiX>240</DpiX><DpiY>240</DpiY><StartPage>0</StartPage></DeviceInfo>";

        // Generate a report in a format for a CRM annotation or email attachment
        byte[] generatedReport = GenerateSRSbytes(reportName, parameters, reportFormat, deviceInformation, reportServiceUrl, null, null, null);

        // An example attachment created from an SRS report
        //var newAnnotation = new annotation
        //  {
        //      objectid = CrmTypes.CreateLookup(regardingEntity, regardingId),
        //      objecttypecode = CrmTypes.CreateEntityNameReference(EntityName.contact.ToString()),
        //      isdocument = CrmTypes.CreateCrmBoolean(true),
        //      ownerid = CrmTypes.CreateOwner(EntityName.systemuser.ToString(), ownerId),
        //      filename = reportFileName,
        //      documentbody = Convert.ToBase64String(generatedReport),
        //      filesize = CrmTypes.CreateCrmNumber(generatedReport.Length),
        //      subject = reportFileName
        //  };

        //service.Create(newAnnotation);
    }


    /// <summary>
    /// Generates an SSRS Report and returns a byte[] for a CRM attachment
    /// </summary>
    /// <param name="reportPath">Name of the report.</param>
    /// <param name="parameters">The parameters.</param>
    /// <param name="outputFormat">The output format.</param>
    /// <param name="deviceInformation">The device information. See http://msdn2.microsoft.com/en-us/library/ms155397.aspx</param>
    /// <param name="ReportServiceUrl"></param>
    /// <param name="userName">if null, DefaultNetworkCredentials are used</param>
    /// <param name="passWord">if null, DefaultNetworkCredentials are used</param>
    /// <param name="domainName"></param>
    /// <returns></returns>
    public static byte[] GenerateSRSbytes(string reportPath, ParameterValue[] parameters, string outputFormat, string deviceInformation, string ReportServiceUrl, string userName, string passWord, string domainName)
    {
        string encoding;
        string mimeType;
        string extension;
        string[] streamIDs;
        string SessionId;
        string historyID = null;
        Warning[] warnings;

        // By default the Report will run with the permissions of the AD authenticated User.
        var rs = new ReportExecutionService.ReportExecutionService
        {
            Credentials = System.Net.CredentialCache.DefaultNetworkCredentials,
            Url = ReportServiceUrl
        };


        // Impersonate credentials if they are specified. 
        if (userName != null && passWord != null)
        {
            if (domainName == null)
            {
                rs.Credentials = new NetworkCredential(userName, passWord);
            }
            else
            {
                rs.Credentials = new NetworkCredential(userName, passWord, domainName);
            }
        }

        // Set timeout in seconds of the report takes a long time.
        //rs.Timeout = 600000;

        ExecutionHeader execHeader = new ExecutionHeader();
        rs.ExecutionHeaderValue = execHeader;

        var execInfo = new ExecutionInfo();
        execInfo = rs.LoadReport(reportPath, historyID);

        rs.SetExecutionParameters(parameters, "en-us");

        SessionId = rs.ExecutionHeaderValue.ExecutionID;

        // Render Report
        return rs.Render(outputFormat, deviceInformation, out extension, out mimeType, out encoding, out warnings, out streamIDs);

    }
}

Happy Coding!

MS CRM 4.0 Many to Many Query helper

2009-05-13T13:37:00.001-04:00

Rather than trying to explain how to query a many to many relationship, I thought it might be easier for many people to take a working generic method that retrieves a collection of entities from a Many to Many relationship and modify it as needed.

When a many to many relationship is created CRM creates a link table. Default naming conventions could give you a name like this

new_new_entity1_new_entity2

which is a link table between new_entity1 and new_entity2

The three entities involved are the following:

linkTableEntity - new_new_entity1_new_entity2
filterEntity – new_entity1

put your conditions against this

returnedEntity – new_entity2

specify your return attributes against this

The arguments to call this method are the following:

service = ICRMService
linkTableEntityName= "new_new_entity1_new_entity2"
filterEntityName = "new_entity1"
filterEntityIdName = "new_entity1id"
filterAttribute = "new_name"
filterValue = "my entity’s name"
returnedCollectionEntityName = "new_entity2"
returnedCollectionIdName = "new_entity2id"
returnedAttibutes = null //null returns all columns
or returnedAttributes = new[]{"new_entity2id","new_name"}

/// <summary>
/// Generic Method to retrieve a collection of all DynamicEntities related to another Entity in a Many to Many relationship
/// 
/// 
/// </summary>
/// <param name="service"></param>
/// <param name="linkTableEntityName"></param>
/// <param name="filterEntityName"></param>
/// <param name="filterEntityIdName"></param>
/// <param name="filterValue"></param>
/// <param name="returnedCollectionEntityName"></param>
/// <param name="returnedCollectionEntityIdName"></param>
/// <param name="filterAttribute"></param>
/// <param name="returnedAttributes">if null, AllColumns() is used</param>
/// <returns></returns>
public static BusinessEntityCollection RetrieveEntityCollectionFromManyToMany(ICrmService service, 
    string linkTableEntityName,
    string filterEntityName, string filterEntityIdName, string filterAttribute,  string filterValue,
    string returnedCollectionEntityName, string returnedCollectionEntityIdName, string[] returnedAttributes)
{
    // Selection against linked Filter Entity
    var con = new ConditionExpression
    {
        AttributeName = filterAttribute,
        Operator = ConditionOperator.Equal,
        Values = new[] { filterValue }
    };

    var filter = new FilterExpression
    {
        FilterOperator = LogicalOperator.And
    };
    
    filter.AddCondition(con);

    // the Entity that you are filtering with
    var filterLinkEntity = new LinkEntity
       {
           LinkToEntityName = filterEntityName,
           LinkFromAttributeName = filterEntityIdName,
           LinkToAttributeName = filterEntityIdName,
           LinkCriteria = filter
       };
    
    // The linktable Entity that CRM generates
    var linkTableEntity = new LinkEntity
      {
          LinkToEntityName = linkTableEntityName,
          LinkFromAttributeName = returnedCollectionEntityIdName,
          LinkToAttributeName = returnedCollectionEntityIdName
      };

    linkTableEntity.LinkEntities.Add(filterLinkEntity);

   
    // The Entity returning the results
    var expression = new QueryExpression
    {
        EntityName = returnedCollectionEntityName
    };

    // Set columns being returned
    if (returnedAttributes == null)
    {
        expression.ColumnSet = new AllColumns();
    }
    else
    {
        expression.ColumnSet = new ColumnSet(returnedAttributes);
    }

    expression.LinkEntities.Add(linkTableEntity);

    var request = new RetrieveMultipleRequest {Query = expression, ReturnDynamicEntities = true };

    var response = (RetrieveMultipleResponse)service.Execute(request);
    
    return response.BusinessEntityCollection;
}

Accessing and Controlling the CrmForm from an iframe.

2009-04-09T10:34:00.001-04:00

If you write custom web applications in iframes that depend on the data in the parent form, it is important to run on up to date information to avoid user confusion.

Important! This requires that the Restrict cross-frame scripting box for your iframe is NOT checked.

Accessing attribute values on the Parent Form can be done simply by adding a parent.document in front of your normal attribute names. This gets you the values currently on the form, but doesn't guarantee those values have been saved.

var myAttributeValue = parent.document.crmForm.all.new_attribute.DataValue;

Parent Form Save "if modified" This is a nice method to call because if there are no modified values on the form it won't do anything and your application can continue on it's merry way.

parent.document.crmForm.Save();

Force a Parent Save Sometimes you want to force a save so that a Plug-in is called to do some additional calculations even though no attributes have been modified on your current form. The recalculate on the Opportunity, Quote, Order, and Invoice forms is a good example.

Note: The SubmitCrmForm method is not a MS supported method, but it hasn't changed in the last couple CRM revisions.

SubmitCRMForm( Mode, Validate, ForceSubmit, closeWindow)

Modes:
1 = Save, 2 = SaveAndClose, 7 = Send,
58 = SaveAsCompleted, 59 = SaveAndNew

Example: In this example I am forcing a save so that a plug-in is called on the Pre Update for the quote to create a new total value from the quote details that were filled in when the Quote was created from an Opportunity. These new fields were mapped between the detail products see Mapping Note below. The iframe contains a button to do something that requires all of the data on the quote be up to date.

function RecalculateQuote() 
{ 
   if ( parent.document.crmForm.all.new_totalamount.DataValue == null)
   {    
    parent.document.crmForm.SubmitCrmForm(1, true, true, false);   
    return false;      
    } 
    
    parent.document.crmForm.Save();
}

The above JavaScript is made to work with an OnClientClick so that a return false will not generate a postback.

Why do we need a return false option? If the validation fails, a message is generated for the user, the save is not performed, and you do not want your action to run.

The data has already been filled in, then the crmFrom.Save() will check to make sure that any modified fields on the form have been saved.

<asp:Button ID="RunMyNeatFeature" CssClass="button" runat="server" Text="Go" 
OnClick="RunMyNeatFeature_Click"  
OnClientClick="javascript:return RecalculateQuote();"/>

For the button the OnClick will PostBack and run the functionality I care about only if the RecalculateQuote() is not false.

This safeguards the user from running the functionality with different data than what is on the screen when they press the "Go" button.

Mapping Note: For mapping details open SQL Management Studio and look at the EntityMapBase table to find the EntityMapId that has the SourceEntityName and TargetEntityName that you are interested in. Add your guid to the end of the URL below and it will bring up a form to map attributes between the Source and Target Entities.

http://yourcrmservername:5555//tools/systemcustomization/relationships/mappings/mappinglist.aspx?mappingId=

Techniques for Driving MS CRM Email Templates

2009-03-15T10:52:00.001-04:00

The email templates in MS CRM can be leveraged as a powerful building block when generating emails programmatically.

Tips:

Generate your HTML in another editor and then paste it into the template editor to add data slugs.
Associate your template with the entity that you want the most information from.
Use Template Naming conventions that organize things and make programmatic template selection easier.

For an example lets say that we have product specific Quote Letters.

Using my helper method from a previous blog article, grab an email template matching a specific name based on the product.

// Get appropriate Template
BusinessEntityCollection templates = 
   h.GetAllEntitieswithFilter(EntityName.template.ToString(), new[] { "templateid" }, new[]{"title"}, new[]{emailTemplateTitle});

Then create a new InstantiateTemplateRequest using the template id and point it at an entity with the information that you want merged in. This must be the same type that you associated your template with when you created it.

var instTemplate = new InstantiateTemplateRequest
     {
         TemplateId = thisTemplate.templateid.Value,
         ObjectId = quoteId,
         ObjectType = EntityName.quote.ToString()
     };


// Execute the request to create an email message from the template.
var instTemplateResponse = (InstantiateTemplateResponse)h.service.Execute(instTemplate);

var newEmail = (email)instTemplateResponse.BusinessEntityCollection.BusinessEntities[0];

The result of the InstantiateTemplateResponse is an email entity collection. For this example we just have one email.

From here you can regard the email to a completely different entity if you want. It is only important that the ObjectId and ObjectType be set for the merge process. After that is complete this is just another email with a bunch of fields pre-filled. Now you can have your way with it like any other email that you created from scratch. This is critical to making the best use of email templates.

Additional Merging
If you are calculating other numbers or pulling information from another data source outside of CRM, there is no reason to limit merging to what can be represented as data slugs.

In this example I am using putting additional information into the email body with a simple string replace using an agreed upon naming convention to represent additional merge fields.

// If template had #EmbedLicense# in body replace it with the license information
newEmail.description = newEmail.description.Replace("#EmbedLicense#", embedFile);

From here you can add attachments as shown here.

Proofing before Email is Sent
Another useful thing to do if you are doing this in a web application or a client Winform application is save the email and then open it in a new window for final review before it is sent. To do that generate a URL like the following with your orgname and email id passed in. You can get the CRM server base URL from the registry as shown here which you need for your web service reference, and then use the following: CrmServerBaseUrl = CrmServiceUrl.Substring(0, CrmServiceUrl.ToLower().IndexOf("mscrmservices"));

 // Open newly created email activity at this Url.
var emailUrl = h.CrmServerBaseUrl + "/"+orgname+"/activities/email/edit.aspx?id={" + emailId + "}";

From a WinForm application you can pop a CRM screen up like this.

For a web application register some JavaScript in the code behind that sets the value of the new email's URL.

 // Sets Javascript variables to envoke Window Open to new Explorer Window with body onload event
const string SETQUERYSTRING_SCRIPT = "Email_String";

if (!Page.ClientScript.IsClientScriptBlockRegistered(SETQUERYSTRING_SCRIPT))
{
   Page.ClientScript.RegisterClientScriptBlock(GetType(), SETQUERYSTRING_SCRIPT, string.Format(@"<script language=""javascript"">emailRecordUrl = '{0}';</script>", emailUrl));
}

Then in the aspx file use the following JavaScript code to open the new window. Call the script from the onload of the body.

   <script type="text/javascript">

    var emailRecordUrl = "";   
    
    function UpdateCRMFormGenerateEmail()
    {
       if (emailRecordUrl != "")
       {
           window.open( emailRecordUrl, 
               "_blank", "toolbar=no,scrollbars=yes,resizable=yes");
           emailRecordUrl = "";
       }   
   }

    </script>
</head>
<body onload="UpdateCRMFormGenerateEmail();">

MS CRM 4.0 Plug-in Stages, Pipelines and Execution Modes

2009-02-25T10:17:00.001-05:00

I've found a lot of contradictory information and misinformation about what you can and can't do inside of a plugin depending on how you are calling it, and when you should call each one, so I hope this will help.

Stage of Execution:

Pre-Stage: (synchronous) called before the write to the database.

The main reasons to use a Pre-Stage of Execution are synchronous in nature:

Modify data before it is written to the database.
Abort the action being taken
Server Side Validity checking

Post-Stage: (synchronous or asynchronous)

Use the Post-Stage of Execution whenever you don't need to use Pre-Stage.

If you don't want the user to wait for the process to finish and there is no race condition use asynchronous.

Triggering Pipeline:

The triggering pipeline is a little less obvious in nature and has an impact on what functionality that you can use in your plugin.

Parent Pipeline: This is the pipeline that is the most common and there are no restrictions imposed in a parent pipeline.

Child Pipeline: This is the pipeline that causes the most confusion and there are limitations that vary with Stage and Execution Mode.

Sometimes a child pipeline is required to trap the event you need, and sometimes you need to trap both the parent and child pipeline for the same entity, message and stage.

Example: Change the quotenumber in the Pre-Stage for the Create of a Quote.

The quotenumber is a field that the CRM web service will not allow you to change after it is written to the database so you need to use the Pre-Stage and modify the context Entity before the end of the Execute method as shown below.

var entity = (DynamicEntity)context.InputParameters.Properties[ParameterName.Target];

// . . . retrieve data to populate number . . .

// Set value before it is written to the database

if( entity.Properties.Contains(numberField))
{
    entity.Properties.Remove(numberField);
}

var prop = new StringProperty(numberField, newNumber);
entity.Properties.Add(prop);

So far so good. This will work in any Pre-Create pipeline!

You can create a Quote in a few ways.

Sales -> Quotes -> New
(open an Account) -> Quotes -> New Quote
Sales -> Opportunities (open an opportunity) -> Quotes -> New Quote

Do you think that Creating a Quote always happens in the same pipeline?

Since you are an efficient plugin developer and are using the ICrmService and dynamic entities to access CRM data because it is pre-authenticated and fast. You retrieve some information to help create the number.

ICrmService service = context.CreateCrmService(true);
retrieved = (RetrieveMultipleResponse)service.Execute(retrieve);

You register your plugin using the handy plugin registration tool for the Quote entity with the following settings:

Create
Pre Stage
Synchronous
Parent Pipeline

You create your Quote from Sales -> Quotes -> New and it works!

However, in many business processes the user will create a Quote from an opportunity so it will inherit opportunityproduct information.

Now you create your quote from Sales -> Opportunities (open an opportunity) -> Quotes -> New Quote and for some reason your plugin did not fire. That is because this quote was created in a child pipeline.

The entire QOI chain also occurs in a child pipeline. If you create an order from a quote or invoice from an order it is happening in a child pipeline. There are other places that this occurs as well like creation of an account or contact from a lead.

You are in a child pipeline, now what ?

The first thing that you might try is to take your existing plugin and register it against the child pipeline, but it won't work. The ICrmService is not available to you in a child pipeline.

If you downloaded the plug-in template for CRM, you have probably seen the following method, which is what you need to use in a child pipeline.

/// <summary>
/// Creates a CrmService proxy for plug-ins that execute in the child pipeline.
/// </summary>
/// <param name="context">The execution context that was passed to the plug-ins Execute method.</param>
/// <param name="flag">Set to True to use impersontation.</param>
/// <returns>A CrmServce instance.</returns>
private static CrmService CreateCrmService(IPluginExecutionContext context, Boolean flag)
{
    var authToken = new CrmAuthenticationToken { AuthenticationType = 0, OrganizationName = context.OrganizationName, CallerId = (flag ? context.UserId : context.InitiatingUserId) };

    var corToken = new CorrelationToken { CorrelationId = context.CorrelationId, CorrelationUpdatedTime = context.CorrelationUpdatedTime, Depth = context.Depth };

    var regkey = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\MSCRM", false);

    var service = new CrmService
    {
        CrmAuthenticationTokenValue = authToken,
        UseDefaultCredentials = true,
        Url = String.Concat(regkey.GetValue("ServerUrl").ToString(), "/2007/crmservice.asmx"),
        CorrelationTokenValue = corToken
    };

    return service;
}

You may find another method called GetCrmProxyUsingEndpointUrlInChildPipeline. It is essentially the same.

There is a comment in the plugin template that doesn't tell the whole story.

// For a plug-in running in the child pipeline, use this statement.
// CrmService crmService = CreateCrmService(context, true);

What it doesn't mention is that what you are allowed to do with that service depends on what your execution mode is.

Hard Coded Restrictions:

A CrmService running Synchronously in a child pipeline is limited to the following:

Create
Delete
Update
RetrieveExchangeRate

However a child plugin running in Asynchronous Execution Mode is not limited this way.

Those 4 allowed actions are hard coded by MS whenever the plugin is executed inside a transaction, and it appears that all synchronous child pipeline events occur inside a transaction.

However you can do a query in child pipeline if it is registered as asynchronous.

In review:

Use ICrmService for all parent pipelines when at all possible.
Use CrmService for child pipelines in asynchronous execution mode.
There is very limited functionality allowed with CrmService for any plugin registered in a synchronous child pipeline
Querying CRM data in a plug-in registered as a synchronous Pre Create in a child process is currently very unsupported. (ie. direct SQL access)

Dynamic Entity and Entity query helper methods

2009-02-08T18:52:00.001-05:00

If you do much MS CRM development you will find that you are constantly querying for things. These are a couple helper methods that I have found come in handy.

There are some subtle differences between them.

Querying for Collections

The following 2 methods retrieve any entity, filtering on any attribute(s), ordering on any attribute(s), and returning any number of specified attributes. The only real restraint is that they are hard coded to anding the filters together and only comparing filters with an Equal condition operator.

BusinessEntityCollection opportunityCollection = webservicehelper.GetAllEntitieswithFiltersOrdered(
EntityName.opportunity.ToString(),
new[] "opportunityid", "name", "statecode" },
new[] { "customerid","statecode" },
new[] { thisAccount.accountid.Value.ToString(),"Open" },
new[] {"createdon"},
new[] {false});

BusinessEntityCollection opportunityCollection
= PluginHelper.GetDynamicEntitiesWithFiltersOrdered( EntityName.opportunity.ToString(),
new[] { "opportunityid", "name", "statecode" },
new[] { "customerid" },
new[] { accountId.ToString() },
new[] {"createdon"},
new[] {false},
service);

The following Helper methods do the exact same thing for strongly typed entities and then dynamic entities. They both return a BusinessEntityCollection but notice the differences in how they are implemented.

The first is for the strongly typed Entity.

public BusinessEntityCollection GetAllEntitieswithFiltersOrdered(string entity, string[] attributes, string[] fields, string[] values, string[] orderfields, bool[] orderAscending)
{

    var cols = new ColumnSet { Attributes = attributes };

    var conditions = new ConditionExpression[fields.Length];

    for (int i = 0; i < fields.Length; i++)
    {
        var condition = new ConditionExpression
        {
            AttributeName = fields[i],
            Operator = ConditionOperator.Equal,
            Values = new[] { values[i] }
        };

        conditions[i] = condition;
    }

    var filter = new FilterExpression
    {
        FilterOperator = LogicalOperator.And,
        Conditions = conditions
    };

    var orderArray = new OrderExpression[orderfields.Length];

    for (int i = 0; i < orderfields.Length; i++)
    {
        var thisOrder = new OrderExpression
        {
            AttributeName = orderfields[i],
            OrderType = (orderAscending[i] ? OrderType.Ascending : OrderType.Descending)
        };

        orderArray[i] = thisOrder;
    }


    var query = new QueryExpression
    {
        EntityName = entity,
        ColumnSet = cols,
        Criteria = filter,
        Orders = orderArray
    };

    try
    {
        return service.RetrieveMultiple(query);
    }

    catch (SoapException ex)

        var thisOrder = new OrderExpression
        {
            AttributeName = orderfields[i],
            OrderType = (orderAscending[i] ? OrderType.Ascending : OrderType.Descending)
        };

        orderArray[i] = thisOrder;
    }


    var query = new QueryExpression
    {
        EntityName = entity,
        ColumnSet = cols,
        Criteria = filter,
        Orders = orderArray
    };

    try
    {
        return service.RetrieveMultiple(query);
    }

    catch (SoapException ex)
    {
        emailNotifications.sendExceptionMessage(service.Url, " - GetAllEntitieswithFiltersOrdered FAILED:", errorEmails, ex,
            "<br/><br/>Entity: " + query.EntityName);
        throw;
    }
}

    {
        emailNotifications.sendExceptionMessage(service.Url, " - GetAllEntitieswithFiltersOrdered FAILED:", errorEmails, ex,
            "<br/><br/>Entity: " + query.EntityName);
        throw;
    }
}

The second is for a Dynamic Entity in a Plug-in.

public static BusinessEntityCollection GetDynamicEntitiesWithFiltersOrdered(string entityName, string[] attributes, string[] fields, string[] values, string[] orderfields, bool[] orderAscending, ICrmService serv)
{
    try
    {
        var filters = new FilterExpression { FilterOperator = LogicalOperator.And };

        for (int i = 0; i < fields.Length; i++)
        {
            var condition = new ConditionExpression
            {
                AttributeName = fields[i],
                Operator = ConditionOperator.Equal,
                Values = new[] { values[i] }
            };

            filters.Conditions.Add(condition);
        }
        
        var query = new QueryExpression
        {
            EntityName = entityName,
            ColumnSet = new ColumnSet(attributes),
            Criteria = filters
        };

        for (int i = 0; i < fields.Length; i++)
        {
            var oneExpression = new OrderExpression
                 {
                     AttributeName = orderfields[i],
                     OrderType = (orderAscending[i] ? OrderType.Ascending : OrderType.Descending)
                 };

            query.Orders.Add(oneExpression);
        }

        var retrieve = new RetrieveMultipleRequest { Query = query, ReturnDynamicEntities = true };

        var retrieved = (RetrieveMultipleResponse)serv.Execute(retrieve);

        return retrieved.BusinessEntityCollection;
    }

    catch (SoapException ex)
    {
        throw new InvalidPluginExecutionException(
             String.Format("An error occurred in GetDynamicEntitiesWithFilters plug-in. {0}", ex.Detail.InnerText), ex);
    }

    catch (Exception ex)
    {
        throw new InvalidPluginExecutionException(
           String.Format("An error occurred in GetDynamicEntitiesWithFilters plug-in. {0} - trace - {1} -  source - {2}", ex.Message, ex.StackTrace, ex.Source), ex);
    }
}

One of the largest differences between querying for these two types of collections is that you are assigning a complete arrays in one and adding to the other.

Case Responsible Contact To Email and other Activities

2009-01-19T08:58:00.001-05:00

A typical customer request is for email created from a Case to default to send to the Responsible Contact instead of its default behavior which is to send it to the Customer.

Since the Responsible Contact isn't even on the Case form by default and a customer could be a contact, MS chose this default behavior. However most of my installations to date have an Account as the Customer and one of many Contacts related to that Account as a Responsible Contact.

This is actually something very easy to change.

Please Note: This is an unsupported modification, and any patch could overwrite this.

There is a JavaScript file, cases.js, in the following folder.

C:\Program Files\Microsoft Dynamics CRM Server\CRMWeb\_static\CS\cases

It contains a function called locAddActTo that fills the To: activity party variables that are sent in the QueryString to the activity like the URL below.

http://crmserver1:5555/MicrosoftCRM/activities/email/edit.aspx?
pId={E0F2E676-7FE2-DD11-9AE8-0003FF517B20}
&pType=112
&pName=CaseTitleGoesHere
&partyid={0EDF3D7E-E3E0-DD11-A5F9-0003FF517B20}
&partytype=1
&partyname=AccountNameGoesHere
&partyaddressused=&contactInfo=

What we care about are the partyid, partytype and partyname arguments.

function locAddActTo(iActivityType, sContentId)
{
var sParentId   = null;
var sParentType = null;
var sPartyId   = null;
var sPartyType = null;
var sPartyName = null;
var sPartyLocation = null;


sParentId   = crmFormSubmit.crmFormSubmitId.value;
sParentType = crmFormSubmit.crmFormSubmitObjectType.value;


if (iActivityType != Task)
{
var customerId = crmForm.all.customerid.DataValue;
if (!IsNull(customerId))
{
if (!IsNull(customerId[0]))
{
sPartyId   = customerId[0].id;
sPartyType = customerId[0].type;
}
}
sPartyName = crmForm.customerid.parentElement.previousSibling.innerText;

sPartyLocation = "";
}

As you can see this information is being pulled from the case form customer field crmForm.all.customerid.DataValue

So all we have to do is change this to crmForm.all.responsiblecontactid.DataValue

and change the sPartyName assignment.

sPartyName = crmForm.customerid.parentElement.previousSibling.innerText;
to
sPartyName = customerId[0].name;

You can just replace the above function with the one below if you would like.

function locAddActTo(iActivityType, sContentId)
{
var sParentId   = null;
var sParentType = null;
var sPartyId   = null;
var sPartyType = null;
var sPartyName = null;
var sPartyLocation = null;


sParentId   = crmFormSubmit.crmFormSubmitId.value;
sParentType = crmFormSubmit.crmFormSubmitObjectType.value;


if (iActivityType != Task)
{
var customerId = crmForm.all.responsiblecontactid.DataValue;
if (!IsNull(customerId))
{
if (!IsNull(customerId[0]))
{
sPartyId   = customerId[0].id;
sPartyType = customerId[0].type;
sPartyName = customerId[0].name;
}
}


sPartyLocation = "";
}

After you have saved the change, run iisreset to flush the cache.

That's it.

CRM 4.0 Custom Workflows

2009-01-18T11:03:00.001-05:00

Custom Workflows in MS CRM 4.0 are very simple to deploy and are pretty simple to create especially if you are familiar with Plugin-in development.

Before you can create a workflow you need to have the Workflow Extensions installed. This is more of a concern if you are running VS2005. If you are running VS 2008 SP1, you should have everything you need already.

If you have an assembly that you are already deploying for plug-ins you can even add a workflow to that assembly so that you have fewer deployment assemblies.

The following custom workflow was created for a customer who wanted to have a matching customer sales relationship created for an account whenever an opportunity role was assigned to a contact.

namespace OneCRMPro
{
    // In the workflow editor
    // "OneCRMPro" is going to show up at the bottom of the Add Step pick list
    // "Create CustomerRelationship" will show up as item off of OneCRMPro.
    [PersistOnClose]
    [CrmWorkflowActivity("Create CustomerRelationship", "OneCRMPro")]
    public partial class CreateCustomerRelationship : SequenceActivity
    {

        // These DependencyProperty entries will show up in the Set Properties editor
         
        public static DependencyProperty RoleProperty = DependencyProperty.Register("Role", typeof(Lookup), typeof(CreateCustomerRelationship));
        [CrmInput("Sales Role")]
        [CrmReferenceTarget("relationshiprole")]        public Lookup Role
        {
            get { return (Lookup)GetValue(RoleProperty); }
            set { SetValue(RoleProperty, value); }
        }

        public static DependencyProperty CustomerProperty = DependencyProperty.Register("Customer", typeof(Lookup), typeof(CreateCustomerRelationship));
        [CrmInput("Customer Contact")]
        [CrmReferenceTarget("contact")]
        public Lookup Customer
        {
            get { return (Lookup)GetValue(CustomerProperty); }
            set { SetValue(CustomerProperty, value); }
        }


        // End Set Properties


        /// <summary>
        /// Execute is called when the custom workflow is invoked
        /// </summary>
        /// <param name="executionContext"></param>
        /// <returns></returns>
        protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
        {
            //Get a workflow context
            var contextService = executionContext.GetService(typeof(IContextService)) as IContextService;
            var workflowContext = contextService.Context;

            CreateRole(workflowContext);

            return ActivityExecutionStatus.Closed;
        }


        /// <summary>
        /// Create a matching sales customer relationship role
        /// </summary>
        /// <param name="context"></param>
        private void CreateRole(IWorkflowContext context)
        {
            try
            {
                // Get Guids of Customer and RelationshipRole
                Guid contactId = Customer.Value;
                Guid salesRoleId = Role.Value;

                // get a local service
                ICrmService service = context.CreateCrmService(true);

                // Grab the contact involved
                var cols = new ColumnSet(new [] {"parentcustomerid"});
                
                var thisContact = (contact)service.Retrieve(EntityName.contact.ToString(), contactId, cols);

                // Create a cooresponding customer relationship
                var role = new customerrelationship
                {
                    customerid = thisContact.parentcustomerid,
                    partnerid = CrmTypes.CreateCustomer(EntityName.contact.ToString(), contactId),
                    partnerroleid = CrmTypes.CreateLookup(EntityName.relationshiprole.ToString(), salesRoleId)
                };

                service.Create(role);
            }

            catch (SoapException)
            {
                // Handle error
            }

            catch (Exception)
            {
                // Handle error
            }

        }


    }

}

Before you can use your workflow it needs to be strongly signed and registered. Its assembly is registered in the same way as a plugin, but it doesn't require registering it at the entity or event level. If you don't have the plugin Registration Tool you can find it here. Plugin Deployment Tool

When you create a new Workflow you can now select this custom Workflow when you "Add Step" and pick the following at the bottom of the list.

OneCRMPro > Create CustomerRelationship

Now when you "Set Properties", you will see below how the DependencyProperty values will show up below.

The CrmInput keyword specifies the Property Name and the CrmReferenceTarget keyword specifies the expected attribute type to be mapped.

That's about it. Publish your workflow and try it out!

MS CRM 4.0 Filtered Lookups

2008-12-20T16:03:00.001-05:00

I just finished implementing a number of filtered lookups with Michael Höhne's Stunnware Filtered Lookup 4.0. Like most developers I have to think seriously about whether I want to build something vs. pay for someone else's work.

There has been a lot of work put into this product since its introduction with CRM 3.0. The 4.0 release seems pretty well sorted and really makes creating filtered lookups an easy task to accomplish. Supporting the Outlook client, multiple languages, multi-tenancy, and IFD makes this a much better solution then most(probably all) of us would take the time to build on our own.

Filtered Lookups have been reinvented far too many times and become maintenance issues for many upgrading from CRM 3.0 to CRM 4.0. I would rather not have to dig through another guy's failed attempt at this functionality in the future. I personally believe MS should pull this functionality into its product, but barring that, I think using a product like this is the best way to go.

I'm currently using it for a growing list of filtered Lookups for one my customers. This includes some pretty standard lookups like the Account: Primary Contact Lookup, the Case: Responsible Contact, and the Email To:, CC:, and BCC: fields, as well as some for custom fields.

What is typically involved in making a filtered lookup with this tool is the following:

Settings -> Filtered Lookup: Create a Retrieve Multiple Queries entity
- This may involve using the Fetch Wizard to generate the query.
Settings -> Filtered Lookup: Create a Single-View Lookup entity
Settings -> Customizations: Add JavaScript to your entity's OnLoad event.

Here is a simple example:

I needed a filtered list for Reseller Accounts on an opportunity.

So I created a new Retrieve Multiple Query entity,

copied the Query from the Active Accounts example and added a filter for an industrycode picklist value of 21,

created a Single-View Lookup using the Query above,

setup the columns for that Lookup,

set the Labels to English,

added this JavaScript to my Opportunity's OnLoad Event. Published the opportunity and I was done.

SW_IS_LICENSED_USER = false;

try 
{
    var httpRequest = new ActiveXObject("Msxml2.XMLHTTP");
    httpRequest.open("GET", prependOrgName("/isv/stunnware.com/cld4/cld4.aspx?orgname=" + ORG_UNIQUE_NAME), false);
    httpRequest.send(null);
    eval(httpRequest.responseText);
}

catch(e) {
}

if (SW_IS_LICENSED_USER) 
{
    var resellerAccountLookup = new SwSingleLookup("new_resellerid");

    if (resellerAccountLookup.existsOnForm()) 
    {
         resellerAccountLookup.setLookupClass("ResellerAccounts");
     }
}

All in all that took maybe 10 minutes including testing.

That was a very simple case. The examples in the help file show you how to create the Account: Primary Contact filtered lookup showing only Contacts associated with that Account. Implementing this only required cutting from the example and pasting into the OnLoad Event of the account form. Another example gave me the information I needed to to implement the Case Responsible Contacts Filter where the Filtered Lookup changes when the case's account is changed. This required a little JavaScript added to the OnChange for the customerid as well as the Onload for the form.

The email modifications I made were also very easy to implement as shown in the code that follows. Since the Account is almost always preloaded in the To: field, it was easy to overload the lookups for the target selections to default to the Contacts related to that Account.

SW_IS_LICENSED_USER = false;

try {
    var httpRequest = new ActiveXObject("Msxml2.XMLHTTP");
    httpRequest.open("GET", prependOrgName("/isv/stunnware.com/cld4/cld4.aspx?orgname=" + ORG_UNIQUE_NAME), false);
    httpRequest.send(null);
    eval(httpRequest.responseText);
}

catch(e) {
}

if (SW_IS_LICENSED_USER) 
{  
   if ( crmForm.all.to.DataValue != null )
   {
     var accountid =  crmForm.all.to.DataValue[0].id;
    
     var toContactLookup = new SwSingleLookup("to");
     toContactLookup.setParameter("parentcustomerid", accountid);
     toContactLookup.setLookupClass("AssociatedContacts");

     var ccContactLookup = new SwSingleLookup("cc");
     ccContactLookup.setParameter("parentcustomerid", accountid);
     ccContactLookup.setLookupClass("AssociatedContacts");

    var bccContactLookup = new SwSingleLookup("bcc");
    bccContactLookup.setParameter("parentcustomerid", accountid);
    bccContactLookup.setLookupClass("AssociatedContacts");
   }

}

For this instance I am still relying on the Form Assistant if the end user wants to select multiple Contacts for a single field or add a CRM user, which is a rare case for this customer. The Form Assistant is not modified by these lookups in any way.

Understanding 3 Important Lines of Code
There are three important lines of code to that you will use to create a filtered lookup.

1. Create a new lookup to override the existing lookup for specified field on the form. In this case the "to" field on the email form.

var toContactLookup = new SwSingleLookup("to");

2. Set a filter parameter that is defined in your Fetch and assign a value.

toContactLookup.setParameter("parentcustomerid", accountid);

Below is the Fetch that you can access under settings. Notice the parentcustomerid field in the filter section. You are not limited to a single parameter if you need additional criteria for your filter.

<fetch mapping="logical">
   <entity name="contact">
      <attribute name="emailaddress1" />
      <attribute name="telephone1" />
      <attribute name="fullname" />
      <order attribute="fullname" />
      <filter>
         <condition attribute="statecode" operator="eq" value="0" />
         <condition attribute="parentcustomerid" operator="eq" param="parentcustomerid" />
      </filter>
   </entity>
</fetch>

3. Set the class that you are using.

toContactLookup.setLookupClass("AssociatedContacts");

That's it, just save your customization and publish. You now have a working filtered Lookup.

Just the Beginning
These are some very simple examples, but it is obvious how easily much more complex filters could be. If you are going to create complex Retrieve queries, it is worth downloading the Fetch Wizard as well, which is a really easy way to create the XML needed for the fetches that this tool relies on. The Fetch Wizard is part of the Stunnware Tools 4.0. that are available for download at no charge.

What you will see Under Settings-> Filtered Lookup are the following which will allow you to configure everything but the little bit of JavaScript that you will add to your forms, and there are even tools for tracing your filtered lookups if something isn't working quite right.

This tool is made for a developer to use, but a person comfortable with customizing CRM and with some JavaScript experience should be able to get by. It requires an installation process that can require you to manually update the XML of your ISV.config and SiteMap, but if you read the instructions, it will all make sense.

If you are playing with the MS CRM 4.0 VPC Image, there is a license for that image that you can download at no cost to test this system out.

If you are considering reinventing this wheel, I seriously recommend trying this solution out first.

MS CRM 4.0 Plug-ins vs. CRM 3.0 Callouts

2008-12-15T06:32:00.001-05:00

Plug-ins are a huge improvement over the callouts available in MS CRM 3.0. They are much more flexible, much easier to deploy, and have a many more triggers allowing a lot more access to the inner operation of your CRM system.

The following comparison shows some of the key differences:

Callout	Plug-in
Deployment
Requires Workflow service to be restarted to re-read the callout.config.xml which defines which assemblies and classes to call for each triggered event.	Has an easy to use Deployment Tool Plugin Deployment Tool Has an open API for automation of builds.
Requires assemblies be copied to each CRM server in your web server farm. Because those assemblies can be busy this can require: Draining each server in an NLB configuration. An IIS reset Stopping the Workflow service.	Allows deployment to the database in a single step for all CRM servers. Or deployment to the GAC on each server. Or deployment to a folder for debugging.
	Requires a strongly typed assembly.
Flexibility
Requires a different interface for each Message. A PreCreate has a different interface from a PostCreate, or a PreUpdate, or a PostUpdate.	Has the same interface for all messages.
	Supports many more messages Supported Messages for Plug-ins
	Has parent and child pipeline feature
	Has the ability to watch for endless loops.
Coding
Requires parsing Xml images to see the contents of the entity generating the message: preImageEntityXml, postImageEntityXml	Returns a Dynamic Entity or Moniker instead. var entity = (DynamicEntity)context.InputParameters.Properties[ParameterName.Target]; var myMoniker = (Moniker)context.InputParameters.Properties[ParameterName.Target];
Allows validity checking and stopping a change to the database in a preCallout errorMessage = "Validation Failed."; return PreCalloutReturnValue.Abort;	Allows validity checking and stopping an operation in a Pre message. throw new InvalidPluginExecutionException( "Validity Failed. {1}");
Allows modifying data before it is written to the database in a preCallout. Parse and Modify the entityXML	Allows modifying data before it is written to the database in a Pre message. Modify the Dynamic entity. String nameProperty = entity.Properties["name"] as String; nameProperty = "new name";

Resources

VS Plug-in template This template will create a basic Plug-in Project and is a good starting point.

The example it creates is for a Dynamic Entity Target. This is useful for Create and Update messages, but many other messages will return a Moniker which gives you the id of the calling entity.
The template includes code to call a customized crmservice which can be useful, although it is faster and a better practice to call your service from the context as shown below if you are comfortable with Dynamic Entities:

ICrmService service = context.CreateCrmService(true);

Plugin Deployment Tool This tool will allow you a simple way to deploy your plug-ins. and has an easy to use UI.

With plug-ins it is important to learn about Dynamic Entities.

If you purchase David Yak's CRM as a Rapid Development Platform, it comes with a number of helper classes for Dynamic Entities, and plug-ins as well as other useful tools that are interesting. His chapters on plug-ins and dynamic entities are useful, and the code he provides is worth downloading and referring to. He also has chapters specific to using his plug-in framework for debugging and other tasks which are not CRM development generic.

I recently ordered a copy of Programming Microsoft Dynamics CRM 4.0, and I'll try to remember to update this post after I have looked over its coverage of Plug-ins and dynamic entities.

Interactive Webcast: The Top 5 Ways to Save Money with CRM

2008-11-26T08:54:00.001-05:00

I've been invited back to be a guest speaker for an interactive Webcast on December 4th at 10:00 AM Pacific, 1:00 PM Eastern, 6:00PM GMT. This is through CBS interactive and Tech Republic.

http://webcasts.techrepublic.com.com/abstract.aspx?docid=390610&promo=100202

Queues in MS CRM

2008-11-20T08:11:00.001-05:00

There are a lot of misconceptions about queues. They only apply to cases and activities. While the terminology is the same, assigning a case or activity to a queue is not the same as assigning an entity to a CRM user or team. Programmatically what is being used is a RouteRequest rather than an AssignRequest.

To get a better idea how this works we'll look at database. There are two entities storing queue information, the Queue and the QueueItem. These are not customizable.

Queue – (table) contains all queues

There are two queues automatically created for each CRM user.
- Assigned
- In Progress
Any user defined queues that you create are also stored here.
- example: My New Public Queue

QueueItem – (link table) Contains an entry for each entity assigned to a queue.

An item can only belong to one Queue at a time,
The only entities that can below to a Queue are:
- Activities ( email, tasks, etc. )
- Cases

An activity or case retains its owner and is not modified in any way when it is assigned to a queue. It is just added to the QueueItem list. An entity can ONLY belong to one queue at a time.

Normal Lifecycle

When created a case or activity is added to the Assigned queue of the owner and it will stay there until it is completed/closed/canceled.

Sometimes a workflow will assign an entity to a user defined queue. (Below is an example that just puts all created Cases into a Support queue.) You might want logic with timers to move Cases around, or you might have different queues by subject, or related account territory. The important thing is that the queue is used as a natural part of the customer's business process.

When someone selects an entity in the queue and clicks Accept... that entity it is then moved into that person's "In Progress" queue.

Example code working with Queues

Creating a Queue

var newQueue = new queue
{
    name = "My New Public Queue",
    businessunitid = new Lookup { Value = BusinessUnitId, type = EntityName.businessunit.ToString() },
    primaryuserid = new Lookup { Value = UserId, type = EntityName.systemuser.ToString() },
    queuetypecode = new Picklist { name = "Public", Value = 1 }
};

service.Create(newQueue);

Assigning an incident to a Queue

 // Target the incident
var target = new TargetQueuedIncident 
{
   EntityId = incidentId
};

// Create a RouteRequest ( you would need to query for your Queue Id's )
var route = new RouteRequest
{
   Target = target,
   RouteType = RouteType.Queue,
   SourceQueueId = currentQueueId.Value 
   EndpointId = finalQueueId,
   };
            
// Execute the route
var routed = (RouteResponse)service.Execute(route);

Tracking Queue Assignment in a Plugin

One of the related improvements to MS CRM 4.0 is the inclusion of the Route Message for Plug-ins. For example, you can now trigger based on a Case being routed to a queue even though the case entity is not modified in any way.

Your code can inspect the SourceQueueId to see what queue it is coming from and the EndpointId to see the destination queue.

This link shows a complete list of the Plug-in Message Input Parameters. You can see that the Route Message has 3 input parameters, two which I mentioned (SourceQueueId and EndpointId) as well as RouteType which has three values ( Auto = 0 ( automatic route) , User = 1 (route to a user's private queue), Queue = 2 (route to a public queue) ) You could use the RouteType to filter out a chunk of queue routes that wish to ignore.

The fact that the dynamic entity of an incident contains no information about the queue it is assigned to means that you need to examine the context.InputParameters.Properties to find out which queue the case is coming from and which queue it will finally call home.

public void Execute(IPluginExecutionContext context)
   {
      DynamicEntity entity = null;

    if (context.InputParameters.Properties.Contains(ParameterName.Target) &&
       context.InputParameters.Properties[ParameterName.Target] is DynamicEntity)
    {
        entity = (DynamicEntity)context.InputParameters.Properties[ParameterName.Target];
        
        if (entity.Name != EntityName.incident.ToString()) { return; }
        if (context.MessageName != MessageName.Route.ToString()) { return; }
        
        Guid SourceQueueId = ((Moniker)context.InputParameters.Properties["SourceQueueId"]).Id;
        Guid EndpointId = ((Moniker)context.InputParameters.Properties["EndpointId"]).Id;
    }

A Couple Data import issues

2008-11-19T07:43:00.001-05:00

I thought these items might be of help to other people populating data in MS CRM systems. The first is documented, but for the second I found no information on web.

Issue 1: When importing email activities, like all other activities in the vast majority of instances you need to complete them so they show up in history and not in the current Activities of a user's Workplace or against the items to which they are regarded.

If you import an email message with a From email address that is not a CRM system user, you can create the activity without a problem, but will get a Soap Exception "The specified sender type is not supported." When you try to set the state of the email to "Received". The following hot fix will allow you to Complete those incoming emails and set them to "Received".

http://support.microsoft.com/kb/947860/en-us

Issue 2: While importing account information after a customer of mine added additional customertypecode picklist items I ran into a Soap Exception.

<code>0x8004431a</code>
<description>A validation error occurred. The value of 'customertypecode' on record of type 'account' is outside the valid range.</description>

The customertypecode picklist starts at 1 and progresses linearly with the default values out of the box, and you can always rename the existing items, but any new picklist items start with values of 200001 and progress linearly from there.

Workaround: Edit an existing account or add a dummy account and select a new pick list item with a higher ranged value and save that account record. Now the problem magically disappears.

Hypothesis: I'm thinking that the CRM webservices are using reflection like Excel does on a spreadsheet column but against the database and it initially ranges the pick list field as a short, but only ranges it up when a larger value exists.

If anyone has a better understanding of why this behavior occurs, I would love to hear about it.

Interactive Webcast: Using CRM to Drive Sales in a Slowing Economy

2008-11-12T08:28:00.001-05:00

I've been invited to be the guest speaker for an interactive Webcast on November 13th at 1:00 PM Pacific, 4:00 PM Eastern, 9:00PM GMT. This is through CBS interactive and Tech Republic.

http://webcasts.techrepublic.com.com/abstract.aspx?docid=390611

Annotation Import web service error

2008-11-07T09:20:00.001-05:00

During a recent import I was getting some exceptions while adding annotations to Accounts and Contacts. The exceptions being generated were not SoapExceptions, but HTTP 400 malformed http request errors.

This was a data driven problem and I assumed that it was an illegal character messing up the SOAP. The annotation.notetext attribute was the only one being set to a large chunk of unknown text. Debugging this showed some illegal characters in my source data. Initially I found an occasional "\0" which is easily removed, but there was another character that showed up as a box symbol.

So how do you filter that out?

First you need to know what you are looking at, so while debugging copy the offending character into the clipboard and paste it into a text file. In Visual Studio there is a binary editor.

File -> Open File
After selecting your file click notice the small pick list to the right of Open.
Select Open With...

Viewing the text file revealed that the offending character was a hex 12. I had copied three of them into NotePad. For the curious among you a hex 12 = DC2 or Device Control 2.

Armed with that information the following statement filtered out the offending characters and the import completed without error.

newAnnotation.notetext = note.Replace('\0', ' ').Replace('\u0012', ' ');

Below is a code example using this filter to generate contact annotations.

var newAnnotation = new annotation
       {
          objectid = CrmTypes.CreateLookup(EntityName.contact.ToString(), contactId),
          objecttypecode = CrmTypes.CreateEntityNameReference(EntityName.contact.ToString()),
          isdocument = CrmTypes.CreateCrmBoolean(false),
          ownerid = newContact.ownerid,
          subject = "GoldMine notes",
          notetext = note.Replace('\0', ' ').Replace('\u0012', ' ')
       };

try
{
    service.Create(newAnnotation);
}

This could have been solved a number of other ways like a regex that only allows valid characters for a SOAP request, but I haven't run into this issue enough to create one.

Creating an ActivityParty in MS CRM 4.0

2008-10-26T10:04:00.001-04:00

In an earlier Blog I covered creating activities, but did not cover the activityparty in depth. Each activity has a number of activityparty arrays containing lookups to the CRM systemuser, contact, lead, and account entities that are involved in that activity.

For many purposes the only attributes that need to be set in each ActivityParty are the participationtypemask and partyid. The name participationtypemask is a little misleading since it needs to be set to a picklist with a value from the ActivityPartyType rather than actually being a bitmask like the SecurityPrincipal AccessMask.

There are numerous ActivityPartyTypes used for the different ActivityParty arrays in each activity. A complete list of these types is located here MSDN ActivityPartyType Class. The partyid is just a lookup to the appropriate systemuser, contact, lead or account.

Typically when importing activities you will be matching against an email address and/or contact or lead name. I'd included some example code that will creates an activityparty array for use in creating an activity based on email addresses. A few examples of how I would call this are the following:

thisEmail.to   = CreateActivityParty(to_rfc882,   ActivityPartyType.ToRecipient);
thisEmail.from = CreateActivityParty(from_rfc882, ActivityPartyType.Sender);
thisEmail.cc   = CreateActivityParty(cc_rfc882,   ActivityPartyType.CcRecipient);
thisEmail.bcc  = CreateActivityParty(bcc_rfc882,  ActivityPartyType.BccRecipient);

This shows an email entity having a number of attributes assigned an appropriate activityparty array.

This code takes the emailAddresses string from a given email and creates a list of email addresses that will be part of the ActivityParty array. Then it looks for a match for each email address against systemusers, contacts, leads and finally accounts. Notice that an ActivityParty array can consist of any combination of these entities.

/// <summary>
/// Create that list of Parties associated with each email address in the email list
/// </summary>
/// <param name="emailAddresses"></param>
/// <param name="addressType"></param>
/// <returns></returns>
private activityparty[] CreateActivityParty(string emailAddresses, int addressType)
{
    var activityPartiesPerEmail = new List<activityparty>();

    List<string> addresses = CleanEmail(emailAddresses);  // Get a clean email list from the rfc822 address line.

    //Find All Activity parties 
    
    // Pecking order System Users, Contacts, Leads, Accounts

    foreach ( var emailAddress in addresses)
    {
        BusinessEntityCollection users = FindEntitiesByAttribute(emailAddress, EntityName.systemuser.ToString(), "internalemailaddress");

        if (users.BusinessEntities.Length > 0)
        {
            foreach (systemuser user in users.BusinessEntities)
            {
                activityPartiesPerEmail.Add( new activityparty
                    {
                        participationtypemask = CrmTypes.CreatePicklist(addressType),
                        partyid = CrmTypes.CreateLookup(EntityName.systemuser.ToString(), user.systemuserid.Value)
                    }
                  );
                break;
            }
        }
        else
        {
            BusinessEntityCollection contacts = FindEntitiesByAttribute(emailAddress, EntityName.contact.ToString(), "emailaddress1");

            if (contacts.BusinessEntities.Length > 0)
            {
                foreach (contact aContact in contacts.BusinessEntities)
                {
                    activityPartiesPerEmail.Add(new activityparty
                          {
                              participationtypemask = CrmTypes.CreatePicklist(addressType),
                              partyid = CrmTypes.CreateLookup(EntityName.contact.ToString(), aContact.contactid.Value)
                          }
                        );
                    break;
                }
            }
            else
            {
                BusinessEntityCollection leads = FindEntitiesByAttribute(emailAddress, EntityName.lead.ToString(), "emailaddress1");

                if (leads.BusinessEntities.Length > 0)
                {
                    foreach (lead aLead in leads.BusinessEntities)
                    {
                        activityPartiesPerEmail.Add(new activityparty
                            {
                                participationtypemask = CrmTypes.CreatePicklist(addressType),
                                partyid = CrmTypes.CreateLookup(EntityName.lead.ToString(), aLead.leadid.Value)
                            }
                          );
                        break;
                    }
                }
                else
                {
                    BusinessEntityCollection accounts = FindEntitiesByAttribute(emailAddress, EntityName.account.ToString(), "emailaddress1");

                    if (accounts.BusinessEntities.Length > 0)
                    {
                        foreach (account anAccount in accounts.BusinessEntities)
                        {
                            activityPartiesPerEmail.Add(new activityparty
                                {
                                    participationtypemask = CrmTypes.CreatePicklist(addressType),
                                    partyid = CrmTypes.CreateLookup(EntityName.account.ToString(), anAccount.accountid.Value)
                                }
                            );
                            break;
                        }
                    }
                }
            }
        }
    }
    
    var theseParties = new activityparty[activityPartiesPerEmail.Count];

    activityPartiesPerEmail.CopyTo(theseParties);
    
    return theseParties;
}

/// <summary>
/// Returns all entities of a specified type filterd on a specified attribute and value
/// </summary>
/// <param name="emailAddress">attribute filter value</param>
/// <param name="entity">entityName</param>
/// <param name="attributeName">attribute to filter on</param>
/// <returns></returns>
public BusinessEntityCollection FindEntitiesByAttribute(string emailAddress, string entity, string attributeName)
{
    var condition = new ConditionExpression
    {
        AttributeName = attributeName,
        Operator = ConditionOperator.Equal,
        Values = new[] { emailAddress }
    };


    var filter = new FilterExpression
    {
        FilterOperator = LogicalOperator.And,
        Conditions = new[] { condition }
    };


    var query = new QueryExpression
    {
        EntityName = entity,
        ColumnSet = new AllColumns(),
        Criteria = filter
    };

    try
    {
        return service.RetrieveMultiple(query);
    }

    catch (SoapException ex)
    {
        string errormsg = String.Format("Error for FindSystemUserByEmailAddress {0} error {1}", emailAddress, ex.Detail.InnerText);

        WriteErrorFile(errormsg);
        throw;
    }
}

If you have any questions please let me know.

Creating Attachments to emails and annotations

2008-10-17T07:39:00.001-04:00

MS CRM stores attachments directly in the database which allows security to be enforced on attachments. If you delete a entity, all of its annotations are removed with it. By way of comparison this offers a lot more control than just saving a pathname for an attached file like GoldMine does with its RFC822 format emails.

In MS CRM 4.0 the attachments are stored in a text field in the ActivityMimeAttachment table, and in an nvarchar(max) in the AnnotationBase table. You can use SQL "like" comparator in a where clause against an nvarchar but not for a text field. nvarchar(max) was introduced with SQL 2005.

Creating an activitymimeattachment ( Email attachment )

The following is a code snippet from a larger method that creates the email entity as well. This code is inside a try catch for the email creation.

Notice that a file can be converted into a format that can be saved into the activitymimeattachment.body attribute by using the File.ReadAllBytes() and the Convert.ToBase64String() methods.

// If you have an email entity ready to be created and list of pathnames
// the following code will generate the related activitymimeattachment entities 

Guid emailId = service.Create(newEmail);
 
 if (attachmentPathnames.Count > 0)
 {
     int attachmentCount = 1;

     foreach (var attachmentPathName in attachmentPathnames)
    {
     var emailAttachment = new activitymimeattachment
             {
                // Relate back to email activity 
                activityid = CrmTypes.CreateLookup(EntityName.email.ToString(), emailId),
                filename = attachmentPathName.Substring(attachmentPathName.LastIndexOf('\\') + 1), 
                subject = subject,
                attachmentnumber = CrmTypes.CreateCrmNumber(attachmentCount ++)
             };

     if (File.Exists(attachmentPathName))
     {         
         byte[] fileContents = File.ReadAllBytes(attachmentPathName);
         emailAttachment.body = Convert.ToBase64String(fileContents);
         emailAttachment.filesize = CrmTypes.CreateCrmNumber((int) new FileInfo(attachmentPathName).Length);
         emailAttachment.mimetype = GetMimeType(attachmentPathName); // GetMimeType() Covered Below
     }
     else
     {
         // Handle condition where file doesn't exist
         emailAttachmentbody = "Attachment File Not Found.";
     }

     try
     {
         service.Create(emailAttachment);
     }

     catch (SoapException ex)
     {
         string errormsg = String.Format("Write Error for Email Attachment {0} error {1}", attachmentPathName, ex.Detail.InnerText);
         WriteErrorFile(errormsg);
     }
    }
 }

Creating an annotation (Notes attachment)

The following code creates an annotation which can belong to any entity with a Notes tab. In this case it is a Letter activity. This is very similar to the above code for the activitymimeattachment. One key difference is that an annotation can also just be a Note, so it has an attribute just to specify if it is a note or an attachment.

Notice the isdocument attribute of the annotation. This needs to be set to true for an attachment. Also notice the overriddencreatedon attribute. The addition of this is one of the many improvements in MS CRM 4.0 and removed one of my pet peeves about MS CRM 3.0. When importing annotations in MS CRM 3.0 all of the annotations would be set to the import date which is useless for the end user. The ONLY way to change it was to go back with a SQL Update to change the createdon date. Now we have the overriddencreatedon attribute so that we don't have to "break the rules" and access the data tables directly.

Guid letterId = service.Create(newLetter);

var newAnnotation = new annotation
  {
      objectid = CrmTypes.CreateLookup(EntityName.letter.ToString(), letterId),
      objecttypecode = CrmTypes.CreateEntityNameReference(EntityName.letter.ToString()),
      isdocument = CrmTypes.CreateCrmBoolean(false),
      ownerid = newLetter.ownerid,
      subject = subject,
      overriddencreatedon = newLetter.actualend,
      notetext = "File from import."
  };

if (hasAttachment)
{
    if (File.Exists(attachmentPath))
    {
        newAnnotation.isdocument = CrmTypes.CreateCrmBoolean(true),
        newAnnotation.filename = attachmentPath.Substring(attachmentPath.LastIndexOf('\\') + 1);
        byte[] fileContents = File.ReadAllBytes(attachmentPath);
        newAnnotation.documentbody = System.Convert.ToBase64String(fileContents);
        newAnnotation.filesize = CrmTypes.CreateCrmNumber((int)new FileInfo(attachmentPath).Length);
        newAnnotation.mimetype = GetMimeType(attachmentPath);
    }
    else
    {
        // Handle missing attachment
        newAnnotation.subject += " - (attached document not found)";
    }

    try
    {
        service.Create(newAnnotation);
    }

    catch (SoapException ex)
    {
        string errormsg = String.Format("Write Error for Letter Attachment {0} error {1}", attachmentPath, ex.Detail.InnerText);
        WriteErrorFile(errormsg);
    }

}

The following method is a helper to look up a mimetype for a given file extension.

public string GetMimeType(string fileName)
{
    string mimeType;

    switch (System.IO.Path.GetExtension(fileName).ToLower())
    {
        case ".3dm": mimeType = "x-world/x-3dmf"; break;
        case ".3dmf": mimeType = "x-world/x-3dmf"; break;
        case ".a": mimeType = "application/octet-stream"; break;
        case ".aab": mimeType = "application/x-authorware-bin"; break;
        case ".aam": mimeType = "application/x-authorware-map"; break;
        case ".aas": mimeType = "application/x-authorware-seg"; break;
        case ".abc": mimeType = "text/vnd.abc"; break;
        case ".acgi": mimeType = "text/html"; break;
        case ".afl": mimeType = "video/animaflex"; break;
        case ".ai": mimeType = "application/postscript"; break;
        case ".aif": mimeType = "audio/aiff"; break;
        case ".aifc": mimeType = "audio/aiff"; break;
        case ".aiff": mimeType = "audio/aiff"; break;
        case ".aim": mimeType = "application/x-aim"; break;
        case ".aip": mimeType = "text/x-audiosoft-intra"; break;
        case ".ani": mimeType = "application/x-navi-animation"; break;
        case ".aos": mimeType = "application/x-nokia-9000-communicator-add-on-software"; break;
        case ".aps": mimeType = "application/mime"; break;
        case ".arc": mimeType = "application/octet-stream"; break;
        case ".arj": mimeType = "application/arj"; break;
        case ".art": mimeType = "image/x-jg"; break;
        case ".asf": mimeType = "video/x-ms-asf"; break;
        case ".asm": mimeType = "text/x-asm"; break;
        case ".asp": mimeType = "text/asp"; break;
        case ".asx": mimeType = "video/x-ms-asf"; break;
        case ".au": mimeType = "audio/basic"; break;
        case ".avi": mimeType = "video/avi"; break;
        case ".avs": mimeType = "video/avs-video"; break;
        case ".bcpio": mimeType = "application/x-bcpio"; break;
        case ".bin": mimeType = "application/octet-stream"; break;
        case ".bm": mimeType = "image/bmp"; break;
        case ".bmp": mimeType = "image/bmp"; break;
        case ".boo": mimeType = "application/book"; break;
        case ".book": mimeType = "application/book"; break;
        case ".boz": mimeType = "application/x-bzip2"; break;
        case ".bsh": mimeType = "application/x-bsh"; break;
        case ".bz": mimeType = "application/x-bzip"; break;
        case ".bz2": mimeType = "application/x-bzip2"; break;
        case ".c": mimeType = "text/plain"; break;
        case ".c++": mimeType = "text/plain"; break;
        case ".cat": mimeType = "application/vnd.ms-pki.seccat"; break;
        case ".cc": mimeType = "text/plain"; break;
        case ".ccad": mimeType = "application/clariscad"; break;
        case ".cco": mimeType = "application/x-cocoa"; break;
        case ".cdf": mimeType = "application/cdf"; break;
        case ".cer": mimeType = "application/pkix-cert"; break;
        case ".cha": mimeType = "application/x-chat"; break;
        case ".chat": mimeType = "application/x-chat"; break;
        case ".class": mimeType = "application/java"; break;
        case ".com": mimeType = "application/octet-stream"; break;
        case ".conf": mimeType = "text/plain"; break;
        case ".cpio": mimeType = "application/x-cpio"; break;
        case ".cpp": mimeType = "text/x-c"; break;
        case ".cpt": mimeType = "application/x-cpt"; break;
        case ".crl": mimeType = "application/pkcs-crl"; break;
        case ".crt": mimeType = "application/pkix-cert"; break;
        case ".csh": mimeType = "application/x-csh"; break;
        case ".css": mimeType = "text/css"; break;
        case ".cxx": mimeType = "text/plain"; break;
        case ".dcr": mimeType = "application/x-director"; break;
        case ".deepv": mimeType = "application/x-deepv"; break;
        case ".def": mimeType = "text/plain"; break;
        case ".der": mimeType = "application/x-x509-ca-cert"; break;
        case ".dif": mimeType = "video/x-dv"; break;
        case ".dir": mimeType = "application/x-director"; break;
        case ".dl": mimeType = "video/dl"; break;
        case ".doc": mimeType = "application/msword"; break;
        case ".dot": mimeType = "application/msword"; break;
        case ".dp": mimeType = "application/commonground"; break;
        case ".drw": mimeType = "application/drafting"; break;
        case ".dump": mimeType = "application/octet-stream"; break;
        case ".dv": mimeType = "video/x-dv"; break;
        case ".dvi": mimeType = "application/x-dvi"; break;
        case ".dwf": mimeType = "model/vnd.dwf"; break;
        case ".dwg": mimeType = "image/vnd.dwg"; break;
        case ".dxf": mimeType = "image/vnd.dwg"; break;
        case ".dxr": mimeType = "application/x-director"; break;
        case ".el": mimeType = "text/x-script.elisp"; break;
        case ".elc": mimeType = "application/x-elc"; break;
        case ".env": mimeType = "application/x-envoy"; break;
        case ".eps": mimeType = "application/postscript"; break;
        case ".es": mimeType = "application/x-esrehber"; break;
        case ".etx": mimeType = "text/x-setext"; break;
        case ".evy": mimeType = "application/envoy"; break;
        case ".exe": mimeType = "application/octet-stream"; break;
        case ".f": mimeType = "text/plain"; break;
        case ".f77": mimeType = "text/x-fortran"; break;
        case ".f90": mimeType = "text/plain"; break;
        case ".fdf": mimeType = "application/vnd.fdf"; break;
        case ".fif": mimeType = "image/fif"; break;
        case ".fli": mimeType = "video/fli"; break;
        case ".flo": mimeType = "image/florian"; break;
        case ".flx": mimeType = "text/vnd.fmi.flexstor"; break;
        case ".fmf": mimeType = "video/x-atomic3d-feature"; break;
        case ".for": mimeType = "text/x-fortran"; break;
        case ".fpx": mimeType = "image/vnd.fpx"; break;
        case ".frl": mimeType = "application/freeloader"; break;
        case ".funk": mimeType = "audio/make"; break;
        case ".g": mimeType = "text/plain"; break;
        case ".g3": mimeType = "image/g3fax"; break;
        case ".gif": mimeType = "image/gif"; break;
        case ".gl": mimeType = "video/gl"; break;
        case ".gsd": mimeType = "audio/x-gsm"; break;
        case ".gsm": mimeType = "audio/x-gsm"; break;
        case ".gsp": mimeType = "application/x-gsp"; break;
        case ".gss": mimeType = "application/x-gss"; break;
        case ".gtar": mimeType = "application/x-gtar"; break;
        case ".gz": mimeType = "application/x-gzip"; break;
        case ".gzip": mimeType = "application/x-gzip"; break;
        case ".h": mimeType = "text/plain"; break;
        case ".hdf": mimeType = "application/x-hdf"; break;
        case ".help": mimeType = "application/x-helpfile"; break;
        case ".hgl": mimeType = "application/vnd.hp-hpgl"; break;
        case ".hh": mimeType = "text/plain"; break;
        case ".hlb": mimeType = "text/x-script"; break;
        case ".hlp": mimeType = "application/hlp"; break;
        case ".hpg": mimeType = "application/vnd.hp-hpgl"; break;
        case ".hpgl": mimeType = "application/vnd.hp-hpgl"; break;
        case ".hqx": mimeType = "application/binhex"; break;
        case ".hta": mimeType = "application/hta"; break;
        case ".htc": mimeType = "text/x-component"; break;
        case ".htm": mimeType = "text/html"; break;
        case ".html": mimeType = "text/html"; break;
        case ".htmls": mimeType = "text/html"; break;
        case ".htt": mimeType = "text/webviewhtml"; break;
        case ".htx": mimeType = "text/html"; break;
        case ".ice": mimeType = "x-conference/x-cooltalk"; break;
        case ".ico": mimeType = "image/x-icon"; break;
        case ".idc": mimeType = "text/plain"; break;
        case ".ief": mimeType = "image/ief"; break;
        case ".iefs": mimeType = "image/ief"; break;
        case ".iges": mimeType = "application/iges"; break;
        case ".igs": mimeType = "application/iges"; break;
        case ".ima": mimeType = "application/x-ima"; break;
        case ".imap": mimeType = "application/x-httpd-imap"; break;
        case ".inf": mimeType = "application/inf"; break;
        case ".ins": mimeType = "application/x-internett-signup"; break;
        case ".ip": mimeType = "application/x-ip2"; break;
        case ".isu": mimeType = "video/x-isvideo"; break;
        case ".it": mimeType = "audio/it"; break;
        case ".iv": mimeType = "application/x-inventor"; break;
        case ".ivr": mimeType = "i-world/i-vrml"; break;
        case ".ivy": mimeType = "application/x-livescreen"; break;
        case ".jam": mimeType = "audio/x-jam"; break;
        case ".jav": mimeType = "text/plain"; break;
        case ".java": mimeType = "text/plain"; break;
        case ".jcm": mimeType = "application/x-java-commerce"; break;
        case ".jfif": mimeType = "image/jpeg"; break;
        case ".jfif-tbnl": mimeType = "image/jpeg"; break;
        case ".jpe": mimeType = "image/jpeg"; break;
        case ".jpeg": mimeType = "image/jpeg"; break;
        case ".jpg": mimeType = "image/jpeg"; break;
        case ".jps": mimeType = "image/x-jps"; break;
        case ".js": mimeType = "application/x-javascript"; break;
        case ".jut": mimeType = "image/jutvision"; break;
        case ".kar": mimeType = "audio/midi"; break;
        case ".ksh": mimeType = "application/x-ksh"; break;
        case ".la": mimeType = "audio/nspaudio"; break;
        case ".lam": mimeType = "audio/x-liveaudio"; break;
        case ".latex": mimeType = "application/x-latex"; break;
        case ".lha": mimeType = "application/octet-stream"; break;
        case ".lhx": mimeType = "application/octet-stream"; break;
        case ".list": mimeType = "text/plain"; break;
        case ".lma": mimeType = "audio/nspaudio"; break;
        case ".log": mimeType = "text/plain"; break;
        case ".lsp": mimeType = "application/x-lisp"; break;
        case ".lst": mimeType = "text/plain"; break;
        case ".lsx": mimeType = "text/x-la-asf"; break;
        case ".ltx": mimeType = "application/x-latex"; break;
        case ".lzh": mimeType = "application/octet-stream"; break;
        case ".lzx": mimeType = "application/octet-stream"; break;
        case ".m": mimeType = "text/plain"; break;
        case ".m1v": mimeType = "video/mpeg"; break;
        case ".m2a": mimeType = "audio/mpeg"; break;
        case ".m2v": mimeType = "video/mpeg"; break;
        case ".m3u": mimeType = "audio/x-mpequrl"; break;
        case ".man": mimeType = "application/x-troff-man"; break;
        case ".map": mimeType = "application/x-navimap"; break;
        case ".mar": mimeType = "text/plain"; break;
        case ".mbd": mimeType = "application/mbedlet"; break;
        case ".mc$": mimeType = "application/x-magic-cap-package-1.0"; break;
        case ".mcd": mimeType = "application/mcad"; break;
        case ".mcf": mimeType = "text/mcf"; break;
        case ".mcp": mimeType = "application/netmc"; break;
        case ".me": mimeType = "application/x-troff-me"; break;
        case ".mht": mimeType = "message/rfc822"; break;
        case ".mhtml": mimeType = "message/rfc822"; break;
        case ".mid": mimeType = "audio/midi"; break;
        case ".midi": mimeType = "audio/midi"; break;
        case ".mif": mimeType = "application/x-mif"; break;
        case ".mime": mimeType = "message/rfc822"; break;
        case ".mjf": mimeType = "audio/x-vnd.audioexplosion.mjuicemediafile"; break;
        case ".mjpg": mimeType = "video/x-motion-jpeg"; break;
        case ".mm": mimeType = "application/base64"; break;
        case ".mme": mimeType = "application/base64"; break;
        case ".mod": mimeType = "audio/mod"; break;
        case ".moov": mimeType = "video/quicktime"; break;
        case ".mov": mimeType = "video/quicktime"; break;
        case ".movie": mimeType = "video/x-sgi-movie"; break;
        case ".mp2": mimeType = "audio/mpeg"; break;
        case ".mp3": mimeType = "audio/mpeg"; break;
        case ".mpa": mimeType = "audio/mpeg"; break;
        case ".mpc": mimeType = "application/x-project"; break;
        case ".mpe": mimeType = "video/mpeg"; break;
        case ".mpeg": mimeType = "video/mpeg"; break;
        case ".mpg": mimeType = "video/mpeg"; break;
        case ".mpga": mimeType = "audio/mpeg"; break;
        case ".mpp": mimeType = "application/vnd.ms-project"; break;
        case ".mpt": mimeType = "application/vnd.ms-project"; break;
        case ".mpv": mimeType = "application/vnd.ms-project"; break;
        case ".mpx": mimeType = "application/vnd.ms-project"; break;
        case ".mrc": mimeType = "application/marc"; break;
        case ".ms": mimeType = "application/x-troff-ms"; break;
        case ".mv": mimeType = "video/x-sgi-movie"; break;
        case ".my": mimeType = "audio/make"; break;
        case ".mzz": mimeType = "application/x-vnd.audioexplosion.mzz"; break;
        case ".nap": mimeType = "image/naplps"; break;
        case ".naplps": mimeType = "image/naplps"; break;
        case ".nc": mimeType = "application/x-netcdf"; break;
        case ".ncm": mimeType = "application/vnd.nokia.configuration-message"; break;
        case ".nif": mimeType = "image/x-niff"; break;
        case ".niff": mimeType = "image/x-niff"; break;
        case ".nix": mimeType = "application/x-mix-transfer"; break;
        case ".nsc": mimeType = "application/x-conference"; break;
        case ".nvd": mimeType = "application/x-navidoc"; break;
        case ".o": mimeType = "application/octet-stream"; break;
        case ".oda": mimeType = "application/oda"; break;
        case ".omc": mimeType = "application/x-omc"; break;
        case ".omcd": mimeType = "application/x-omcdatamaker"; break;
        case ".omcr": mimeType = "application/x-omcregerator"; break;
        case ".p": mimeType = "text/x-pascal"; break;
        case ".p10": mimeType = "application/pkcs10"; break;
        case ".p12": mimeType = "application/pkcs-12"; break;
        case ".p7a": mimeType = "application/x-pkcs7-signature"; break;
        case ".p7c": mimeType = "application/pkcs7-mime"; break;
        case ".p7m": mimeType = "application/pkcs7-mime"; break;
        case ".p7r": mimeType = "application/x-pkcs7-certreqresp"; break;
        case ".p7s": mimeType = "application/pkcs7-signature"; break;
        case ".part": mimeType = "application/pro_eng"; break;
        case ".pas": mimeType = "text/pascal"; break;
        case ".pbm": mimeType = "image/x-portable-bitmap"; break;
        case ".pcl": mimeType = "application/vnd.hp-pcl"; break;
        case ".pct": mimeType = "image/x-pict"; break;
        case ".pcx": mimeType = "image/x-pcx"; break;
        case ".pdb": mimeType = "chemical/x-pdb"; break;
        case ".pdf": mimeType = "application/pdf"; break;
        case ".pfunk": mimeType = "audio/make"; break;
        case ".pgm": mimeType = "image/x-portable-greymap"; break;
        case ".pic": mimeType = "image/pict"; break;
        case ".pict": mimeType = "image/pict"; break;
        case ".pkg": mimeType = "application/x-newton-compatible-pkg"; break;
        case ".pko": mimeType = "application/vnd.ms-pki.pko"; break;
        case ".pl": mimeType = "text/plain"; break;
        case ".plx": mimeType = "application/x-pixclscript"; break;
        case ".pm": mimeType = "image/x-xpixmap"; break;
        case ".pm4": mimeType = "application/x-pagemaker"; break;
        case ".pm5": mimeType = "application/x-pagemaker"; break;
        case ".png": mimeType = "image/png"; break;
        case ".pnm": mimeType = "application/x-portable-anymap"; break;
        case ".pot": mimeType = "application/vnd.ms-powerpoint"; break;
        case ".pov": mimeType = "model/x-pov"; break;
        case ".ppa": mimeType = "application/vnd.ms-powerpoint"; break;
        case ".ppm": mimeType = "image/x-portable-pixmap"; break;
        case ".pps": mimeType = "application/vnd.ms-powerpoint"; break;
        case ".ppt": mimeType = "application/vnd.ms-powerpoint"; break;
        case ".ppz": mimeType = "application/vnd.ms-powerpoint"; break;
        case ".pre": mimeType = "application/x-freelance"; break;
        case ".prt": mimeType = "application/pro_eng"; break;
        case ".ps": mimeType = "application/postscript"; break;
        case ".psd": mimeType = "application/octet-stream"; break;
        case ".pvu": mimeType = "paleovu/x-pv"; break;
        case ".pwz": mimeType = "application/vnd.ms-powerpoint"; break;
        case ".py": mimeType = "text/x-script.phyton"; break;
        case ".pyc": mimeType = "applicaiton/x-bytecode.python"; break;
        case ".qcp": mimeType = "audio/vnd.qcelp"; break;
        case ".qd3": mimeType = "x-world/x-3dmf"; break;
        case ".qd3d": mimeType = "x-world/x-3dmf"; break;
        case ".qif": mimeType = "image/x-quicktime"; break;
        case ".qt": mimeType = "video/quicktime"; break;
        case ".qtc": mimeType = "video/x-qtc"; break;
        case ".qti": mimeType = "image/x-quicktime"; break;
        case ".qtif": mimeType = "image/x-quicktime"; break;
        case ".ra": mimeType = "audio/x-pn-realaudio"; break;
        case ".ram": mimeType = "audio/x-pn-realaudio"; break;
        case ".ras": mimeType = "application/x-cmu-raster"; break;
        case ".rast": mimeType = "image/cmu-raster"; break;
        case ".rexx": mimeType = "text/x-script.rexx"; break;
        case ".rf": mimeType = "image/vnd.rn-realflash"; break;
        case ".rgb": mimeType = "image/x-rgb"; break;
        case ".rm": mimeType = "application/vnd.rn-realmedia"; break;
        case ".rmi": mimeType = "audio/mid"; break;
        case ".rmm": mimeType = "audio/x-pn-realaudio"; break;
        case ".rmp": mimeType = "audio/x-pn-realaudio"; break;
        case ".rng": mimeType = "application/ringing-tones"; break;
        case ".rnx": mimeType = "application/vnd.rn-realplayer"; break;
        case ".roff": mimeType = "application/x-troff"; break;
        case ".rp": mimeType = "image/vnd.rn-realpix"; break;
        case ".rpm": mimeType = "audio/x-pn-realaudio-plugin"; break;
        case ".rt": mimeType = "text/richtext"; break;
        case ".rtf": mimeType = "text/richtext"; break;
        case ".rtx": mimeType = "text/richtext"; break;
        case ".rv": mimeType = "video/vnd.rn-realvideo"; break;
        case ".s": mimeType = "text/x-asm"; break;
        case ".s3m": mimeType = "audio/s3m"; break;
        case ".saveme": mimeType = "application/octet-stream"; break;
        case ".sbk": mimeType = "application/x-tbook"; break;
        case ".scm": mimeType = "application/x-lotusscreencam"; break;
        case ".sdml": mimeType = "text/plain"; break;
        case ".sdp": mimeType = "application/sdp"; break;
        case ".sdr": mimeType = "application/sounder"; break;
        case ".sea": mimeType = "application/sea"; break;
        case ".set": mimeType = "application/set"; break;
        case ".sgm": mimeType = "text/sgml"; break;
        case ".sgml": mimeType = "text/sgml"; break;
        case ".sh": mimeType = "application/x-sh"; break;
        case ".shar": mimeType = "application/x-shar"; break;
        case ".shtml": mimeType = "text/html"; break;
        case ".sid": mimeType = "audio/x-psid"; break;
        case ".sit": mimeType = "application/x-sit"; break;
        case ".skd": mimeType = "application/x-koan"; break;
        case ".skm": mimeType = "application/x-koan"; break;
        case ".skp": mimeType = "application/x-koan"; break;
        case ".skt": mimeType = "application/x-koan"; break;
        case ".sl": mimeType = "application/x-seelogo"; break;
        case ".smi": mimeType = "application/smil"; break;
        case ".smil": mimeType = "application/smil"; break;
        case ".snd": mimeType = "audio/basic"; break;
        case ".sol": mimeType = "application/solids"; break;
        case ".spc": mimeType = "text/x-speech"; break;
        case ".spl": mimeType = "application/futuresplash"; break;
        case ".spr": mimeType = "application/x-sprite"; break;
        case ".sprite": mimeType = "application/x-sprite"; break;
        case ".src": mimeType = "application/x-wais-source"; break;
        case ".ssi": mimeType = "text/x-server-parsed-html"; break;
        case ".ssm": mimeType = "application/streamingmedia"; break;
        case ".sst": mimeType = "application/vnd.ms-pki.certstore"; break;
        case ".step": mimeType = "application/step"; break;
        case ".stl": mimeType = "application/sla"; break;
        case ".stp": mimeType = "application/step"; break;
        case ".sv4cpio": mimeType = "application/x-sv4cpio"; break;
        case ".sv4crc": mimeType = "application/x-sv4crc"; break;
        case ".svf": mimeType = "image/vnd.dwg"; break;
        case ".svr": mimeType = "application/x-world"; break;
        case ".swf": mimeType = "application/x-shockwave-flash"; break;
        case ".t": mimeType = "application/x-troff"; break;
        case ".talk": mimeType = "text/x-speech"; break;
        case ".tar": mimeType = "application/x-tar"; break;
        case ".tbk": mimeType = "application/toolbook"; break;
        case ".tcl": mimeType = "application/x-tcl"; break;
        case ".tcsh": mimeType = "text/x-script.tcsh"; break;
        case ".tex": mimeType = "application/x-tex"; break;
        case ".texi": mimeType = "application/x-texinfo"; break;
        case ".texinfo": mimeType = "application/x-texinfo"; break;
        case ".text": mimeType = "text/plain"; break;
        case ".tgz": mimeType = "application/x-compressed"; break;
        case ".tif": mimeType = "image/tiff"; break;
        case ".tiff": mimeType = "image/tiff"; break;
        case ".tr": mimeType = "application/x-troff"; break;
        case ".tsi": mimeType = "audio/tsp-audio"; break;
        case ".tsp": mimeType = "application/dsptype"; break;
        case ".tsv": mimeType = "text/tab-separated-values"; break;
        case ".turbot": mimeType = "image/florian"; break;
        case ".txt": mimeType = "text/plain"; break;
        case ".uil": mimeType = "text/x-uil"; break;
        case ".uni": mimeType = "text/uri-list"; break;
        case ".unis": mimeType = "text/uri-list"; break;
        case ".unv": mimeType = "application/i-deas"; break;
        case ".uri": mimeType = "text/uri-list"; break;
        case ".uris": mimeType = "text/uri-list"; break;
        case ".ustar": mimeType = "application/x-ustar"; break;
        case ".uu": mimeType = "application/octet-stream"; break;
        case ".uue": mimeType = "text/x-uuencode"; break;
        case ".vcd": mimeType = "application/x-cdlink"; break;
        case ".vcs": mimeType = "text/x-vcalendar"; break;
        case ".vda": mimeType = "application/vda"; break;
        case ".vdo": mimeType = "video/vdo"; break;
        case ".vew": mimeType = "application/groupwise"; break;
        case ".viv": mimeType = "video/vivo"; break;
        case ".vivo": mimeType = "video/vivo"; break;
        case ".vmd": mimeType = "application/vocaltec-media-desc"; break;
        case ".vmf": mimeType = "application/vocaltec-media-file"; break;
        case ".voc": mimeType = "audio/voc"; break;
        case ".vos": mimeType = "video/vosaic"; break;
        case ".vox": mimeType = "audio/voxware"; break;
        case ".vqe": mimeType = "audio/x-twinvq-plugin"; break;
        case ".vqf": mimeType = "audio/x-twinvq"; break;
        case ".vql": mimeType = "audio/x-twinvq-plugin"; break;
        case ".vrml": mimeType = "application/x-vrml"; break;
        case ".vrt": mimeType = "x-world/x-vrt"; break;
        case ".vsd": mimeType = "application/x-visio"; break;
        case ".vst": mimeType = "application/x-visio"; break;
        case ".vsw": mimeType = "application/x-visio"; break;
        case ".w60": mimeType = "application/wordperfect6.0"; break;
        case ".w61": mimeType = "application/wordperfect6.1"; break;
        case ".w6w": mimeType = "application/msword"; break;
        case ".wav": mimeType = "audio/wav"; break;
        case ".wb1": mimeType = "application/x-qpro"; break;
        case ".wbmp": mimeType = "image/vnd.wap.wbmp"; break;
        case ".web": mimeType = "application/vnd.xara"; break;
        case ".wiz": mimeType = "application/msword"; break;
        case ".wk1": mimeType = "application/x-123"; break;
        case ".wmf": mimeType = "windows/metafile"; break;
        case ".wml": mimeType = "text/vnd.wap.wml"; break;
        case ".wmlc": mimeType = "application/vnd.wap.wmlc"; break;
        case ".wmls": mimeType = "text/vnd.wap.wmlscript"; break;
        case ".wmlsc": mimeType = "application/vnd.wap.wmlscriptc"; break;
        case ".word": mimeType = "application/msword"; break;
        case ".wp": mimeType = "application/wordperfect"; break;
        case ".wp5": mimeType = "application/wordperfect"; break;
        case ".wp6": mimeType = "application/wordperfect"; break;
        case ".wpd": mimeType = "application/wordperfect"; break;
        case ".wq1": mimeType = "application/x-lotus"; break;
        case ".wri": mimeType = "application/mswrite"; break;
        case ".wrl": mimeType = "application/x-world"; break;
        case ".wrz": mimeType = "x-world/x-vrml"; break;
        case ".wsc": mimeType = "text/scriplet"; break;
        case ".wsrc": mimeType = "application/x-wais-source"; break;
        case ".wtk": mimeType = "application/x-wintalk"; break;
        case ".xbm": mimeType = "image/x-xbitmap"; break;
        case ".xdr": mimeType = "video/x-amt-demorun"; break;
        case ".xgz": mimeType = "xgl/drawing"; break;
        case ".xif": mimeType = "image/vnd.xiff"; break;
        case ".xl": mimeType = "application/excel"; break;
        case ".xla": mimeType = "application/vnd.ms-excel"; break;
        case ".xlb": mimeType = "application/vnd.ms-excel"; break;
        case ".xlc": mimeType = "application/vnd.ms-excel"; break;
        case ".xld": mimeType = "application/vnd.ms-excel"; break;
        case ".xlk": mimeType = "application/vnd.ms-excel"; break;
        case ".xll": mimeType = "application/vnd.ms-excel"; break;
        case ".xlm": mimeType = "application/vnd.ms-excel"; break;
        case ".xls": mimeType = "application/vnd.ms-excel"; break;
        case ".xlt": mimeType = "application/vnd.ms-excel"; break;
        case ".xlv": mimeType = "application/vnd.ms-excel"; break;
        case ".xlw": mimeType = "application/vnd.ms-excel"; break;
        case ".xm": mimeType = "audio/xm"; break;
        case ".xml": mimeType = "application/xml"; break;
        case ".xmz": mimeType = "xgl/movie"; break;
        case ".xpix": mimeType = "application/x-vnd.ls-xpix"; break;
        case ".xpm": mimeType = "image/xpm"; break;
        case ".x-png": mimeType = "image/png"; break;
        case ".xsr": mimeType = "video/x-amt-showrun"; break;
        case ".xwd": mimeType = "image/x-xwd"; break;
        case ".xyz": mimeType = "chemical/x-pdb"; break;
        case ".z": mimeType = "application/x-compressed"; break;
        case ".zip": mimeType = "application/zip"; break;
        case ".zoo": mimeType = "application/octet-stream"; break;
        case ".zsh": mimeType = "text/x-script.zsh"; break;
        default: mimeType = "application/octet-stream"; break;
    }
    return mimeType;
}

MS CRM 4.0 Attachment Size Limitation

MS CRM stores attachments directly in the database, and there is a 5Mb attachment limit by default with CRM 4.0. This limit is set for good reason, and if you want to increase it, you may want to see if it starts to impact your system performance.

This can be overwritten by doing the following:

Changing the maxRequestLength value in the main CRM web.config file. By default it is 8Mb which doesn't impact the System Setting below. However if you increase the Maximum File size above the maxRequestLength you will have problems.

<system.web>
<httpRuntime executionTimeout="300" maxRequestLength="8192"/>
</system.web>

There are many examples on the web that show something like the following which pretty well removes any size constraints from the web.config.

<httpRuntime executionTimeout="9999" maxRequestLength="99999"/>
Save the web.config and restart IIS.
For MS CRM 4.0 that just leaves adjusting the Maximum file size in System Settings with default of 5,120 Kb shown below to something higher but less than the maxRequestLength.

Alternate 3. In MS CRM 3.0 there is a registry setting that needs to be set instead. In HKEY_Local_Machine\Software\Microsoft\MSCRM
the maxuploadfilesize value can be changed from it's 5Mb default.

CRM 4.0 Creating Activities

2008-10-12T11:02:00.001-04:00

When importing activities or creating them for a process, there are three important Steps.

Create the Activity relating it to all appropriate entities.
(Optional) Attach a file using an Annotation or ActivityMimeAttachment
Set the State of the Activity

MS CRM has numerous Activities. They are all part of an ActivityPointer Entity, but we won't work with that directly. We will directly create task, email, letter, appointment, and phonecall entities. I'll cover Campaign and Service Activities another day.

Activities need to be related with a number of entities before they are useful.

Activities need

An owner, a systemuser who is responsible for carrying an activity out.
A regardingobject, the entity the activity is related to, like a Contact, Opportunity or Account.
Numerous activityparty arrays for holding the different types of related entities that this activity affects. For example an email could cc: a systemuser and a contact, and there is a cc activityparty array for an email.
Any file attachments in the form of an annotation or activitymimeattachment
Start and End dates Scheduled and Actual.
A state/status combination
1. Active will show up in the owners WorkPlace Activities and under the regardingobject entity and possible rollup to an entity above that.
2. Inactive - will show up in history under the regardingobject and possible rollup to an entity above that.

Setting up each activity is very similar. Below is some example code that creates a phonecall, and completes that activity.

Notice the following in the code sample:

The activityparty arrays that allow any number of systemuser, contact, account and lead entities to be related to an activity.
The SetStatePhoneCallRequest to set the state of the phonecall to completed. The PhoneCallStatus of 2 for outgoing. You can refer to the following link for this and find other state enumerations required to set the state and status of all entities. Link to MSDN PhoneCallState Enumeration
I use the CRM SDK CrmTypes and other Enumeration helpers. They come in handy so why not?

var newphoneCall = new phonecall
  {
      ownerid = CrmTypes.CreateOwner(EntityName.systemuser.ToString(), activityOwnerId),
      from = new[]
          {
              new activityparty
                  {
                      participationtypemask = CrmTypes.CreatePicklist(ActivityPartyType.Sender),
                      partyid = CrmTypes.CreateLookup(EntityName.systemuser.ToString(), activityOwnerId)
                  }
          },
      subject = subject,
      description = description,
      regardingobjectid = (matchedContact) ? CrmTypes.CreateLookup(EntityName.contact.ToString(), relatedContactId) : null,
      to =  (!matchedContact)? null : new []
         {
            new activityparty
              {
                  participationtypemask = CrmTypes.CreatePicklist(ActivityPartyType.ToRecipient),
                  partyid = CrmTypes.CreateLookup(EntityName.contact.ToString(), relatedContactId)
              }
         },
      scheduledstart = CrmTypes.CreateCrmDateTime(Convert.ToDateTime(scheduledStart).ToShortDateString()),
      actualstart = CrmTypes.CreateCrmDateTime(Convert.ToDateTime(scheduledStart).ToShortDateString()),
      scheduledend = CrmTypes.CreateCrmDateTime(Convert.ToDateTime(scheduledEnd).ToShortDateString()),
      actualend = (isComplete) ? CrmTypes.CreateCrmDateTime(Convert.ToDateTime(scheduledEnd).ToShortDateString()) : null,
  };

try
  {
      Guid phonecallId = service.Create(newphoneCall);

      if (isComplete)
      {
          var request = new SetStatePhoneCallRequest
              {
                  EntityId = phonecallId,
                   PhoneCallState = PhoneCallState.Completed,
                   PhoneCallStatus = 2
              };

          try
          {
              service.Execute(request);
          }

          catch (SoapException ex)
          {
              string errormsg = String.Format("Update Error Setting PhoneCall State to Complete error {0}", ex.Detail.InnerText);
              WriteErrorFile(errormsg);
          }
      }

  }
catch (SoapException ex)
   {
       string errormsg = String.Format("Write Error for PhoneCall {0} error {1}", row[(int) tblCal.ACTVCODE], ex.Detail.InnerText);
       WriteErrorFile(errormsg);
   }

Next: My next post will cover importing files into CRM in the form of annotations and activitymimeattachments as well as mimeTypes, and CRM file size limitations and their configuration.