BugsOli's xRM blog

CRM 2011: Bad ‘setFormMode’ error!

Olivier — Fri, 19 Apr 2013 12:24:17 +0000

The other day, I was puzzled by a weird problem coming from a “Go to URL” action in a CRM sub-report.

The link was constructed correctly by using the following line of code:
Parameters!CRM_URL.Value & “?ID={“& Fields!new_bookingid.Value.ToString() &”}&LogicalName=new_booking”
which was rendered as:

https://crm.site.com/main.aspx?etn=new_booking&extraqs=etc%3d10048&id%3d4a528068-a2a1-e211-bc2c-d067e5e91163&id=4a528068-a2a1-e211-bc2c-d067e5e91163&pagetype=entityrecord

Notice how the ID has been replicated twice? Now the form was opening correctly but no Javascript was called after I updated the fields, which is why I fired up the IE developer tools and debugged the form scripts to discover an horrible Javascript error: Object doesn’t support property or method ‘setFormMode’

I then remembered that my client CRM server was on Update Rollup 7, so after having read the following forum post http://social.microsoft.com/Forums/en-US/crmdevelopment/thread/0c0aa09e-0ea6-4150-8056-a2b7b91f3256, I knew the only solution was to update the server!

Hope this helps someone.

BI: TARGIT Certified Specialist

BugsOli — Thu, 29 Mar 2012 06:48:12 +0000

Congratulations to my colleague Mathieu and I as we have successfully passed the TCS exam and are now proud to announce that we can deliver TARGIT trainings in French to customers in Belgium (French part) and Luxemburg!

CRM 2011: MB2-866 certification

BugsOli — Wed, 07 Mar 2012 13:20:00 +0000

Passed it today, and got the maximum score…1000/1000

CRM 2011: Error 404 while using internal claims authentication

BugsOli — Thu, 01 Mar 2012 09:16:15 +0000

This error has driven me crazy for a while: while using Microsoft CRM 2011 in IFD-mode, the external authentication would work correctly but not the internal access!

DNS were working correctly, the TMG server was configured correctly, the SSL certificate was correctly bound to the internal & external (we are using a wildcard SSL certificate) and ADFS was set up per the Microsoft installation document.

Now, to resolve the internal access issue, I had to remove the “:443” from the Deployment Manager Web addresses:

And now everything is working properly

CRM 2011: ADFS error 317

BugsOli — Fri, 06 Jan 2012 10:46:52 +0000

While deploying a new CRM 2011 environment at a client site, I got errors with my ADFS setup:

We used a wildcard certificate for all servers (on the same domain), purchased from RapidSSL
ADFS is on a separate server
CRM 2011 is on its own server
DNS internal entries were made and could resolve correctly to both servers

The problem occurred right after enabling claims in CRM 2011 Deployment Manager: the internal CRM address specified in the deployment manager could not be resolved and a couple of 317 & 364 errors were logged on the ADFS server.

I tried creating SPNs for both servers, remove and import the certificates again on both server, recreate the relying party for CRM, etc. but with no correct results.

Since the SSL certificates were created with lowercase characters for the domain, I changed the CRM web addresses to lowercase as well, which made the ADFS authentication form appear!

But I could still not get passed the 317 error after logging in with valid credentials…

Then I found this post were a PowerShell command was shown:

Add-PSSnapin Microsoft.Adfs.PowerShell

Set-ADFSRelyingPartyTrust -TargetName RPNameInADFS -EncryptionCertificateRevocationCheck None

Reset IIS on the ADFS server and voilà, it worked for me!

CRM 2011: Q4 Service Update

BugsOli — Wed, 02 Nov 2011 10:37:17 +0000

OK, now that you have installed Update Rollup 5 for Microsoft CRM 2011, you can import the Activity Feeds solution provided by Microsoft and available here.

This new solution will provide new functionalities that are related to “social networking” (a description of the new functionalities can be found here and here).

Once the new solution is installed under your organization (be sure to check the ‘Post Import Actions’ to activate all the processes and plugins), you need to configure the activity feeds for the entities you want to follow, by going to the ‘Activity Feeds Configuration’ menu under the CRM system settings:

In this example, I’ve configured the following of “accounts” by specifying a new configuration profile with a target entity name of “account”, and by publishing the entity through my custom solution.

I also enabled the configuration on the “task” entity, and activated the ‘New Task for an Account’ rule:

Once this is done, you will see a new ribbon option to ‘follow’ or ‘unfollow’ any number of selected accounts in the accounts view:

Now that the desired company is being followed, any new task activity linked to this account will be displayed in the activity feed screen:

The next step is to provide a way to capture data from social networks such as LinkedIn, Facebook or Twitter to automatically store these information in the CRM

CRM 2011: Q4 Service Update and localhost

BugsOli — Wed, 02 Nov 2011 10:26:38 +0000

If, like me, you get consistent ‘Access denied’ error while browsing the “What’s New” activity feed screen, this is because you are using the following Web address: http://localhost/YOUR_ORG

Instead, try using the computer’s Netbios name, for example: http://yourserver/YOUR_ORG it should work!

CRM 2011: Update Rollup 5 with Q4 Service Update available through direct download

BugsOli — Wed, 02 Nov 2011 08:10:45 +0000

More information here: http://support.microsoft.com/kb/2567454/en-us

Link to the individual downloads: http://www.microsoft.com/download/en/details.aspx?displaylang=en&id=27820

This update will be available through Windows Update from the November 8, 2011.

CRM 2011: Update Rollup 4 available through direct download

BugsOli — Wed, 28 Sep 2011 10:05:50 +0000

More information here: http://support.microsoft.com/kb/2556167/en-us

Link to the download: http://www.microsoft.com/download/en/details.aspx?displaylang=en&id=27554

This update will be available through Windows Update from the 27^th of September

CRM 2011: Thunderbird compatibility

BugsOli — Tue, 30 Aug 2011 14:08:20 +0000

Well, this one is a recurring question: is Microsoft CRM compatible with other email clients such as Thunderbird?

Well, the simple answer is “No sir”, but I’ve found myself thinking about creating a free plugin that will give the ability to convert emails in Thunderbird to CRM emails and to synchronize contacts (at least from the Thunderbird address book to CRM).

It is a very much anticipated development but I already have the skeleton, and thanks to Microsoft CRM 2011 REST feature, I think I might end-up getting things to work.

What do you think, would such a plugin be useful to you? Feel free to comment and give me advices

How-to: Use SQL CTE with custom reports in CRM

BugsOli — Mon, 18 Jul 2011 12:55:42 +0000

One of my client asked me the other day to produce a report containing all the cases (incidents) in the system… OK, this is pretty easy and it already exists somewhere

But the hardest part was the filtering of this report: he wanted to be able to put a parent subject in the filter and the report should take care of getting all the child under this subject!

I said “hum…sure it can be done!” because I remembered about the CTE, or Common Table Expressions (more information here: http://en.wikipedia.org/wiki/Common_table_expressions)

Before going on with this post and dealing with code, I should back up a little bit and talk about the CTE…

As you may know, the CTE is kind of a temporary ‘table’, defined in the execution scope of a SELECT statement (for example). The beauty of this temporary ‘table’ is that it can be self-referencing so it’s easy to create recursive queries using them.

From the MSDN:

A CTE can be used to:

Create a recursive query. For more information, see Recursive Queries Using Common Table Expressions.

Substitute for a view when the general use of a view is not required; that is, you do not have to store the definition in metadata.

Enable grouping by a column that is derived from a scalar subselect, or a function that is either not deterministic or has external access.

Reference the resulting table multiple times in the same statement.

Using a CTE offers the advantages of improved readability and ease in maintenance of complex queries. The query can be divided into separate, simple, logical building blocks. These simple blocks can then be used to build more complex, interim CTEs until the final result set is generated.

Wow…I could’nt have done better And now for the fun part…

Retrieve the complete list of subject

You may think that this is simple but wait to see the query and you’ll get it:

This is how it looks in Microsoft CRM:

WITH  SubjectTree
        AS (
              -- anchor
            SELECT  s.subjectid, s.title, s.parentsubjectname, 0 as Level
            FROM    dbo.FilteredSubject s (nolock)
            UNION ALL
              -- recursive member
            SELECT  s.subjectid, s.title, s.parentsubjectname, Level+1
            FROM    dbo.FilteredSubject s (nolock)
                    INNER JOIN SubjectTree AS t 
                      ON s.parentsubject = t.subjectid
           )
SELECT
    t.*
FROM SubjectTree AS t
ORDER BY t.Level

This query’s result:

Filtering the CTE query:

Let’s put a query filter in the anchor part of the CTE query:

-- anchor
SELECT  s.subjectid, s.title, s.parentsubjectname, 0 as Level
FROM    dbo.FilteredSubject s (nolock)
WHERE s.title = 'Root level'

The result:

It’s pretty obvious that this kind of query can be very helpful in custom search engines or in reports, where the subject is used.

So how about integrating this kind of query in a custom report?

Integrating the CTE in a custom report:

I won’t explain how to create a custom report in this post since it has been covered previously (see part 1, part 2, part 3, part 4 or part 5).

Instead, I will put the query I’m using to show how to filter the cases based on a subject:

DECLARE @sql NVARCHAR(MAX)
 
SET @sql = '
    WITH  SubjectTree
        AS (
              -- anchor
            SELECT  s.subjectid, s.title, 0 as Level
            FROM    FilteredSubject s (nolock)
        WHERE   s.subjectid IN (SELECT i.subjectid FROM (' + @CRM_FilteredIncident + ') AS i)
            UNION ALL
              --recursive member
            SELECT  s.subjectid, s.title, Level+1
            FROM    dbo.FilteredSubject s (nolock)
                    INNER JOIN SubjectTree AS t 
                      ON s.parentsubject = t.subjectid
           )
 
    SELECT 
        i.contactidname AS contact,
        i.ticketnumber AS reference,
        i.title,
        i.subjectidname AS domain,
        i.createdon,
        i.owneridname AS owner,
        i.statecodename AS state
    FROM FilteredIncident AS i
    INNER JOIN SubjectTree AS s
        ON i.subjectid = s.subjectid
    WHERE i.casetypecodename = ''Urgent Problem''
        AND i.statecode = 0
    ORDER BY i.createdon DESC' 
 
EXEC(@sql)

Don’t forget to specify a default filter in your report when you upload it so your clients won’t have to define it afterwards, they will only have to set the correct subject and voilà, your report with recursive subject tree will spit out the results they are looking for

Useful links:

Using CTE (MSDN): here
Recursive queries using CTEs (MSDN): here
Definition of CTE (Wikipedia): here
Comparison of relational DB systems (Wikipedia): here

Interesting article: Microsoft CRM 2011 Multiple Forms basics

Olivier — Tue, 21 Jun 2011 12:28:48 +0000

I’ve just found out this very nice post on multiple forms basics in Microsoft CRM 2011, so I wanted to share it with you all…

Microsoft CRM 2011: Multiple Forms basics.

How-to series: Send SMS messages from CRM 2011 (part 3)

BugsOli — Tue, 07 Jun 2011 09:50:34 +0000

Finally! This is the final part of my how-to series on how to send and track SMS messages in Microsoft CRM 2011.

The first post explained how to prepare the solution.

The second post talked about the Web front-end customization.

This last post will explain how to communicate with Clickatell’s gateway to send your SMS messages.

First step: sign-up for a Clickatell account

First of all, you need to sign-up on Clickatell’s web site using their sign-up form which can be found here: http://www.clickatell.com/register/account_signup.php
Make sure you select the ‘clickatell central (api)’ and ‘International’ option for either Small Business or Enterprise
During the registration process, you have to provide a cellphone number in order to receive a unique and personal code, which will be needed to create a ‘Sender ID’. The definition of the ‘Sender ID’ is this:

A Sender ID is the name or number that the message appears to come from. By default you can send a message from the mobile number you registered your account with. If you wish to send messages from other numbers or names you will be required to register them. Approval of your submitted Sender ID is not guaranteed and generally only numbers, company and product names that we are able to verify will be approved. Any MO numbers linked to your account do not need to be registered.
Once you have filled all the required information, you will receive an email to activate your account and you will be able to put the activation code you received by SMS
Once the account is validated, you should receive 3 important information:
- Your username
- Your password
- Your ‘Client ID’

Which API do you need?

OK, this can be a bit confusing since Clickatell offers several types of API to developers: COM, HTTP, SOAP, SMTP, etc.

In my example, I used the SOAP API which is easier to integrate in a Microsoft CRM plugin but needs a permanent connection to the Web Service.

These are the steps to register a new API connection:

Log on to your Clickatell account (http://www.clickatell.com/register/account_login.php) using the correct product (in our case ‘Central API’) and fill in the username, client ID and password to access the ‘Central Home’ management console
The management console allows you to:
To create a new API connection, simply click on the ‘Create a new Connection’ hyperlink and select the type of connection you want to create, then request your ‘API ID’ (this parameter is really important for the rest of this article)
Once you close the confirmation screen, you will see a message stating that the 10 first test credits will always display the same SMS text (it’s OK, it’s just for testing purposes )
You are all set!

FYI, if you need to retrieve the API ID, just click on the ‘Manage my Products’ link in the management console:

Create the CRM plugin

OK, now it’s time to create our Microsoft CRM plugin using Visual Studio 2010; I’m using Pogo69’s CRM 2011 – Visual Studio Plugin Templates to easy my plugin developments so you might as well use it, it’s free

Create a new VS project using the CRM 2011 plugin template and give it a easy name, such as ‘SMSMessaging’
- In this new project, everything is already there for you to start developing your plugin, so I’m not going to explain all the steps
Start by modifying the ‘plugin.cs’ file and change the name of the public class to ‘SendSMS’ for example
Next step is to register the Clickatell’s Web Service by using the Internet address provided during the API connection creation: http://api.clickatell.com/soap/webservice.php?WSDL and by giving it an easy name (example: ‘Clickatell’)

Add a new CS file (it will contain the SOAP API return codes) called ‘ClickatellRC.cs’ with the following C# code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace SMSMessaging.ReturnCodes
{
    public sealed class StatusCodes
    {
        public const string m001 = "Status unknown";
        public const string m002 = "Message queued";
        public const string m003 = "Delivered to client gateway";
        public const string m004 = "Received by recipient";
        public const string m005 = "Error with message";
        public const string m006 = "User cancelled message delivery";
        public const string m007 = "Error delivering message";
        public const string m008 = "Message received by gateway";
        public const string m009 = "Routing error";
        public const string m010 = "Message expired";
        public const string m011 = "Message queued for later delivery";
        public const string m012 = "Out of credit";
    }
}

In your ‘plugin.cs’ file, add a reference to your return codes file:
```
using SMSMessaging.ReturnCodes;
```

When all of this is done, you can paste the following code in your file and then modify it to include the correct parameter according to your CRM customization (see previous post) :

public class SendSMS : IPlugin
{
    public void Execute(IServiceProvider serviceProvider)
    {
        IPluginExecutionContext context = (IPluginExecutionContext)serviceProvider.GetService(typeof(IPluginExecutionContext));
  
        // TODO - If you require tracing, uncomment the following line
        ITracingService trace = (ITracingService)serviceProvider.GetService(typeof(ITracingService));
  
        Entity entity = null;
  
        // Check if the InputParameters property bag contains a target
        // of the current operation and that target is of type Entity.
        if (context.InputParameters.Contains("Target") && context.InputParameters["Target"] is Entity)
        {
            // Obtain the target business entity from the input parmameters.
            entity = (Entity)context.InputParameters["Target"];
  
            // TODO Test for an entity type and message supported by your plug-in.
            if (entity.LogicalName != "xxx_smsmessage") { return; }
        }
        else
        {
            return;
        }
  
        try
        {
            if ((bool)entity.Attributes["xxx_readytosend"] == true)
            {
                // Obtain the organization service reference.
                IOrganizationServiceFactory serviceFactory = (IOrganizationServiceFactory)serviceProvider.GetService(typeof(IOrganizationServiceFactory));
                IOrganizationService service = serviceFactory.CreateOrganizationService(context.UserId);
  
                // Need to specify 'by hand' the binding and endpoint address
                BasicHttpBinding binding = new BasicHttpBinding();
                EndpointAddress ws = new EndpointAddress("http://api.clickatell.com/soap/webservice.php");
                // Instanciation of the Web Service client
                Clickatell.PushServerWSPortTypeClient client = new Clickatell.PushServerWSPortTypeClient(binding, ws);
                // Preparing the message
                string[] to = new string[1];
                to[0] = entity.Attributes["xxx_phonenumber"].ToString().Replace("+", "");
                string smsText = entity.Attributes["subject"].ToString();
                // Sending the message to Clickatell server
                string[] retCode = client.sendmsg("",
                    API_ID,
                    "USERNAME",
                    "PASSWORD",
                    to,
                    "SENDER_ID",
                    smsText,
                    0,
                    1,
                    0,
                    0,
                    3,
                    0,
                    1,
                    0,
                    0,
                    null,
                    0,
                    "SMS_TEXT",
                    null,
                    null,
                    1440);
                // Retrieving the message status to know if sent or not
                string msgId = retCode[0].ToString();
                retCode = client.querymsg("",
                    API_ID,
                    "USERNAME",
                    "PASSWORD",
                    msgId,
                    null);
                // Looking for the status code in the return code
                int index = retCode[0].IndexOf("Status:");
                string statusCode = retCode[0].Substring(index, 11);
                statusCode = statusCode.Substring(statusCode.IndexOf("0"), 3);
                // Updating the SMS activity status and delivery info
                SetStateRequest smsStatus = new SetStateRequest();
                smsStatus.EntityMoniker = entity.ToEntityReference();
                switch (statusCode)
                {
                    case "001":
                        smsStatus.State = new OptionSetValue(1);
                        smsStatus.Status = new OptionSetValue(100000002);
                        break;
                    case "002":
                    case "003":
                    case "008":
                    case "011":
                        smsStatus.State = new OptionSetValue(0);
                        smsStatus.Status = new OptionSetValue(100000003);
                        break;
                    case "004":
                        smsStatus.State = new OptionSetValue(1);
                        smsStatus.Status = new OptionSetValue(2);
                        break;
                    case "005":
                    case "007":
                    case "009":
                    case "010":
                        smsStatus.State = new OptionSetValue(1);
                        smsStatus.Status = new OptionSetValue(100000001);
                        break;
                    case "006":
                    case "012":
                        smsStatus.State = new OptionSetValue(2);
                        smsStatus.Status = new OptionSetValue(3);
                        break;
                    default:
                        break;
                }
                SetStateResponse resp = (SetStateResponse)service.Execute(smsStatus);
            }
        }
        catch (FaultException ex)
        {
            throw new InvalidPluginExecutionException("An error occurred in the plug-in.", ex);
        }
    }
}

You have to modify the following line #: 20, 29, 42, 46 to 50, 70 to 72

Your complete solution should look like this:

Now, I’m aware this code is not the best looking or the best bullet-proof C# code but it is only meant for educational purposes, so feel free to add all the error catching you want, etc. I don’t mind

Also, note that the part where I update the SMS message after getting the return code back from the Web Service does not work! The code is correct but the return message is always the same, which means that it is always kind of ‘OK’ even when it’s not

This might be due to the fact that the process is run synchronously or something like that, I don’t know and I haven’t investigated much…

Deploy your plugin

Now for the easy and last part of this post: deploying the new plugin!

Start the ‘Plugin Registration Tool’ found in the Microsoft CRM 2011 SDK package
Connect to your CRM server and to the appropriate organization
Register a new assembly and select your plugin’s compiled assembly
Once the assembly has been registered, you have to create a new step for it; in my case, I wanted to call the plugin in a new SMS message ‘Create’ event
Click on register new step, you’re all set!

Test your plugin

If you followed all the steps here above and modified what needed to be modified in the plugin code, you should be able to test your new plugin successfully:

Connect to your CRM server and go to your ‘Activities’ list
Create a new SMS message from the ribbon
Select a contact and type in its phone number (in a final customization, this field must be populated automatically according to a relationship mapping in CRM)

The phone number’s country code is required and must be typed without 0s or + sign

Click on the ‘Send SMS’ button in the ribbon… if everything goes well, you should receive a cool SMS message on your phone!

That’s it for this how-to series, I hope you enjoyed it! Feel free to put comments on this blog and remember…..you can always redirect your friends or colleagues to my posts also

Stay tuned for more how-to series in a near future.

CRM 2011: Update Rollup 2 available through direct download

BugsOli — Tue, 07 Jun 2011 07:10:15 +0000

More information here: http://support.microsoft.com/kb/2466086/en-us

Link to the download: http://www.microsoft.com/downloads/en/details.aspx?FamilyID=a5a088be-c19e-43b5-87fb-219c2a2bc280&displaylang=en

This update will be available through Windows Update from the 28^th of June.

How-to series: Send SMS messages from CRM 2011 (part 2)

BugsOli — Tue, 17 May 2011 09:36:24 +0000

In the first part (see part 1), I explained how a SMS could be better to communicate with your customers and contacts, since it is instantly dispatched on the cell phone.

In this part, I’ll deal with customizing the CRM as to enable this kind of communication.

How I’m doing it

Since we are dealing with a new activity, we are going to create a new activity entity; this entity will be responsible for sending the SMS messages to our contacts so we need a button to really do the action of ‘sending’ the message.

What I’ve devised is a simple method to send the message: once the ‘send’ button is clicked, a small JavaScript function changes the state of a check box on the message form then saves the message; once the message has been saved, a C# plugin is called which verifies the status of the check box and then constructs a message to send to Clickatell’s gateway.

That’s it! Pretty easy right?

In the remaining of this post, I’ll deal with:

The creation of the new custom entity
The implementation of the JavaScript function
The customization of the custom entity main form’s ribbon

Create a new activity type entity

The first thing to do is to create a new custom entity that will allow us to send SMS messages to our customers; of course this entity must be a new activity type, since we want to track down every single message sent to them in our communication history.

So here are the steps to follow:

In Microsoft CRM, go to your new ‘SMSMessaging’ solution (see part 1), click on the ‘New’ button and select ‘Entity’ in the sub-menu
In the new screen, enter the following information
- Display Name: SMS Message
- Plural Name: SMS Messages
- Name: XXX_smsmessage (or whatever you want)
- Tick the ‘Define as an activity entity’ check box and make sure ‘Display in Activity Menus’ is checked as well
- The rest is up to you
- Save your new entity

Now it’s time to add or modify some fields that will help us store the SMS message information such as: when was it sent, to which customer and which phone number, what is the message status, etc.

Field	Display Name	Custom	Type	Comment
RegardingObjectID	Contact	No	Lookup	When creating a new SMS message from an account or contact, only this field is set by default!
Subject	Text Message	No	Text	The text sent in the SMS message
XXX_phonenumber	Phone Number	Yes	Text	The contact’s phone number (must be formatted properly)
XXX_readytosend	Ready to Send?	Yes	Bit	Is the message ready to send or not (more on that later on)

Customize the main form to something like this
Add some cool icons and publish your customization and check to see if it looks good

Ok, we are done with the entity customization… now we need to create a small JavaScript function that will change the ‘Ready to send’ check box

Add a JavaScript function

Since we are going to use a C# plug-in for sending the message, we need something to ‘tell’ it to create the message and send it properly: this will be done thanks to our ‘Ready to send’ check box and JavaScript code below:

function SendSMS()
{
    if (Xrm.Page.getAttribute("xxx_readytosend").getValue() == false)
    {
        Xrm.Page.getControl("xxx_readytosend").setDisabled(false);
        Xrm.Page.getAttribute("xxx_readytosend").setValue(true);
        Xrm.Page.getControl("xxx_readytosend").setDisabled(true);
        Xrm.Page.data.entity.save("saveandclose");
    }
    else
    {
        alert("SMS message already delivered for sending!");
    }
}

This code must be included in a JS file and in the solution:

In your solution, click on the ‘New’ button and select ‘Web Resource’ in the sub-menu
In the new screen, enter the following information
- Name: XXX_sendsms
- Display Name: Send SMS JavaScript
- Description: whatever you like
- Type: Script (JScript)
- You can either paste your JavaScript code by using the ‘Text Editor’ button or upload your JS file (my choice here)
Save and close the screen to upload the file to Microsoft CRM
That’s it, your JavaScript has been packaged!

The last thing we need to do is to add something that’ll help us send the SMS message: this will be possible thanks to a custom button in the new entity’s ribbon, that will call our JavaScript function.

Customize the ribbon

The customization of the entity’s ribbon must be done manually in the customization file, which must be exported by using the solution export functionality:

Once the solution has been exported, you’ll find a single ZIP file where is enclosed several XML files; the one we are interested in is the ‘customizations.xml’ file:
Open this file in your favorite text editor and look for the following node
```
      "SMS Message"
```
The entity section contains several sub-nodes which defines the entity’s fields, forms, queries, etc.; the sub-node we need to modify is the ‘RibbonDiffXml’ node
```
    "SMS Message" OriginalName="SMS Message">ofusms_smsmessage
```
```
    10000
```
```
    
```
```
    
```
```
    
```
```
    
```
In the ‘RibbonDiffXml’ section, you have to (just copy the code below and you’re done ) :


    
        "CA_SendSMS" Location="Mscrm.Form.ofusms_smsmessage.MainTab.Save.Controls._children" Sequence="1">
            
                
            
        
        "CA_HideSaveAsComplete" Location="Mscrm.Form.ofusms_smsmessage.SaveAsComplete" />
        "CA_HideDeactivate" Location="Mscrm.Form.ofusms_smsmessage.Deactivate" />
    
    
        "Mscrm.Templates">
    
    
        "Mscrm.RunSomeJS">
            
                "B_SendSMS.Enable" />
            
            
            
                "SendSMS" Library="$Webresource:ofusms_sendsms">
            
        
    
    
        
        
        
            "B_SendSMS.Enable">
                
                    
                        "Create" />
                    
                    
                        "Existing" />
                    
                
            
        
    
    


Let me explain what this code does:

Line 3: Defines where a custom button (for example) will be positioned in the default ribbon
Line 5: This line defines the custom button, with all its properties (the button text, the JavaScript command, the icons, etc.)
Line 8 & 9: These 2 lines are used to hide a particular element in the ribbon (in these cases the ‘Save as complete’ & ‘Deactivate’ buttons)
Line 15: This line defines the command that has been set in the button properties (see line 5, ‘Command’)
Line 17: This line defines when the command can be used, it is a reference to the line 29
Line 21: This line defines which JavaScript function is called in which web resource when the button is clicked
Line 29: This is the rule definition for the custom button (same as saying ‘when is the button enabled?’)

Why did I use an ‘OrRule’ in my ‘EnableRules’ section? Well, a CRM form can’t be in ‘Create’ mode and in ‘Edit’ mode at the same time so you need to specify that the button is enabled either in ‘Create’ or ‘Existing’ (‘Edit’) mode

Make sure you include your modified customization file in a new ZIP file and import it back in your CRM, publish everything and you should see something like this in your SMS message form ribbon:

This is it for this pretty long post, I’ll take you on the plugin journey in the next part so stay tuned for the big final!

How-to series: Send SMS messages from CRM 2011 (part 1)

BugsOli — Fri, 06 May 2011 10:59:10 +0000

In a time where the information must be available quickly, there is an alternative to feeds, tweets, walls and emails….this alternative is called SMS, for Short Message Service.

Of course, one can always say that an SMS is the same thing as a tweet with roughly the same text length but who can say that its cell phone is always connected to the Internet? Not me, it is way too expensive here in Belgium!

On the same note, all cell phones can receive basic text SMS messages so this is an interesting alternative to emails and so on.

So in this series, I wanted to focus on a small plugin that would allow any of your customers to be alerted by SMS instead of by email, SMS that should be sent from Microsoft CRM of course

This first part will focus on customizing Microsoft CRM to prepare for the plug-in that I’ll develop on the second part.

Pre-requisites to this series

For this SMS integration to work, you should consider using a Clickatell account (www.clickatell.com) and their set of APIs to connect to their SMS gateway (APIs available through HTTP, SMTP, SOAP, XML, COM, …)

This company offers 10 free SMS to test your code, then you can buy credits for sending ‘real’ messages throughout the world (I don’t have any acquaintance with them but I find that their site is clear and easy to understand; on the other hand, there are no real C# code samples).

If you need help signing-up with them, please contact me and I’ll try to help you.

How is this series divided?

This series will be divided in 3 parts:

Part 1 of 3: Expressing the requirements and creating the CRM solution
Part 2 of 3: Customizing the CRM for the new SMS activity
Part 3 of 3: Developing the CRM plugin for sending the SMS

Expressing the business needs

Ok, down on the needs now

Let’s assume you want to be able to send SMS to your customers just like you would send an email from Microsoft CRM, how would you that?

Well thankfully, Microsoft CRM 2011 allows you to create new activity types (see previous post New activity types for dummies) so I’ll use this new awesome feature.

Creating the CRM solution

Ok, in this first post I’ll show you how to properly prepare a solution for your SMS implementation but you are free to do as you wish.

Make sure you have a backup of your original CRM customizations before you start customizing your system
Within Microsoft CRM, create a new solution called SMSMessaging; this solution will host our customizations for the new SMS functionality

Open your new solution and add the following entities for now:

Account
Activity
Contact
Lead
User

OK you’re ready to go…..it’s very easy for now but stay tuned and watch for the second part of this series, where I’ll show you some cool stuff!

CRM 2011: Hide a button in a custom entity’s form ribbon

BugsOli — Thu, 28 Apr 2011 13:01:44 +0000

For all of you who wanted to know how to do this, here are the steps:

Make sure the custom entity is part of the solution you want to export and modify
Export the solution and edit the customizations.xml file
In this file, each entity has its own
tag so you need to find the one that suits your needs (example: if your custom entity is called new_test, you should look for the node
```
 "Test" OriginalName="Test">new_test
[...]
```
In this node, you should see a sub-node starting with , which is the node containing the ribbons elements for your particular entity
In this new section, you should only modify the
node, which is the node containing all the custom actions for the entity’s ribbon: add a new button, hide a button, change the behavior of a particular button, etc.
1. Under
  , place the following code if you want to hide the ‘Save as complete’ button
  "CA_HideSaveAsComplete" Location="Mscrm.Form.new_test.SaveAsComplete" />
2. Do not forget to close the tag after it!

The complete code should look like this:

    
        "CA_HideSaveAsComplete" Location="Mscrm.Form.new_test.SaveAsComplete" />
    
        "Mscrm.Templates">

After having saved the modified customizations.xml file, compress all the solution files in a new ZIP package and import it back in Microsoft CRM.

Once the package has been published, you should “see” that the ‘Save as complete’ button has disappeared on your entity’s form

CRM 2011: Update Rollup 1 available through direct download

BugsOli — Thu, 14 Apr 2011 10:16:00 +0000

More information here: http://support.microsoft.com/kb/2466084

If you don’t want to bother downloading all the components separately, wait until the 26th of April when the update will be given through Windows Update.

Are you ready for the Cloud?

BugsOli — Mon, 07 Mar 2011 14:49:46 +0000

In this video from Software Advice, Brad Wilson, General Manager of Microsoft Dynamics CRM, explains the choice between Microsoft Dynamics CRM Online and On Premise.

It all ends up to this obvious question: are your clients ready for the Cloud or not?

Brad Wilson on moving to the Cloud

Get ready for a fight Salesforce.com!

BugsOli — Thu, 24 Feb 2011 08:32:32 +0000

In this video from Software Advice, Brad Wilson, General Manager of Microsoft Dynamics CRM, gives an overview of the current and future strategy behind Microsoft Dynamics CRM 2011.

What is interesting about this interview is the fact that Microsoft is really focusing on its cloud solution (3:35), which will offer various cloud-based scenarios.

Brad Wilson on Microsoft’s strategy for Microsoft Dynamics CRM 2011

Where are we with the CRM software market today?

BugsOli — Wed, 23 Feb 2011 09:41:30 +0000

Here is an interesting video from Software Advice about the CRM software market as-of today compared with 12 years ago.

As you will hear, Brad Wilson (General Manager of Microsoft Dynamics CRM) talks about the difference between the way people treated a CRM solution 12 years ago and nowadays, stating the obvious: CRM is a must-have today!

State of the CRM Software Market, with Brad Wilson

CRM 2011: RTM today!

Olivier — Thu, 17 Feb 2011 10:59:20 +0000

Or yesterday it seems

http://www.microsoft.com/downloads/en/details.aspx?FamilyID=c3f82c6f-c123-4e80-b9b2-ee422a16b91d&displaylang=en

How-to series: Create a custom report (part 5)

BugsOli — Thu, 10 Feb 2011 12:23:52 +0000

So, after a long time, I’ve decided to end my how-to series by explaining how to embed a subreport in a custom report.

If you don’t already know how to create a custom report, I’ll suggest that you follow my previous posts on this same blog for more info: part 1, part 2, part 3 and part 4.

So the purpose of this last post of the series is to explain how-to embed a subreport in a parent report and how-to pass parameters to this subreport (for example: pass the account ID from the parent report to the subreport).

Now, let’s imagine you want to track software deployments and milestones within your CRM with the following business requirements:

Each account can have 0..N deployment(s) [1:N relationship in CRM]
Each deployment can have 0..N activitie(s) [1:N relationship in CRM]
Each deployment can have 0..N milestone(s) [1:N relationship in CRM]
Each milestone can have 0..N activitie(s) [1:N relationship in CRM]

I’m sure you figured how to map these requirements in Microsoft CRM already, so let’s just put an image to illustrate the entities and their relationships (fields and entities not relevant to our example are omitted for easy understanding):

Now for the report design requirements:

The report should be grouped by milestone category
Each row should display only the milestone title and should allow for drill-down to the complete description and linked activities
Each milestone should have an order number in the report (not in CRM)
For each milestone displayed, the linked activities should be displayed under it

If you’ve already done some reports using Reporting Services, you know this is kind of basic stuff; for the others, I’ll explain the steps needed to create this kind of report since it involves the use of a subreport:

Create a new report and add the default datasets for use against CRM; my advice is to create a new report based on an existing CRM report

This report will contain:

2 new datasets that will be used to populate our table
A report parameter (CRM_ParameterID) that will be used to store the milestone ID, this parameter being used in the subreport

A table that holds the deployment & milestone info, as well as a reference to the subreport which will display the activities linked to the milestones; the TSQL code for the dataset behind this table should look like this:

DECLARE @sql NVARCHAR(MAX)

SET @sql = '
    select 
        account0.name as accountname,
        contact0.fullname as contact_name,
        contact0.emailaddress1 as contact_email,
        contact0.telephone1 as contact_phone,
        deploy0.new_deploymentid,
        deploy0.new_deploymentsubject as subject,
        deploy0.new_deploymenttypename as deploy_type,
        miles0.new_milestoneid,
        ROW_NUMBER() OVER (ORDER BY miles0.new_milestonecategory) as milestone_nb,
        miles0.new_milestonecategoryname as category,
        miles0.new_milestonedate as planned_date,
        miles0.new_milestonetitle as milestone_title,
        miles0.new_milestonedescription as milestone_desc,
        miles0.new_milestonerealizeddate as realized_date,
        miles0.owneridname as responsible
    from (' + @CRM_FilteredAccount + ') as account0
    inner join Filterednew_deployment as deploy0
        on account0.accountid = deploy0.new_associatedaccountid
    inner join Filterednew_milestone as miles0
        on deploy0.new_deploymentid = miles0.new_associateddeployment
    left join FilteredContact as contact0
        on deploy0.new_associatedcontactid = contact0.contactid
    order by miles0.new_milestonecategory ASC'

EXEC(@sql)

NB: In this TSQL example, I used the ROW_NUMBER() OVER ([…]) function to generate some auto-numbers based on the milestones category; for more information on this SQL Server function (only available in SQL Server 2005 and up), please follow this article.

The general layout for this report should look like this (this is an example):
- In this example, the element highlighted in yellow is the reference to the subreport: to reference a sub-report, just click on the subreport icon and select an empty cell in the table
- The subreport properties we must deal with are the general properties and the parameters properties:
- In the ‘General’ properties, you must choose the report to be used as a subreport (see #4 hereunder)
- In the ‘Parameters’ properties, you must configure the parameter to use and the value that will be passed, in this case it is the CRM_ParameterID parameter, which gets the ‘new_milestoneid’ value:

After the first report is completed, create a new empty report with the following:

A report parameter (CRM_ParameterID) that will hold the milestone ID passed by the parent report

A dataset that returns the list of activities based on the parameter; here is an example of TSQL code:

select 
    act0.activitytypecode,
    act0.description as activity_desc,
    act0.owneridname as activity_resp,
    act0.subject as activity_subject,
    act0.scheduledend as activity_time,
    act0.statuscodename as activity_status
from FilteredActivityPointer as act0
where act0.regardingobjectid = @CRM_ParameterID
order by act0.scheduledend DESC

The design is really simple and could look like this:

Okay, time to deploy the reports! First, you must deploy the parent report then the subreport; I will not explain the deployment of the first report, since this has been explained
at the end of this post. The steps to deploy the subreport are exactly the same, and since everything was configured correctly in the parent report, the ‘Parent Report’ section is automatically filled for you:
Once you test the report, this is the result you get:

CRM 2011: The RC version is here!

BugsOli — Wed, 15 Dec 2010 09:09:57 +0000

As stated on various blog around the world, the Release Candidate version of Microsoft CRM 2011 is finally here!

I’ll updating soon, if not today, to see what has changed and what has been corrected

Stay tuned!

Some links:

CRM 2011 Server RC

http://www.microsoft.com/downloads/details.aspx?FamilyID=c3f82c6f-c123-4e80-b9b2-ee422a16b91d

CRM 2011 Outlook Client

http://www.microsoft.com/downloads/details.aspx?FamilyID=22dc423a-7194-491e-a169-6ace16bfdd36

Language Pack

http://www.microsoft.com/downloads/details.aspx?FamilyID=db44c564-2338-407e-980a-c9c83ad37729

Email Router

http://www.microsoft.com/downloads/details.aspx?FamilyID=a995f6ad-0099-42fd-9b22-cf7b3d40a2bf

BIDS

http://www.microsoft.com/downloads/details.aspx?FamilyID=64a09b75-8376-4b9d-aea3-8a83a1837c4d

SharePoint Connector

http://www.microsoft.com/downloads/details.aspx?FamilyID=23c0f351-8694-4d92-9ddf-34a949aec6a7

Azure: Want to know more about SQL Azure DB Manager?

BugsOli — Wed, 15 Dec 2010 09:03:18 +0000

Follow this link!

How-to series: Create-and-deploy a “template” organization

BugsOli — Wed, 15 Dec 2010 08:56:25 +0000

Okay, now this post is going to show how to quickly export a complete CRM 4.0 organization, which includes:

customizations
reports
workflows
mail-merge templates
email templates
contract templates
plugins (only those who have been deployed to the database)
data

The principle behind all this: quickly clone all your developments in a small amount of steps! Who said that the IT guys are lazy?

Ok, now suppose that you have a project where you must deploy a couple of times the same customizations, same plugins, etc. What I’m talking about here is typical of a company offering the same basic customization to all of their clients (which is my business right now).

In my case, I needed to deploy 30 organizations within the same CRM implementation with the same customizations, reports, plugins and ISV pages

My first approach, which is correct but time-consuming, was to create 30 different OUs and to deploy all my customizations, reports and plugins afterwards. You can imagine the time it takes: even if you take 30 minutes per OU, it would take at least (30 min * 30 OU) = 900 minutes (or nearly 2 days based on a 8-hour a day work-day) just for the deployment part!

This timing does not even include the organization parameterization: users creation, system parameters management, and so on.

So I needed to find another way to quickly deploy my 30 OUs…then I remembered that you could import new organizations in Microsoft CRM just by using the ‘Deployment Manager’.

So I investigated this path, and came to the conclusion that it is possible and highly efficient, so here are the steps to follow to clone your organizations:

Prepare your “template” organization by deploying all your customizations, reports, workflows, email & mail-merge templates and your plugins (remember: your plugins should be deployed in the database; refer to this post to show how to deploy them in DB)
Disable (or deactivate) the “template” organization using the ‘Deployment Manager’
- Launch the ‘Deployment Manager’
- Go to “Organizations”, then select the “template” organization and choose “Disable” in the right-hand view
Now that your OU is disabled, you have a “template” OU, pointing to a “template” (or “master”) SQL Server database; the next step is to clone this database (along with the log file) to be able to reimport it afterwards
- Launch the SQL Server Management Studio
- Right-click on your “master” database and select “Tasks –> Copy Database…”; The Copy Database Wizard should show up
- Follow the wizard until it asks you for the destination database, where you must change the database name (from “master” to “clone”)
- If everything was done correctly, the process should be successful and you should get a perfect copy of your “master” CRM database (meaning: you have a perfect “clone” )
Now, head back to the ‘Deployment Manager’ to import the new organization
- Go to “Organizations”, then choose “Import Organization…” in the right-hand view
- The import wizard will show up and let you choose the organization to import; this step involves querying the SQL Server databases in search for new MSCRM databases, so we must find our “clone” in the list of available databases
- The next steps involve giving an organization name (must be unique) and pointing to the correct Reporting Services server in order to deploy the embedded reports
Voilà, you’re done! You have successfully deployed a perfect clone of your “template” organization in maybe 10 minutes (in my case: 10 min * 30 OUs = 300 minutes or 5 hours max to deploy everything!)

HTH

CRM 2011: Global launch event

BugsOli — Tue, 14 Dec 2010 15:25:13 +0000

“Thursday, January 20th, 2011 at 9am PST” is the date you can’t miss!

Quote from the web page http://crm.dynamics.com/2011launch/:

“Attend this FREE global virtual launch event and watch Microsoft CEO Steve Ballmer introduce Microsoft Dynamics CRM 2011. Learn how it is designed to help you boost sales, improve marketing, enrich customer service interactions, and accelerate line of business application development through xRM.

Hear keynote presentations by Kirill Tatarinov (Corporate Vice President, Microsoft Business Solutions), Michael Park (Corporate Vice President, Microsoft Business Solutions), and Brad Wilson (General Manager, Microsoft Dynamics CRM).”

“In addition, you’ll be able to:

Get a sneak peek view through engaging demos.
Hear success stories from real customers who put Microsoft Dynamics CRM 2011 to work for them.
Choose from 15 different tracks especially designed to suit your business, industry or IT needs.
Chat live with Microsoft experts and other customers in real time during the event.”

Ready? Register here.

CRM 2011 : Ajouter des packs de langue

BugsOli — Sat, 27 Nov 2010 11:47:37 +0000

Bien que Microsoft CRM 2011 soit multi-langues, il est nécessaire d’installer un pack de langue pour que celle-ci soit disponible lors de l’instanciation d’une nouvelle organisation (OU).

En effet, il faut savoir que dans la version bêta, l’instance par défaut créée lors de l’installation, est toujours en langue anglaise (ENG).

Une fois l’installation terminée, il est nécessaire d’installer un ou plusieurs pack(s) de langue pour que les OU suivantes puissent en bénéficier.

Les étapes à suivre sont :

Télécharger le pack de langue adéquat sur le site de Microsoft en choisissant une langue différente de l’anglais ici
- Si on choisit le français, il n’est pas possible de télécharger la version “serveur” de Microsoft CRM 2011, par contre, il faut télécharger le fichier MUI (exemple : CRM2011-mui-FRA-amd64.exe)
Une fois le pack téléchargé, il faut l’installer sur le serveur CRM

Double-cliquer sur le pack téléchargé pour lancer l’extraction des fichiers
Double-cliquer sur le fichier muisetup_CODELANGUE_CODEPLATEFORME.exe (exemple : muisetup_1036_adm64.exe)

Une fois l’installation terminée, vous pouvez utiliser la langue installée lors de la création d’une nouvelle organisation via le gestionnaire de deploiement

Et voilà !

How-to series: Change activities’ status when closing opportunities

BugsOli — Wed, 24 Nov 2010 12:34:29 +0000

Okay, this post is a response to a good question made by someone on the Microsoft Dynamics CRM forum (for Partners).

The initial question was:

“Hi All,

When an opportunity is cancelled, the activities (tasks, appointments, etc.) are not being flagged as cancelled and staying considered as “open” items. We need to find a solution that when an opportunity is closed (or cancelled) that all associated activities tied to that opportunity be deleted. Can i automate the above process? I tried using workflow, but i am not able to trigger an Activity record.

Regards,

VP”

A response from Dylan Haskins pointed to a really cool workflow plugin called ‘Distributed Workflow’ and available on Codeplex here.

In this post, I will show how to use this plugin in the particular situation stated above.

Download the plugin (which is basically a DLL) and copy it on your CRM server
Launch the ‘Plugin Registration tool’, given with the Microsoft Dynamics CRM SDK (available here)
In the registration tool, you simply need to register the plugin and that’s it!
When this step is done, a new workflow step will be available in your workflow rules:
So, let’s create a new workflow rule that will target an opportunity, but first you have to know the type of relationship between an activity and an opportunity: start by going to the “1:N relationships” in the opportunity entity and write down the name of the relations between the various activities and the opportunity
Now create a new workflow rule against the phone call entity and simply add a workflow step that changes the phone call’s status to ‘Cancelled’; this workflow rule must be available to run ‘on demand’. Publish it
Now that you have your ‘related’ workflow rule, let’s create another one but this time you must target the opportunity entity
This workflow should run whenever you change the opportunities’ status reason to ‘Cancelled’, so we should first verify the status reason and then launch the ‘on demand’ workflow rule, based on the 1:N relationship. Don’t forget to publish your workflow once it is done.
In our case, the ‘Distribute Workflow (1:N)’ properties should be set to this:

Before the workflow rules were deployed, this is what it looked like when an opportunity was closed or cancelled:

You can see that all the activities are still open!

Now that we have deployed our new workflow rules, this is what it looks like (which is much better ):

Workflow running

Phone call activity now cancelled as well!

NOTE: If you want to cancel other activity types, you have to repeat the steps 5 & 6 to create a workflow rule for each activity type; then, you would modify the opportunity workflow rule to take into account the other ‘on demand’ workflows

HTH!

Update Rollup 14

BugsOli — Wed, 24 Nov 2010 09:20:01 +0000

Haha! This update rollup *should* resolve the following issue I had with my workflows: “For a Send Email step in a workflow, an email template is not retained when the email step properties window is opened again.”

It is available here: http://www.microsoft.com/downloads/en/details.aspx?FamilyID=0fde5456-05a5-4407-81b3-0eaa928c8cc3&displaylang=en

CRM 2011: New activity types for dummies® – Part 1

BugsOli — Thu, 04 Nov 2010 15:31:26 +0000

After a couple of days without posting anything, I thought about explaining a real case scenario where your client would like to deal with meeting minutes inside Microsoft CRM.

This real case scenario is based, obviously, on Microsoft CRM 2011 and its ability to create new activity types (meaning: these new types are derivative of the ‘Activity’ entity).

The scenario is pretty simple: the client wants to track the meeting minutes in the CRM and use the field audit feature to track the meeting minutes revision (more on that in another post).

Furthermore, he/she (let’s not be sexist ) wants to be able to assign actions related to the meeting minutes (action plan definition). A good read about what “minutes” are is available here.

Here is the object model, based on the Microsoft CRM object model (available here):

How to create a new activity type

Create a new entity and give it a name (for example: ‘Meeting Minute’)
Check the ‘Define as an activity entity’ check box and keep the ‘Display in Activity Menus’ check box checked
Change the primary field name to reflect your needs
Save your new entity!
Now that your entity is created, you can modify the fields that have been created automatically by setting the ‘Define as an activity’ check box
- ‘Rescription’ is renamed to ‘Report’: will hold all the meeting’s discussion points
- ‘Owner’ is renamed ‘Submitter’: the person who submits the meeting minutes
- ‘Required’ is renamed ‘Present’: the people who attended the meeting
- ‘Optional’ is renamed ‘Absent’: the people who did not attend the meeting
- ‘Actual End’ is renamed ‘End of Meeting’: the real meeting’s end time
- ‘Actual Start’ is renamed ‘Start of Meeting’: the real meeting’s start time
- ‘Subject’ is renamed ‘Purpose’: why is the meeting taking place anyway?
Last but not least, as you want to track all the meeting’s action points, you must create a 1:N relationship to the ‘Task’ entity (this way, you can use the “sub-grid” functionality in the form’s designer!)
When all of this is done, it’s time to edit the entity’s default form; I’ll put the form I designed for my client:

On my form, I have 7 different “tabs”

agenda: a meeting for what? / who is the organizer? / regarding what?
attendees: who was there? / who wasn’t there?
timeline: when did the meeting start? / when did it end?
report: the meeting’s complete report (text field)
action items: a list of tasks that are created during the meeting
documents: uses the SharePoint list component to store documents
notes: (self-explanatory)

For visibility, I’ve also put the regarding field in the form’s header, which is a good way of knowing to which customer (for example) this meeting minute is linked to
Also, I make a good use of the new form’s footer functionality by exposing the ‘Created By’ and ‘Created On’ fields as they are system fields which do not require any user-entry

The result of these customizations should look like this:

Conclusion

The concept of having the ability to create new activity types is awesome! You’re not limited anymore and only your imagination will limit you

This is the kind of customization I wanted to see a long time ago in CRM 3.0 & 4.0, hopefully it did come to life (there is still another thing that could be cool: the ability to “send” a meeting minute like a mail, but I haven’t found how yet, except with a workflow).

CRM 2011: New update (KB2439176) for beta available!

BugsOli — Thu, 04 Nov 2010 10:19:44 +0000

New update for Microsoft CRM 2011 beta is available through Windows Update since the 26th of October.

I haven’t found any information on this update so far, so I’m going to test it against my deployment to find any bug or error.

CRM 2011: Show-off your icons!

BugsOli — Tue, 26 Oct 2010 14:04:53 +0000

One of the noteworthy feature available now in Microsoft CRM 2011 is the ability to define ‘Web Resources’ which are a set of ‘virtual’ files that can be accessed from a URL (think: virtual folder holding the files on the CRM server).

One thing you can do now in CRM 2011 is store a couple of PNG files representing icons for custom entities, which is pretty cool since the PNG format is a lossless and well-compressed format which adds variable transparency compared to GIF which is a compressed format based on a proprietary patent! (source).

So, from now on, please, SHOW-OFF your icons

CRM 2011 : Adaptez vos modèles d’emails à la nouvelle version !

BugsOli — Mon, 18 Oct 2010 13:34:41 +0000

Finalement, il n’en fallait pas plus à Microsoft pour adapter sa plateforme CRM aux demandes des partenaires (dont moi ) : il est désormais possible d’attacher un ou plusieurs document(s) dans les modèles d’emails !

En effet, quoi de plus frustrant dans les versions précédentes (3.0 et 4.0) que l’impossibilité d’attacher des documents annexes aux modèles d’emails : pour preuve, qu’il s’agisse de la volonté d’envoyer un magazine mensuel par voie électronique ou une fiche produit, il a fallu attendre la version 2011 de la plateforme CRM pour que cela devienne possible.

Ainsi, il faudra tenir compte, lors d’un upgrade futur, de la possibilité de révision de tous les modèles d’enteprise afin de prendre en compte cette nouvelle fonctionnalité.

Voici un bref aperçu des nouvelles possibilités désormais offertes par Microsoft CRM 2011 au niveau des modèles (liste non exhaustive, il faudra attendre la prochaine release pour l’activation de toutes les fonctionnalités) :

Ajout d’un ou de plusieurs documents
Ajout d’images via l’éditeur de texte (actuellement indisponible dans la bêta)
Ajout de liens hypertexte via l’éditeur de texte (actuellement indisponible dans la bêta)

N’oubliez donc pas de prévoir du temps pour cette migration, car passer en revue tous les modèles d’une grande organisation (bancaire par exemple) peut s’avérer fastidieux !

Olivier

How-to series: Generate auto-numbers on custom entities (part 2)

BugsOli — Tue, 12 Oct 2010 08:03:38 +0000

In the first post of the series (see Part 1), I was dealing with the creation of a new entity which can be used to store the autonumbering parameters such as: which entity must get a number, which attribute must store the number, the number length, the prefix & suffix, etc.

In this second post, we will see how to generate the autonumber by using a plugin.

I’ll use Visual Studio 2010 with C# to create this plugin and then show how it work in real life.

First step, open VS 2010
Next, create a new ‘Visual C# Windows Class Library’ project (you can choose either the .NET Framework 3.0 or 3.5)
Add a reference to the two following Microsoft assemblies given with the Microsoft CRM SDK (these DLLs are located under the CrmSdk\bin folder; make sure you choose the right version: 32-bits or 64-bits)
- Microsoft.CRM.Sdk.dll
- Microsoft.CRM.SdkTypeProxy.dll
Next step, sign your assembly before doing anything else
- Right-click on your project and select ‘Properties’
- Select the ‘Signing’ menu
- In the drop-down list, choose to create a new strong name key file by selecting the “” option
- Type in a key file name and choose a strong password
- Visual Studio will then create a ‘.pfx’ file which will be attached to the assembly

Rename the created C# class to whatever you like and put the code listed above (the code is self-explanatory):

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
using Microsoft.Crm.Sdk;
using Microsoft.Crm.SdkTypeProxy;
using Microsoft.Crm.Sdk.Query;

namespace xRM.AutoNumberPlugin
{
    /// 

    /// Class that generates a random number for the Test Entity
    /// 
    public class TestEntityAutoNumber : IPlugin
    {
        public void Execute(IPluginExecutionContext context)
        {
            DynamicEntity entity = null;

            // Verify we have an entity to work with
            if (context.InputParameters.Properties.Contains("Target") &&
                context.InputParameters.Properties["Target"] is DynamicEntity &&
                context.MessageName.Equals("Create"))
            {
                // Obtain the target business entity from the input parameters.
                entity = (DynamicEntity)context.InputParameters.Properties["Target"];

                if (!context.OutputParameters.Properties.Contains("id")) { return; }

                // Verify that the entity represents a test entity
                if (entity.Name != "new_testentity") { return; }
            }
            else { return; }

            try
            {
                // Verify that the ID is returned upon creation of the test entity
                string entityId = context.OutputParameters.Properties["id"].ToString();
                Key entityKey = new Key();
                entityKey.Value = new Guid(entityId);

                // Get a new instance of the CRM service from the context
                ICrmService service = (ICrmService)context.CreateCrmService(true);

                // Create the query on the auto number entity
                QueryByAttribute query = new QueryByAttribute();
                query.ColumnSet = new AllColumns();
                query.EntityName = "xrm_automaticnumber";
                query.Attributes = new string[] { "xrm_entityname" };
                // The entity name you're looking for, selected from the drop-down list (see the how-to part 1)
                query.Values = new string[] { "new_testentity" };
                // Create the request based on the above query
                RetrieveMultipleRequest request = new RetrieveMultipleRequest();
                // Set the request properties
                request.Query = query;
                request.ReturnDynamicEntities = true;
                // Execute the request and get the response
                RetrieveMultipleResponse response = (RetrieveMultipleResponse)service.Execute(request);

                string prefix = null;
                string suffix = null;
                int length = 1;
                // Parse the response to get the values you want 
                //  (there should be only one record for the same entity)
                foreach (BusinessEntity be in response.BusinessEntityCollection.BusinessEntities)
                {
                    if (((DynamicEntity)be).Properties.Contains("xrm_prefix"))
                        prefix = ((string)((DynamicEntity)be)["xrm_prefix"]).ToString();
                    if (((DynamicEntity)be).Properties.Contains("xrm_suffix"))
                        suffix = ((string)((DynamicEntity)be)["xrm_suffix"]).ToString();
                    if (((DynamicEntity)be).Properties.Contains("xrm_length"))
                        length = ((CrmNumber)((DynamicEntity)be)["xrm_length"]).Value;
                }
                // Generating a random number based on the cryptographic library                char[] chars = new char[10];
                string a;
                a = "1234567890";
                chars = a.ToCharArray();
                byte[] data = new byte[1];

                RNGCryptoServiceProvider crypto = new RNGCryptoServiceProvider();
                crypto.GetNonZeroBytes(data);

                data = new byte[length];
                crypto.GetNonZeroBytes(data);
                StringBuilder result = new StringBuilder(length);
                foreach (byte b in data)
                {
                    result.Append(chars[b % (chars.Length - 1)]);
                }
                // Update the new entity's number attribute with the retrieved prefix & suffix and add the random number
                PropertyCollection properties = new PropertyCollection();
                properties.Add(CrmTypes.CreateStringProperty("new_testentitynumber", prefix + "-" + result.ToString() + "-" + suffix));
                properties.Add(CrmTypes.CreateKeyProperty("new_testentityid", entityKey));
                entity.Properties = properties;

                // Creating a target update message to alter the newly created entity
                TargetUpdateDynamic updateEntity = new TargetUpdateDynamic();
                updateEntity.Entity = entity;

                // Creating a request on the server
                UpdateRequest updateRequest = new UpdateRequest();
                updateRequest.Target = updateEntity;

                // Updating the entity by using the created ICrmService
                UpdateResponse updated = (UpdateResponse)service.Execute(updateRequest);
            }
            catch (System.Web.Services.Protocols.SoapException ex)
            {
                throw new InvalidPluginExecutionException("An error occurred in the TestEntityAutoNumber plug-in.", ex);
            }
        }
    }
}

Compile your code and copy your assembly over to your server (I prefer this method)
Launch the “Plugin Registration Tool” on the CRM server and connect to the desired organization
- Once connected to the correct organization, the right screen will display the list of already deployed plug-ins
- Click on ‘Register’ and select the ‘Register New Assembly’ option from the toolbar, or use CTRL – A
- On the ‘Register New Plugin’ screen, select your assembly and select the class you want to register; I always choose to store my plug-ins in the database but this depends on your needs. Hit the “Register Selected Plugins” once you’re done
- If everything is OK, you should see this kind of message:
- The next step is the registration of a new ‘Step’ which is the event the plug-in will be attached to; to register a new step for the new plug-in, select your plug-in in the right screen and click on the ‘Register New Step’ in the toolbar (or hit CTRL – T)
- Now this is the fun part: you have to tell the server to which event the plug-in will be attached to (Create, Update, Delete, etc.). You also need to specify on which entity the plug-in will be run and the stage of execution (pre or post): these parameters are mandatory! (You can find more information on the execution pipeline here and on plug-in development & deployment here)
- Hit ‘Register New Step’ to create the event handler
- Last step is to create a pre or post XML image depending on your needs: in my case, I always create a post image if I’m dealing with a ‘Create’ messages (obviously, there is nothing in the database at that time so a pre image is irrelevant) and I always create pre & post images on ‘Update’ messages to get the data before and after update (think audit plug-in for example). To create a new image, select the step you just created in the right screen and select the ‘Register New Image’ from the toolbar or hit CTRL – I
- In this last screen, you have to select the image type (pre or post) and give it a name: the name is really important if you want to use a code like the one below, which creates a new dynamic entity object from the post image:
```
// Post image for the current entity
DynamicEntity postImage = new DynamicEntity();
postImage = (DynamicEntity)context.PostEntityImages.Properties["postEntityImageXml"];
```
- Hit the ‘Register Image’ button to create the new image
Everything is all set! Your plug-in is now deployed and ready to run And here is the example based on the code above (see step 5 on this blog post):

Links:

Generating unique keys in C#: http://www.codeproject.com/KB/aspnet/UniqueKeys.aspx
MSDN – Creating a simple plug-in: http://msdn.microsoft.com/en-us/library/bb955365.aspx

CRM 2011: Installer le connecteur SharePoint 2010 pour Microsoft CRM 2011

BugsOli — Mon, 11 Oct 2010 13:14:00 +0000

Une nouvelle fonctionnalité de Microsoft CRM 2011 est la possibilité d’utiliser SharePoint 2011 pour l’intégration des documents CRM.

Cette fonctionnalité était longuement attendue et pouvait être implémentée dans la version précédente de Microsoft CRM (4.0) en utilisant du code (voir ici et là).

Au jour d’aujourd’hui, il est plus qu’important d’avoir une visibilité sur les informations des comptes et contacts, non seulement au niveau des informations générales (nom, adresse, préférences, etc.) mais aussi au niveau des documents échangés.

Ainsi, Microsoft a finalement mis le paquet au niveau de l’intégration entre SharePoint et CRM : il est désormais possible de faire un projet SharePoint chez un client et de venir ajouter une option CRM et inversément; l’offre client change !

Dans ce post, je vais tenter d’expliquer comment fonctionne le connecteur SharePoint avec Microsoft CRM 2011 en expliquant comment l’installer et surtout comment l’utiliser.

Pré-requis

Windows Server 2008 64-bits
SharePoint 2010 (Foundation ou autre)
Microsoft CRM 2011

Installation

Télécharger le connecteur sur le site de Microsoft ici (CRM2011-SharePointList-ENU-amd64.exe)
Une fois téléchargé, extraire les fichiers à l’endroit que vous voulez sur votre serveur après avoir accepté les conditions d’utilisation:
Dès que les fichiers sont extraits, il est nécessaire de vérifier au niveau de SharePoint qu’il existe au moins une application Web pouvant être partagée avec CRM; pour cela, il est nécessaire de passer par la console d’administration centrale de SharePoint 2010
Cliquer sur ‘Gérer les applications Web’ et cliquer sur le bouton ‘Nouveau’ dans la barre de menu afin de créer un nouveau site SharePoint
Voici les différentes étapes à suivre pour la création d’un nouveau site SharePoint 2010
- Etant donné que nous sommes sur la même VM pour SharePoint 2010 et CRM 2011, nous allons configurer l’authentification en mode classique; de plus, il faut choisir un nom d’hôte afin que le port 80 puisse être réutilisée (ici j’ai choisi intranet.MONDOMAINE) :
- Le fournisseur d’authentification le plus simple à utiliser est le NTLM aussi j’ai choisi cette option et j’ai désactivé les connexions anonymes pour plus de sécurité :
- Un nouveau site SharePoint peut fonctionner sur un pool d’application existant mais il est toujours recommandé d’en créer un nouveau; pour ce faire, il faut prélablement vérifier qu’un compte de service existe dans l’Active Directory (utilisateur “classique”), en l’occurrence ici il s’agit du compte sp_user :
- Une fois le compte de service créé, il suffit de le sélectionner dans la liste des comptes de sécurité à associer au pool d’applications :
- Si le compte AD n’est pas présent dans la liste déroulante, il suffit de cliquer sur le lien “Enregistrer le nouveau compte géré” et remplir les paramètres suivants :
- Pour notre VM de test, nous n’allons pas créer de serveur de basculement ni utiliser de search server donc il suffit de laisser ces paramètres vide :
- La dernière étape du wizard est l’activation au programme d’amélioration Microsoft, auquel je n’ai pas souscrit :
- Un clic sur le bouton OK et le wizard déploie la nouvelle application (cela prend quelques minutes) :
- Une fois l’application déployée, vous recevez un chouette message tel que celui-ci !
Maintenant que nous avons une nouvelle application SharePoint, il est nécessaire de vérifier qu’elle fonctionne et surtout de finir le paramétrage afin de pouvoir l’intégrer avec CRM 2011 :
- Dans la liste, cliquer sur la nouvelle application précédemment créée
- Ensuite, cliquer sur le bouton “Paramètres généraux” et le sous-menu “Paramètres généraux” dans la barre de menu
- Il faut assouplir la gestion des fichiers par les navigateurs en choisissant l’option “Permissif”, puis cliquer sur OK
Une fois le paramétrage effectué, il faut créer un nouveau site dans l’application afin de pouvoir partager des informations
- A l’écran d’accueil de l’administration centrale de SharePoint, sélectionner l’option “Créer des collections de sites”
- Choisir la nouvelle application, lui donner un titre et créer un nouveau site à partir du modèle “Espace de travail du document”
- Ensuite, il est nécessaire de choisir le(s) administrateur(s) de la collection de sites (le secondaire n’est pas obligatoire)
Une fois le nouveau site créé, il suffit de le tester en se rendant à l’adresse précédemment créé (dans mon cas : intranet.crm.furnemont.eu)
Si vous ne parvenez pas à atteindre votre site Web, c’est à cause du “Loopback Check” de Windows 2008 : pour le désactiver, suivre la procédure décrite ici puis il faut redémarrer le serveur
Après redémarrage, voici la page d’acceuil de votre nouveau site :
Une fois votre site créé, il est nécessaire d’installer le connecteur CRM 2011 en vous rendant dans les “Actions du site” et après avoir cliqué sur le sous-menu “Paramètre du site”
Sous les paramètres du site, il faut choisir le déploiement d’une nouvelle solution sous l’option “Galeries”

Cliquer sur le bouton “Télécharger la solution” dans la barre de menu
La galerie de solutions vous propose de sélectionner un fichier à télécharger : il suffit de pointer vers le fichier crmlistcomponent.wsp (voir point n°2)

Normalement, il est possible d’activer le nouveau composant en cliquant sur le bouton “Activer” mais il est parfois possible que ce bouton soit grisé; pour l’activer, il faut suivre les étapes suivantes :

Depuis l’écran d’accueil de l’administration centrale de SharePoint, cliquer sur le bouton “Gérer les services sur le serveur”
Démarrer le service “Service de code en mode bac à sable Microsoft SharePoint Foundation”
Re-télécharger le composant CRM et, hop, le bouton “Activer” apparaît !

Et voilà, le composant CRM pour SharePoint 2010 est finalement installé !

Utilisation

Maintenant que le connecteur CRM pour SharePoint est installé, il est temps de l’utiliser !

Pour ce faire, il suffit de se connecter au CRM et de le paramétrer en suivant les étapes :

Se rendre dans les paramètres et choisir le sous-menu “Document Management” pour choisir l’option “Document Management Settings”
Sélectionner les entités pour lesquelles il faut activer la fonctionnalité de gestion des documents (dans notre cas, nous allons utiliser uniquement les contacts et les ‘assets’); il est également nécessaire de saisir l’adresse du site SharePoint qui sera utilisé pour la gestion des documents :
A l’étape suivante, choisir la structure des dossiers (dans mon cas, je choisis une structure basée sur les contacts afin d’organiser au mieux les documents) :
La création de la structure des documents peut prendre un certain temps en fonction du nombre d’entité sélectionnée :
Succès ! Cliquer sur “Finish” pour quitter le wizard
Pour tester la fonctionnalité de gestion des documents, il suffit dès lors d’ajouter un document quelconque (PDF, XLS, DOC, etc.) à un contact

Cliquer sur le menu “Documents” et cliquer sur le bouton “Add Location” dans la barre de menu pour créer un nouveau répertoire dans SharePoint :
Donner un nom à la location et choisir l’option de création d’une nouvelle location sur SharePoint :
Un nouveau répertoire sera créé sur le SharePoint :
Vous pouvez désormais ajouter, supprimer et même éditer des documents directement depuis Microsoft CRM !

Une fois un document ajouté dans Microsoft CRM, il est possible de le voir dans le SharePoint et inversément !

CRM 2011: New update (KB2409294) for beta available!

BugsOli — Fri, 08 Oct 2010 09:21:30 +0000

New update for Microsoft CRM 2011 beta is available through Windows Update

Link: http://blogs.msdn.com/b/crm/archive/2010/09/29/microsoft-dynamics-crm-2011-client-beta-updates-available-on-microsoft-update.aspx#comments

CRM 2011: A first look at the field security

BugsOli — Thu, 07 Oct 2010 14:29:47 +0000

A nice feature that has been added to Microsoft CRM 2011 is the field security.

I’ll try to explain it with an example where a customer wanted to store the contact’s password in Microsoft CRM for easier maintenance (RH department).

Obviously, the passwords must be hidden for certain CRM users but not for the IT guys (for example): in Microsoft CRM 4.0 you could achieve this result by retrieving the connected user’s security role and then show/hide the password field on the form.

Now, with CRM 2011, you do not have to deal with JavaScript anymore: you just need to create a security profile and add the fields you want to secure!

Ok, time for the example:

Create a new field called ‘Contact password’ and enable the ‘Field Security’ option
Add the new field to the contact form by drag & droping it; you’ll see a small key next to the label meaning that the field is ‘secured’
Publish your (really simple) customization and head down to the Microsoft CRM administration section to edit the ‘Field Security Profiles’
On a clean install, Microsoft CRM creates a default security profile for the system administrator security privilege (which can not be modified!); therefore, we are going to create a new profile for the end-users and for the IT guys
When you open the new security profile, you will find all the secured fields in your current solution under the ‘Field Permissions’ left menu
To modify the permissions for the field, click on the ‘Edit’ button (double-click not working?) and select the appropriate permissions you want to enable/disable
Once your security profile is done, you must link it to the users
If everything is all set, your users should not be able to see anything!

Before

After

Cool

CRM 2011: Finally a way to alter the ‘queue items’ view!

BugsOli — Thu, 07 Oct 2010 13:21:28 +0000

Yes, now it’s nearly official: you CAN alter the queue items views and set the columns you want to display!

Before:

After:

This was a long awaited need for my clients, thanks Microsoft!

Hommage à la politique Belge !

BugsOli — Wed, 06 Oct 2010 12:17:20 +0000

Ce n’est pas de moi mais de Thomas Gunzig sur La Première (copyright à qui de droit)…messieurs les pseudo-ministres, prenez-en un peu de la graine !

Samedi dernier, Thomas Gunzig a offert un véritable bijou aux auditeurs de la Semaine Infernale, diffusée à 11 h sur La Première. Voici le texte intégral. Régalez-vous !

Bande de cons !

Pas vous, cher public !

Les autres, les formateurs, informateurs, explorateurs, chefs de groupe, présidents de parti flamand, présidents de parti francophone, seconds couteaux, troisièmes couteaux, de gauche, de droite, les cathos, les écolos, les franc-maçons, les libéraux…

Bande de cons de Flandre

Bande de cons de Bruxelles

Bande de cons de Wallonie.

D’abord à tous ceux qui croient avoir gagné les élections d’il y a 5 mois.

A tous ceux qui avaient un grand sourire

A tous ceux qui avaient les bras en l’air.

Le temps est venu de vous avouer quelque chose :

Les gens n’ont pas voté pour vous parce qu’ils vous aimaient.

Les gens ont voté pour vous parce qu’ils étaient obligés.

A la veille du onze juin : dans les rues, les maisons, les bureaux, les gens hochaient la tête et se demandaient vraiment qui ils allaient pouvoir choisir parmi ce catalogue de nuls, de klets, de nouilles, d’opportunistes agressifs, de carriéristes sans charisme, de mal fringués, de gros types à l’élocution problématique, de petit nerveux en pleine tendinite de l’égo, de semi-hystériques, de semi-mafieux, de cynique, de je-m’en-foutiste, de ratés, de tout le reste, de fils à papa, d’experts comptables en décrochage professionnel, d’entrepreneurs en faillite frauduleuse, de sinistres, de pas lavés, de faux gentils, de vrais méchants…

Les Leterme, De Krem, Reynders, Milquet, Michel, De Wever, Maingain, Wattelet, Bacquelaine… Cette morbide collection de névroses qui nous gouvernent avec leurs troubles anxieux, leur troubles dissociatifs, leur troubles psycho-sexuels, leurs troubles obsessionnels compulsifs.

Et en plus, ils sont tous… si moches…

Cette élection, à tout le monde, ça a un peu fait l’impression d’un de ces mariages forcé que l’on organise dans des pays très loin d’ici.

C’est comme si on avait été une jeune fille devant choisir entre le vieux marchand qui pète au lit ou l’arrière-cousin qui ne se brosse pas les dents.

Bande de cons.

Vous n’avez rien gagné du tout.

Si c’était possible, on reprendrait nos voix et on ne les donnerait qu’après les négociations, à ceux qui auraient su être un peu intelligents, un peu sobres, un peu humains.

Mais non. Donner c’est donner, reprendre c’est voler.

Vous aviez un chouette petit pays, pas très grand mais bien équipé de voisins plutôt sympas bien situé avec la mer, avec la forêt, avec pas trop de charges.

Vous aviez une chouette petite population, pas parfaite parfaite.

Mais en gros, ce n’était pas des talibans non plus, c’était pas des Contras, c’était pas des Tigres Tamouls : une petite population de fabricant de pralines, des marchand de kayaks, des chanteurs à texte, des comiques parfois drôles, des stylistes un peu punk, des postiers plutôt polis, des sportifs en minijupe, des flics à moustache, des tas de gens prêts à travailler plus, à gagner toujours moins et à ne pas dire grand-chose.

Une petite population qui mélange le goût des mandarines à celui des spéculoos.

Une petite population qui n’a rien contre l’Eurovision ni les horodateurs.

Une petite population qui rend visite à ses grands-parents le dimanche pour boire un café après le chicon gratin.

Une petite population de buveurs de bière et de joueurs de kicker.

Une petite population qui emmène ses enfants à Plankendael au printemps et à Paradisio en hiver… Comme ça, sans ennuyer le monde, en VW Touran.

Une petite population prévoyante qui a quelques euros sur un compte-épargne et une concession au cimetière.

Une petite population qui est plutôt toujours d’accord et en gros une petite population qui ne veut pas d’histoire.

Et vous,

bande de cons,

tout ce que vous trouvez à faire, ce sont ces petites réunions où l’on tourne encore plus en rond que sur un circuit Marklin, ce sont ces petits comités aussi stériles qu’un champs de patates à Tchernobyl, ce sont ces petites réactions à chaud qui me rappellent les crises de mon chat, quand il n’aime pas la marque de ses croquettes, ce sont ces airs de petits tribuns en solde, ce sont ces grands chevaux sur lesquels vous montez et qui seront toujours comme ces petits poneys tristes de la foire du Midi.

Tout ce que vous trouvez à faire, c’est de vous tirer dans les pattes pour gagner une floche qui vous donnera droit à un tour gratuit sur ce manège sinistre que vous appelez "politique".

Bande de nuls.

Alors moi,

J’ai eu une idée, une grève, une vraie grève, une bonne grève, une grève de tout le monde tant que la politique Belge ressemblera à une conserve de rollmops :

Les enfants n’iront plus à l’école, les femmes enceintes n’accoucheront pas, les déménageurs ne déménageront pas. Navetteurs, ne navettez plus, Alcooliques, n’alcoolisez plus, chauffeurs, ne chauffez plus, pilote, mécanicien, traiteur, boucher, pêcheur, éboueur, esthéticienne, taxidermiste, stripteaseuse, scaphandrier, géomètres expert, fleuriste, trader, opticien, huissier, substitut, gourou, préfet, trésorier, banquier, infographiste, ajusteur, analyste programmeur, technicien, hotline, proxénète, dealer, animateur, orthodontiste, urologue, animateur socioculturel, fossoyeur…

Et tous les autres…

Total Stand By ! On arrête tout…

Et vous verrez que dans trois jours, ils feront moins les malins.

CRM 2011: New ‘helpers’ for system customizers! (Part 1)

BugsOli — Thu, 16 Sep 2010 13:52:29 +0000

PREVIEW – Here is an overview of the new ‘helpers’ customizers have at their disposal while customizing Microsoft CRM 2011:

Solutions

Upon installing Microsoft CRM, a new default solution is created that reflects the ‘default’ state of the system; this default state contains all the entities and components that are installed with the system
A solution can be seen as a ‘vertical solution’ created with Microsoft CRM; for example: you may need to create a new solution for customer Y, based on an existing solution created for customer X
A solution groups a series of customization
Solutions can be imported/exported
New solutions are empty, you just need to add the entities & components you want to deploy!
Solutions are versioned using a ‘version’ field, meaning you can have multiple versions of your customizations resulting in ease of deployment and testing
A solution is based on a publisher, which means that each publisher can now be identified by a contact form and can have its own customization prefix
The publishers can sell their solutions through the new “Marketplace”, which is available through Microsoft CRM

Attributes = Fields

This may not seem quite interesting but it looks like someone at Microsoft thought that it would be more understandable for everyone to rename ‘Attributes’ to ‘Fields’ for the entities customization, not sure why…
A new field is available: lookup, which lets you decide to which entity you want to relate (account, contact, etc.); this field is similar to the attribute created when using a N-1 relationship in Microsoft CRM 4.0

Entities

New entities can now be defined as being a new type of activities; for example: visits, meeting minutes, etc.
New entities can now be sent to queues
New entities can be set to send emails (not sure of that one, I still have to test it)
New entities can be audited based on the new auditing feature (more on that later)
New entities can be set to use the new ‘Document Management’ feature which is tightly coupled with SharePoint 2010 (more on that later as well)

This is a first overview of the new functionalities (or helpers) that are available for system customizers, I’ll try to go more into details of these new cool stuffs!

CRM 2011: Installation issues and way to resolve it

BugsOli — Wed, 15 Sep 2010 14:22:32 +0000

Some issues that can arise during the ‘System Checks’ while installing Microsoft CRM 2011…

Issues

The SPN for the ASP.NET App Pool account has to be verified
The SPN for the CRM Deployment Web Service App Pool account has to be verified
The IIS NTAuthenticationProviders must be ‘Negotiate,NTLM’

For information, this are the messages I get on a Windows Server 2008 Std VM.

How to resolve these issues?

Issue #1:

This issue arises when you specify a domain account for the ASP.NET service used by the CRM server instead of the ‘Network Service’ account. To resolve this issue, follow the steps below:

Use the SETSPN command to create the ‘Service Principal Name’ for the ASP.NET domain account you created (the SETSPN is part of the ‘Windows Support Tools’ which is part of the install of Windows Server 2008):
- Open the command prompt with administrator privileges
- Type the following command: setspn –A HTTP/servername:port domain\user (where servername is your CRM server name, port is the chosen Web Site port, domain\user is the domain account used for the CRM services)
- Type the following command for the FQDN name: setspn –A HTTP/servername.company.com:port domain\user
Open ‘Active Directory Users and Computers’ and enable the ‘Trust this user for delegation to any service (Kerberos only)’ for the selected domain account
Add the domain account to the IIS_IUSRS group

Issue #2:

(See step as issue #1 since it is the same account)

Issue #3:

For CRM to work on our server, we need to enable both Kerberos and NTLM by following these steps:

Open a command prompt with administrator privileges
Go to the C:\inetpub\AdminScripts folder (according C:\ is the drive where the inetpub folder is installed)
Verify the Web Site ID under IIS (here I’m installing CRM under the Default Web Site, which is ID 1):
Verify that the ‘NTAuthenticationProviders’ hasn’t changed by using this command: cscript adsutil.vbs get w3svc/ID of your web site/NTAuthenticationProviders; if the Web Site is dealing with NTLM only, you should get something like this:
To set the value to ‘Negotiate,NTLM’, use this command: cscript adsutil.vbs set w3svc/ID of your web site/NTAuthenticationProviders “Negotiate,NTLM”
Verify again that your web site ID is set to the correct authentication provider by using the command at step 4, then reset IIS by using the iisreset command

NOTE: I have an issue here since the installation wizard does not seem to ‘see’ that my default web site is using Kerberos and NTLM for authentication. The only thing I’ve found so far is to let the wizard create a new Web Site on another port (see: http://social.microsoft.com/Forums/en/crm2011beta/thread/288ef9ce-42fc-46a4-b24b-b43519fec0f6)

Deploy plugins in an IFD+OnPremise environment

BugsOli — Tue, 14 Sep 2010 08:19:52 +0000

If you are stuck with the Plugin Registration Tool (PRT) in an IFD environment, one test to make is this one:

Compile the Visual Studio solution using VS 2008 or 2010
Deploy the debug or release files PRT on the server, wherever you want, in its own folder
On the server, launch the PluginRegistration.exe file with administrator privileges
When you configure a CRM environment for IFD, it is recommended to configure it with IFD + OnPremise, meaning that on the server, you can access (theoretically ) the CRM by using the local address (http://localhost); therefore, if you connect to the server with a login that has access to the CRM with administrator privileges, you don’t need to enter the credentials in the PRT connection:
This way, the PRT will use the current user’s credentials, using AD authentication, which will work; you will therefore be able to deploy your plugins by using the following addresses in the “Organization URLs” fields (you need to ensure that these URLs are the same for each OU in your CRM):

Woohoo, now I can deploy my plugins in our secured IFD environment!

What’s new in Microsoft Dynamics CRM 2011?

BugsOli — Sun, 12 Sep 2010 09:47:44 +0000

A good read for everyone, not only developers or customizers: http://rc.crm.dynamics.com/rc/2011/en-us/on-prem/5.0/whatsNewCRM5.aspx

How-to series: Generate auto-numbers on custom entities (part 1)

BugsOli — Fri, 10 Sep 2010 09:16:48 +0000

Ok, in this series, I will try to explain how to generate auto-numbers on custom entities based on the user’s preferences (length of the auto-number, prefix, suffix, increment value, etc.)

This kind of customization is based on the plug-in created and sold by CRM Innovation.

I am not trying to copy their work, and therefore my plug-in is not as complete as theirs. Meaning…. if you want more complete functionalities, don’t ask me but BUY their plug-in!

The approach I will be using is very simple:

Use an organization-owned entity for the users to configure the auto-numbering features
Use a plug-in to generate an auto-number based on the user’s preferences

NB: I am not saying this is the best approach to this kind of feature but it shows how to use various techniques (JavaScript, C#) to customize Microsoft CRM. In this first series, I will describe the first step and explain the JavaScript used behind the customization.

Let’s get to work!

Create the organization-owned “Auto Number” entity

Go to “Settings / Customizations” and create a new entity called ‘Auto Number’ (or whatever your language is, in French it would be ‘Numéro auto’)
Instead of using the default ‘Name’ field as-is, rename it to ‘Entity Name (schema)’ and change its schema name to ‘New_Entityname’; this field is going to store the selected entity schema name (physical name)
Click the “Save” button to generate the new custom entity

Now we are going to create a couple of custom attributes that will be used to store various information:

Name	Used for	Type	Length
Attribute Name	Schema name of the attribute that will store the generated number	varchar	100
Attribute Display	Display name of the attribute that will store the generated number	varchar	100
Entity Display	Display name of the entity that will use the generated number	varchar	100
Entity Type Code	The entity type code	varchar	100
Length	The length of the generated number	int
Increment	The increment value for the generated number	int
Prefix	The prefix to use during the number generation (optional)	varchar	100
Suffix	The suffix to use during the number generation (optional)	varchar	100
Example	An example of generated number	varchar	100

When all the attributes have been created, this is the looks of the default form:
The purpose of this customization is to render the first two attributes (‘Entité’ [Entity] and ‘Attribut’ [Attribute]) as dynamic drop down lists: the first will allow the user to select the entity and the second will allow the user to select the attribute that will store the automatic identification number

The code that deals with the dynamic drop-down list comes from Thuta’s CRM blog and is available below with some explanations:

crmForm.all.xrm_entitynamedisplay.ForceSubmit = true;
crmForm.all.xrm_attributenamedisplay.ForceSubmit = true;
crmForm.all.xrm_numberingexample.ForceSubmit = true;

// Function that will load the attribute drop down list and store the entity's drop down list selected value
entityOnChange = function () {
    crmForm.all.xrm_entityname.DataValue = document.getElementById('xrm_entitynamedisplay').options[document.getElementById('xrm_entitynamedisplay').selectedIndex].getAttribute('schemaName');
    crmForm.all.xrm_entitytypecode.DataValue = document.getElementById('xrm_entitynamedisplay').options[document.getElementById('xrm_entitynamedisplay').selectedIndex].getAttribute('entitytypeid');

    var schemaName = document.getElementById('xrm_entitynamedisplay').options[document.getElementById('xrm_entitynamedisplay').selectedIndex].getAttribute('schemaName');
    var request = "" +
                  "" +
                  GenerateAuthenticationHeader() +
                  " " +
                  "     " +
                  "         " +
                  "             00000000-0000-0000-0000-000000000000" +
                  "             IncludeAttributes" +
                  "             " + schemaName + "" +
                  "             true" +
                  "         " +
                  "     " +
                  " " +
                  "";

    var xmlHttpRequest = new ActiveXObject("Msxml2.XMLHTTP");
    xmlHttpRequest.Open("POST", "/mscrmservices/2007/MetadataService.asmx", false);
    xmlHttpRequest.setRequestHeader("SOAPAction", "http://schemas.microsoft.com/crm/2007/WebServices/Execute");
    xmlHttpRequest.setRequestHeader("Content-Type", "text/xml; charset=utf-8");
    xmlHttpRequest.setRequestHeader("Content-Length", request.length);
    xmlHttpRequest.send(request);

    var result = xmlHttpRequest.responseXML;
    var schemaNames = result.selectNodes("//EntityMetadata/Attributes/Attribute");

    ConvertAttributeToPicklist('xrm_attributenamedisplay', schemaNames);
}
// Function that will store the attribute's drop down list selected value
attribOnChange = function () {
    crmForm.all.xrm_attributename.DataValue = document.getElementById('xrm_attributenamedisplay').options[document.getElementById('xrm_attributenamedisplay').selectedIndex].getAttribute('schemaName');
}
// Function that converts the entity textbox to a drop down list
function ConvertEntityToPicklist(fieldName, dataItems) {
    var defaultValue = crmForm.all[fieldName].DataValue;
    var table = crmForm.all[fieldName + "_d"];
    var select = "";
    table.innerHTML = select;

    entityOnChange();
}
// Function that converts the attribute textbox to a drop down list
function ConvertAttributeToPicklist(fieldName, dataItems) {
    var defaultValue = crmForm.ObjectId != null ? crmForm.all[fieldName].DataValue : null;
    var table = crmForm.all[fieldName + "_d"];
    var select = "";
    table.innerHTML = select;

    attribOnChange();
}
// Entity retrieval request: used to retrive the published entities
var request = "" +
              "" +
              GenerateAuthenticationHeader() +
              "  " +
              "    " +
              "      " +
              "        true" +
              "        EntitiesOnly" +
              "      " +
              "    " +
              "  " +
              "";

var xmlHttpRequest = new ActiveXObject("Msxml2.XMLHTTP");
xmlHttpRequest.Open("POST", "/mscrmservices/2007/MetadataService.asmx", false);
xmlHttpRequest.setRequestHeader("SOAPAction", "http://schemas.microsoft.com/crm/2007/WebServices/Execute");
xmlHttpRequest.setRequestHeader("Content-Type", "text/xml; charset=utf-8");
xmlHttpRequest.setRequestHeader("Content-Length", request.length);
xmlHttpRequest.send(request);

var result = xmlHttpRequest.responseXML;
var schemaNames = result.selectNodes("//CrmMetadata/CrmMetadata");

ConvertEntityToPicklist('xrm_entitynamedisplay', schemaNames);

The final result should look like this once a new record is created:

This first post of the series is to lay the groundwork of the following posts, which will deal with creating a plugin to generate a random number based on the information stored in the autonumber record.

Feel free to contact me for any question…

Microsoft Dynamics CRM 2011 Beta Signup

BugsOli — Fri, 10 Sep 2010 06:23:05 +0000

And there it is, the beta signup for Microsoft Dynamics CRM 2011 is finally available!

More info here: https://offers.crmchoice.com/CRM2011Beta-Signup/

A good read on 1 to 1 marketing

BugsOli — Sun, 05 Sep 2010 08:29:23 +0000

I’ve just rediscovered this book, which was in my book library: http://www.amazon.com/gp/aw/d.html/ref=redir_mdp_mobile/186-8161065-2842614?a=038549369X
If you can get a copy, it’s worth a reading!

The Boss is back!

BugsOli — Fri, 13 Aug 2010 17:02:49 +0000

Oh yeah baby, too bad for the taxes in Belgium

Tip: Use that default ‘name’ field in custom entities!

BugsOli — Fri, 13 Aug 2010 11:00:00 +0000

Sometimes it is useful, sometimes it is not…when you create a new custom entity in Microsoft CRM, there is always one default field called ‘name’ which is a varchar field.

One will say that you can always make it ‘non-mandatory’ and remove it from the form, but the problem lies in the search view, where you will not be able to remove it!

So here is a quick tip for those of you who want to keep this field in the default views but not on the form, by hiding it; the idea is very simple: suppose you have a picklist on the form, you can always retrieve it’s text to fill the ‘name’ field, therefore the text will be displayed in all the default views!

Here is an explanation of the example below: the new entity is used to track all the contacts’ income revenues, with the amount (money field) and the type of revenue (picklist).

Create a new entity called ‘Income revenues’, with ‘User’ ownership
- Modify the default attribute label from ‘Name’ to ‘Revenue type’
- Change its required level to ‘No constraint’
Save the new entity
Create a new attribute
- Call it ‘Revenue type’
- Choose the picklist field type and add the appropriate values
- Change its required level to either ‘Required’ or ‘Recommended’

On the default form:

Place the revenue type textbox next to the revenue type picklist
Disable the revenue type textbox
In the form properties, place this code in the OnLoad event

/*hide field only*/
crmForm.all.new_revenuetypetextfield.style.display = 'none';

In the picklist properties, place this code in the OnChange event

if (crmForm.all.new_revenuetypelist != null)
{
   crmForm.all.new_revenuetypetextfield.DataValue = 
        crmForm.all.new_revenuetypelist.SelectedText;
}
else
{
   crmForm.all.new_revenuetypetextfield.DataValue = "";
}

crmForm.all.new_revenuetypetextfield.ForceSubmit = true;

Save & test your form before publishing… if everything looks good, you’re all set!

Problem with Microsoft SQL Server Full-Text Search

BugsOli — Wed, 28 Jul 2010 05:00:00 +0000

If, by any means, you have upgraded your Microsoft SQL Server 2005 to 2008, you’ve probably seen this: you want to install a brand new CRM 4 on your server and, just before the end of the wizard, the verification process hangs on the Microsoft SQL Server node with the following message:

“The Full-Text Search service msftesql is not started on the SQL Server”

This is because the Full-Text Search service is called MSSQLFDLauncher in SQL Server 2008, and this is a known bug that has the following workaround:

Connect to the SQL Server with the appropriate privileges and edit the registry with the ‘REGEDIT’ command
Go to HKEY_LOCAL_MACHINE|SYSTEM|CurrentControlSet|Services
Find the node “MSSQLFDLauncher” (with “$YOUR_INSTANCE” if you have more than one SQL Server instance)
Rename the node “msftesql” (+ “$YOUR_INSTANCE” if you have more than one SQL Server instance)
Restart the SQL Server computer!
On the next restart, verify that the Full-Text Search service is correctly started
Install CRM normally
Once CRM is installed, rename the service “msftesql” to “MSSQLFDLauncher”
Restart the SQL Server computer
On the next restart, verify that the Full-Text Search service is correctly started

Once all these steps are done, you’re all set!

Adapted from (in French): http://blogs.coforcert.com/dntamack/Lists/Billets/Post.aspx?ID=56