CRM Entropy - A Microsoft Dynamics CRM Blog

Love Your UI: Icons for CRM

2013-04-11T22:11:00.001-06:00

I’m going to make an unusual break from my normal kind of post to talk about customizing Dynamics CRM with paid utilities, and specifically about sourcing professional-appearing icons for CRM’s UI. The topic doesn’t occur very often in the forums, and generally the advice has been to search Google.

I can’t discount that method, as I’ve used it in the past to locate royalty-free, attribution-free, and open-licensed sets of icons. While the quality of many sets are great, the bulk of files are cumbersome to manage, and customizing them requires a significant investment of time and energy. Looking into “modern” Microsoft interfaces with flattened icons, there are very few free options that match this style and look good doing it. (However, if you’re looking for a good compilation of options, look no further than Chris Coyier.)

What an illuminating experience working with Axialis IconWorkshop has been! I inquired about the product about 6 months back, and was very graciously granted a gratis license to their full “Pure Flat” icon sets. I’ve had a handful of opportunities to use them, since, in conjunction with the IconWorkshop to author and customize the results. Here’s a breakdown comparison of my previous “Google discovery” experience, and using a professional tool:

Locating an Icon

Using Google:

Generally, I don’t use Google to find a single icon. There is a significant amount of danger for violating copyright and intellectual-property rights. Icon authors are hard working people too, and icon theft is one of the unspoken undercurrents of web applications, due in part to lazy people like I used to be.

So, the last few times that I used Google, I went straight for “open-source, royalty-free, copyright-free” icon libraries. There are many, but obtaining them from reputable sites can take some work. Then, they are bundled into zip files (typically), and generally contain thousands or tens-of-thousands of icon files. Filenames are the primary descriptors to search on, so if nothing turns up for a basic term, trying variations… or at worst, scanning through thumbnails, are best bets.

Experience Ratings (1 best – 5 worst)
Time Consumption	4
Skill Required	2
Efficiency of Desired Outcome	5

Finding icons that are legal to use can be a struggle, and sorting and managing the various packing and naming conventions often leave much to be desired when it comes to cataloging or describing collections.

Using IconWorkshop:

Searching through icons that are imported into Axialis Librarian is a fast process, and only made faster, I think, due to indexing of the files. This indexing extends to metadata keywords, but unfortunately the Axialis icon sets don’t come preloaded with any (at least not by my sampling). Adding your own keywords takes time, but can certainly help improve it. For the basis of rating this experience, though, I will not consider it an advantage.

When it comes to the image you want to use, Axialis has many libraries with an impressive number of icons, but they don’t yet have a “full set” purchase experience—unless you use their in-site contact form to inquire about it. Their prices are fair for long-term use, and more importantly, they include “base” icon images and “overlay” images that can be easily combined to create new permutations easily. Searches will generally turn up both, however variety is going to cost you. That said, it’s generally easy to figure out which set likely contains the candidate icon you want.

Thankfully, you can import assets from other libraries (especially any “free” sets you may already have), and the IconWorkshop can be useful for searching those, as well. Depending on how you look at it, Axialis icon sets are not given first-class status over other libraries--and that’s either noble, or a lost opportunity.

Experience Ratings (1 best – 5 worst)
Time Consumption	4
Skill Required	2
Efficiency of Desired Outcome	4

While IconWorkshop helps with searching and organizing, Axialis’ icon sets are hamstringed by lack of useful keyword metadata accompanying their files. They could have taken a “2” or “1” rating in the efficiency department, and probably lower in other areas. However, the improved organization and the search capabilities maintain a slight edge over searching through the file system with something like Agent Ransack.

Icon Set Quality

Using Google:

“Free” icon sets come in varying styles and quality, so it’s hard to judge them collectively. Often, it’s difficult to find a icon that comes in several native sizes. Most “free” sets offer one or two sizes, and are often capped at 32x32, so scaling up or down impacts quality by producing pixelated or blurry results, respectively. Within Dynamics CRM, 32x32 and 16x16 are used throughout the ribbons, grids, and menus; however, custom controls and pages can benefit from larger or smaller icons. I have often found myself repeating the searching phase to find several icons that closely match each other in the various sizes.

File formats are another issue, although generally minor given a good image editor. Sets generally come in one or two formats, and they may or may not implement transparency. It becomes important to check and convert, where necessary, to meet your needs. (JPEG and GIF to PNG, for example. Maybe that’s only my need, so your mileage may vary.)

Experience Ratings (1 best – 5 worst)
Time Consumption	3
Skill Required	3
Efficiency of Desired Outcome	3

Across the board, for most cases, if you find an icon you want, and are either lucky enough to have it looking good in every size you need it, or content with visual scaling effects, this is not a bad option. In my experience, however, it tends to be fairly mediocre.

Using Axialis Icons:

The best thing I can say: 256x256 all the way down to 16x16 of hand-crafted icon goodness. Each set comes in ICO, BMP, and PNG formats, which covers the Web and Windows spectrum nicely. On top of this, overlays are separated into their own files with transparency masks as companions. These only factor into the ratings of this category insofar as they also come in native resolutions that are clean, well-scaled, and visually appealing at all sizes; and also that Axialis has pre-combined many “obvious” overlay and base image permutations.

Experience Ratings (1 best – 5 worst)
Time Consumption	1
Skill Required	1
Efficiency of Desired Outcome	2

Having pre-built ranges and formats adds a tremendous amount of space to the icon libraries, but the convenience of always having a size and format that works without additional thought is hard to trade away after experiencing it. The quality and appearance of each image is strikingly good. However, I do wish the files had an SVG or font-based format—I haven’t needed those for CRM yet, so that doesn’t affect my rating.

Customizing an Icon

Using GIMP:

I’m not going to throw Google under the bus in the image editing department. There are lots of icon editors available, and image manipulation suites. My personal favorite is GIMP. It has many of the features I need for advanced image editing, and it’s open source. After 10 years, I’m fairly comfortable performing a wide variety of tasks.

Unfortunately, small images don’t feel comfortable in suites meant for larger ones, but it works. Layers are especially handy for putting together transparency masks and overlays… but overlays are uncommon to find in free icon sets, so most overlays I’ve used were custom produced, adding a lot of time for clean results.

GIMP’s main advantage is its tremendous image editing capabilities—professional caliber features. However, its learning curve is equally tremendous, and I never quite found the time to automate some repeated tasks. It does, however, produce superior quality.

Experience Ratings (1 best – 5 worst)
Time Consumption	5
Skill Required	4
Efficiency of Desired Outcome	4

Unfortunately, GIMP really just helps me “limp” with free icons, helping me cleanup scaling quirks, add custom overlays, or modify palettes. The time investment is not insignificant, though. I just didn’t realize it could be so much better.

Using IconWorkshop and Axialis Icons:

IconWorkshop has a feature that will compile and combine in all permutations, the overlays and base images you specify, to automatically produce an array of sizes and decorations without additional effort. This is one of the faster ways to simply knock-out the 32x32 and 16x16 sizes I desire for CRM 2011.

The image editing capabilities of IconWorkshop are lackluster, and just advanced enough to satisfy the needs of basic manipulation. Thankfully, I find myself working within their base+overlay formulas well enough that I haven’t had to step outside of IconWorkshop for anything more advanced. It’s a borderline comfort, but it fits well for the purpose.

It’s obvious that combining images is IconWorkshop’s strong suit, and that’s why Axialis’ icon sets are amazing within it. The sets can stand alone, and IconWorkshop can do its deal with any source, but together they offer a purpose-built system that streamlines the whole process of tailoring icons—if you require it. Again, Axialis has taken the liberty of combining common base and overlay permutations and included them in their large icon set files, so that reduces the need for customizing in the first place (or simplifies recombinant decoration).

Experience Ratings (1 best – 5 worst)
Time Consumption	2
Skill Required	3
Efficiency of Desired Outcome	2

By using a simpler tool and products that are built to work with it in an optimized fashion, I have shaved a lot of time from the process of building a slick-looking, custom UI within Dynamics CRM.

Average Scores:

	“Free”	Axialis
Time Consumption	4	2.33
Skill Required	3	2
Efficiency of Desired Outcome	4	2.66

I’m starting to understand the adage: “It’s not nobler to do by hand, what can be better and faster done with a tool, when lunch is on the line.”

High Availability Workflows

2013-02-28T20:04:00.001-07:00

Since joining Avtex, I have been able to expand my horizons and gain exposure to customers with unique needs. I try, as hard as possible, to incorporate or build on top of CRM’s out-of-box experience, and refrain from writing code I don’t have to. To that end, I’d like to share a simple solution to making Workflows trigger while they’re deactivated for updating.

It’s no secret that business processes change on-the-fly. Implementing changes to active Workflows can be tricky, from an availability standpoint. Most companies adopt a routine of modifying Workflow designs afterhours, or with operations momentarily held until the modification is complete. This presents a dynamic and potentially troubling hurdle for “always on” companies.

Because Workflows are listeners to CRM operations, rather than direct participants, any downtime with a particular Workflow means that it’s no longer listening to events. This allows for the potential of unapplied business logic, and can be very difficult to diagnose or troubleshoot.

Though the space of downtime can be reduced to mere minutes—by developing in an alternate environment and shipping the updated Workflow in as a Solution—the window of opportunity for actions to tip-toe past a disabled Workflow still exists. For some companies, this is simply unacceptable.

However, you can use the out-of-box Workflow abilities to create high availability Workflows that can be taken offline, modified, and then reactivated, all without missing a single event that was triggered while the Workflow was offline. This works by splitting the Workflow’s functionality into two separate Worfklows:

An event listening “Dispatcher” Workflow; and
A “Business Logic” application Workflow

By isolating the business logic into a “child Workflow” which is called by its corresponding Dispatcher, one can take the Business Logic offline, while leaving the Dispatcher functional. This allows the configured triggers of the Dispatcher to operate continuously, though the step which calls the Business Logic counterpart will fail during the downtime.

Though the Dispatcher jobs enter a “Waiting” state, they will be easy to identify (especially if you allow them to delete themselves when they’re successful) in order to resume. This behavior is generally sufficient enough to allow a wider window for Business Logic adjustment, without requiring additional intervention to process the new logic against records that are awaiting to execute the new logic. That brings up another excellent advantage to this pattern:

With Dispatchers, you can immediately terminate existing logic and immediately register all further processing against future logic.

Note: You cannot retarget a different workflow, as that would require taking the Dispatcher offline—which defeats the purpose. The System Job acts as a cloned instance of a Workflow, so the Dispatcher will always target a specific, business-logic Workflow. You can approximate a retargeting scenario with Dispatcher juggling, but it would involve trigger overlapping mitigation.

Here’s an example scenario that uses a Dispatcher to update an Account using the Dispatcher and Business Logic pattern:

First, create the Business Logic workflow, and for “Available to Run” select “As a child process”. Remove all selections from “Options for Automatic Processes”.

Then, create the Dispatcher workflow with the “Options for Automatic Processes” setting you desire, and configure it to call your Business Logic workflow.

You may now activate both. Your Dispatcher is diligently watching the events, and the Business Logic is processing your rules.

Here is what happens when you deactivate the Business Logic workflow to make modifications:

My example uses a Dispatcher that listens to Account creation, so when I create a new account, here is what I see in the “Workflows” associated to it:

As you can see, the Dispatcher caught the event, and then entered a “Waiting” state. If we examine the job, we can see the error:

It failed on the step that calls my Business Logic. This job will remain in this state until I resume it. After completing my modifications to Business Logic, I’ll reactivate it. Then, I need to identify all my outstanding Dispatcher jobs:

Then, resume them with the confidence that I have missed no important triggers while my Business Logic was momentarily offline:

That said, I always perform a quick validation, just to be sure:

A Potent Cocktail: ExecuteMultiple and LINQ

2013-02-11T16:53:00.001-07:00

I love it when technologies using the same framework marry together like peaches and cream. Today, I want to cover the intersection of CRM 2011’s new ExecuteMultiple capabilities and my love of LINQ. Just to be clear, I’m not talking about using LINQ provider for CRM, though you can certainly use that to produce a collection of records upon which to perform some operation in bulk.

Instead, I’d like to show you an elegant snippet of code that demonstrates the power of ExecuteMultiple with the cleanliness of succinct LINQ. Given an EntityCollection —someRecords— suppose that you need to increment some integer —my_integer— on each of the contained records. For the purposes of this example, I’ll be using the late-bound Entity type.

// Start our request with some basic initialization
ExecuteMultipleRequest bulkIncrementRequest = new ExecuteMultipleRequest()
{
    Settings = new ExecuteMultipleSettings()
    {
        ContinueOnError = true,
        ReturnResponses = true
    },
    Requests = new OrganizationRequestCollection()
}

// Compile the collection of requests
bulkIncrementRequest.Requests.AddRange( from record in someRecords.Entities
                                        where record.Contains( "my_integer" )
                                        select new UpdateRequest() 
                                        { 
                                            Entity = new Entity( "someRecord" )
                                            {
                                                Id = record.Id,
                                                Attributes = {
                                                    new KeyValuePair( "my_integer",
                                                        ( ( Int32 ) record[ "my_integer" ] ) + 1 )
                                                }
                                            }
                                        } );

// Excute the requests
ExecuteMultipleResponse bulkIncrementResponse = ( ExecuteMultipleResponse ) service.Execute( bulkIncrementRequest );

// Check "IsFaulted" to determine if any of the submitted requests failed
if ( bulkIncrementResponse.IsFaulted )
{
    Int32 errorCount = ( from incrementResponse in bulkIncrementResponse.Responses
                         where incrementResponse.Fault != null
                         select incrementResponse ).Count();
}

By using LINQ to inject the AddRange method of Requests, I was able to compound the code that loops through each record, selects the original value, increments it, and produces a request to update the record.

Keen observers notice that I created a new Entity object from the old one; this is a best-practice to avoid triggering updates on attributes undesirably. However, it also allows me to perform the increment operation inline. I’m sure you could inject this operation into a secondary where statement, but I think that makes the query logic less readable. But your mileage may vary. :)

Add Parameters to CRM 2011 Lookup Dialog

2013-02-06T06:26:00.001-07:00

Alternate Title: How to hide the “New” or “Properties” button from the CRM 2011 Lookup Dialog.

Following on the heels of yesterday’s post, I have finally discovered a way to eliminate the pesky “New” and “Properties” buttons from the Lookup dialog. This was, again, easier accomplished in the previous version of CRM, with the following code:

   1:  crmForm.all.<lookup>.AddParam("ShowNewButton", 0);

As we’ve seen before, this function did not disappear from CRM 2011—it was simply moved. Now, this function is invoked somewhat implicitly via a behavioral association to a highly organized JavaScript object structure. Yet again, hours of pouring over Developer Tools in Internet Explorer (this time with a lot more Profiling and debugging), I have figured out how Microsoft does it.

Here’s the new way to hide the “New” button:

   1:  var lookupControl = Sys.Application.findComponent("some_lookupid");

2:

   3:  if (lookupControl != null)

   4:  {

   5:      lookupControl._element._behaviors[0].AddParam("ShowNewButton", 0);

   6:  }

Like most of the things on this blog, this is highly unsupported, but I personally believe that this is a harmless hack. There is one caveat, however, to the above code:

The ‘_behaviors’ member is a collection of references to classes. For every Lookup I could find, there was only one entry, and it exposed the “AddParam” function. Conceivably, there could be other Lookups with multiple behaviors, and the first item in ‘_behaviors’ may not be the one you want. You have been warned.

Custom CRM 2011 Form Notifications for UR12

2013-02-05T06:15:00.001-07:00

[UPDATE: 2013.04.12 I added some additional tricks to this code, at the bottom.]

Before Update Rollup 12, it was relatively simple to use the original “form alert” hack (seen here, here, here, and here) to produce custom, inline alerts and notices for the end user. It’s a great feature of the form, and I wish I knew why using it is unsupported.

Alas, many realized that these customizations would be undone by Update Rollup 12, and indeed they have. So, allow me to show you what appears to be the “Microsoft” way of accessing the new form notification system. The added bonus is that this method requires no additional libraries or external references, and should be cross-browser. (Disclaimer: the following information was not released or documented by Microsoft; I discovered it after a few hours of pouring over Developer Tools in IE10.)

The original hack could never have been cross-browser, because it relied on the “htc” behavior file which backed the original “crmNotifications” element. Fortunately, these functions haven’t changed… just moved to a new home. Here’s the old way (pre-UR12):

var notificationsArea = document.getElementById('crmNotifications');

notificationsArea.AddNotification('noteId1', 1, 'namespace', 'Message.');

And here’s the new way (post-UR12):

var notificationsList = Sys.Application.findComponent('crmNotifications');

notificationsList.AddNotification('noteId1', 1, 'namespace', 'Message.');

Both examples do the same thing in their respective CRM 2011 revisions. This customization remains as unsupported as it ever was; however there is relatively little danger in using it.

Here are some additional tricks you can use:

notificationList.SetNotifications();

That will reset the notifications array with an empty set. Also, you can hide the notifications area by using:

notificationList.SetVisible(false);

SSRS Execution Account Needs PrivUserGroup

2012-12-10T14:11:00.001-07:00

I discovered, somewhat by accident, that if you specify an Execution Account in the SQL Server Reporting Services Configuration Wizard, the specified account will provide the security context for SSRS Web Services when using the CRM Reporting Extensions (SRS Data Connector). Sound complicated? It’s really not.

The Execution Account is SSRS’s way to connect to external resources which do not require login (or those for which no other credentials have been configured). This keeps the SSRS service account safe from making any external connection with its own credentials. CRM’s “SRS Data Connector” removes credential requirements in favor of an alternate impersonation scheme (which eliminates double-hop Kerberos, and makes reports easier to access).

Perhaps that was obvious to people with more SSRS education, but I thought it was a maintenance account. /shrug A brand-new installation is likely the place you’ll run into this issue. Unfortunately, the real causes of the failure are best viewed from the SSRS logs.

The problem manifests as the following exception:

"Cannot create a connection to data source 'CRM'."

But ultimately is caused by this exception:

"Immediate caller <SQL Server Reporting Services Execution Account> has insufficient privilege to run report as user <SID>"

So the long and short of it: if you specify an Execution Account for SSRS, and use CRM’s “SRS Data Connector”, then the Execution Account needs to be added manually to “PrivUserGroup”.

Telerik wins a cookie!

2012-10-18T10:28:00.001-06:00

I’ve had the fortunate opportunity to be working with Telerik (www.telerik.com) tools in my Visual Studio development environment for a while now, and I like them. JustTrace, JustCode, and JustDecompile are fantastic development accelerators that should be an integral part of any serious developer’s toolset. However, it was an experience with a recent software update that really set Telerik apart, in my mind, from any other software I’ve used to date.

Recently, Telerik has introduced a Control Panel utility that centrally manages the installation and download of their products. It’s quite handy, and saves a great deal of time and effort. While I was using it to process updates yesterday, the installation of Telerik’s OpenAccess ORM product failed. I tried to update it once or twice more, through the Control Panel, and each time it failed, I used the “Send Feedback” button—thinking that perhaps the error was due to some flaw in the update, and maybe this report would be aggregated with others to help isolate a bug.

I couldn’t have been more wrong.

Unlike other software vendors, Telerik takes its feedback very seriously, and those simple little buttons that relay crash data back to vendors generally does nothing helpful for the user—unless you’re using a Telerik product.

Today, I received an email from Petar Raykov, in the Telerik support team, who not only personally identified my reports, but suggested—very kindly—that I should consider shutting down Visual Studio when I apply updates, because file locks were likely the cause.

Man, do I feel stupid and important all in the same breath. Of course, I should have known to close VS2012; but didn’t think it would be a problem since I originally installed the components on my still-present VS2010 installation. However, the fact that I was personally contacted by Telerik, after using just a simple button on the product to send off exception data, astounded me. Compound that with the fact that I expressed no severity or need to address this problem, and what you get is the picture of a company that just cares about how its software works for you.

Thank you, Petar. Thank you, Telerik. You’ve earned the highest marks in my book for quality of service and support by being proactive and concerned about the basic experience of your product. I will continue to recommend your line of developer toolkits wherever I go, and share this story as I do it!

My Third MVP Award

2012-07-01T16:29:00.001-06:00

Microsoft graciously renewed my MVP status for 2012, as I found out today. I don’t know why it keeps happening, but I love it and hope always to be worthy of it. Having grown much closer to my MVP compatriots this year, more than previous years thanks to the MVP Summit, I am honored again to be placed among their ranks.

Ordinarily, I would have lots to say about it… but I can only thank Microsoft for yet another opportunity to continue in this capacity, and hope strongly that I will not disappoint the Dynamics CRM team in continuing to help steer the product’s development. Also, I thank the community that has supported me all these years, and hope to be worthy in their eyes as well.

NDepend v4 Released

2012-05-25T06:42:00.001-06:00

I’ve mentioned NDepend a scant few times, mostly because I’ve used it in limited fashion. Though CQL was easy enough to learn, I found it difficult to quickly put together complex analytical queries against my code. Patrick Smacchia answered my unannounced plight in the Version 4 release of NDepend with the revolution that is CQLinq.

By bridging the best of the CQL and Linq worlds together, Patrick has truly delivered the most effective and rapid-use code quality tool for .Net development. NDepend has moved from being a utility of convenience to a core necessity in my personal development. Regardless of whether or not you have experience with code quality tools for .Net development, I highly recommend investigating NDepend.

I look forward to continuing my use and integration of this latest version into my projects and using the power of CQLinq to its fullest extent. Thank you, Patrick!

CRM, Cookies, and You

2012-04-29T13:41:00.001-06:00

I went out on an adventure to find out if I could pass extra data into a web service Message from the client, and discovered that it is possible to set a cookie at the browser (or an ISV page, if you’re into that kind of thing), and pick it up inside of a Plugin. There are a few limitations and gotchas to this process, not the least of which being that this is considered an unsupported customization.

However, there are often interesting needs and situations for which you may want to pass extra data along to a Plugin, but don’t really have a good way to do it. For instance, I wanted to watch a sub-grid for changes to records and identify only those changes which were made while the parent record was opened. In this case, I wanted to catch an array of changes once the parent record was saved, and I needed this array to be specific to the singular “session” of the form’s lifetime on the screen. (If anyone can think of an alternate, supported method for this that doesn’t involve a ridiculous amount of return trips to CRM, I’d love to hear it.)

Practically speaking, I was producing a rich audit trail with contextual links to changes with related records. Because this was for CRM 4, there was no existing audit feature as with CRM 2011—however, I’m fairly certain this process can be applied to CRM 2011 with the consideration that it may fail in sandbox mode.

What I did was push indicators from the child window into a JavaScript array running on the parent window. Then, I serialized these indicators into a JSON string, and established a cookie (again, in JavaScript). By examining the “Request.Cookies” object at the plugin (after importing the necessary namespaces), I could identify and deserialize the contents and perform work at the Plugin.

Also, I discovered that “Response.Cookies” can be loaded with information by an ISV page (though depreciated in CRM 2011, are still available for on-premise use) and also discovered by the Plugin. This can effectively overload a CRM web service transaction with extra information without messy things like temporary records (which will shoot SQL indexes to hell) and extra attributes.

I ran into trouble, however, when trying to set a cookie from JavaScript within an ISV page. The Plugin would not identify this cookie, and I believe it’s due to the difference in the way the browser treats cookies from the runtime versus cookies from the domain (served in the HTTP response of the ISV page).

So, what are the limitations and gotchas?

THIS IS AN UNSUPPORTED CUSTOMIZATION
CRM 2011 Plugins operating within sandbox mode will probably be prevented from accessing the “Request” or “Response” from the “Page” context. Again, I haven’t tried this with CRM 2011 yet, but that’s the assumption I’d have to make.
The Plugin will only have access to the cookie from the “Page” context while operating synchronously.
Cookies are persistent. Most web developers understand this, but it’s easy to forget. Once a cookie is set, it must be forcibly removed or allowed to expire. Never assume that a cookie will not have survived its previous instantiation.

Cookies can be a two-way street of information, so there are likely many different and exciting uses for them to extend CRM’s functionality and encourage cross-talk between various UI elements that may otherwise have no sensible means of sharing data. If you have used Cookies with CRM before, I’d love to hear what purpose they served!

So This Is What I Missed…

2012-03-04T16:43:00.001-07:00

I’ve successfully returned alive from my attendance of the Microsoft 2012 MVP Summit. This was a minor concern, given that I was stricken with a bout of vertigo that still troubles me to a lesser extent today.

I missed last year’s Summit, and was quite anxious to attend this year’s event. This extended delay in participation allowed me to accrue more familiarity with the MVP world, and the topics reserved for NDA-backed channels. Thankfully, JourneyTEAM helped me attend during one of the largest projects I’ve ever been assigned.

The single greatest thing I’m looking forward to in the Dynamics CRM 2011 updates to come will be [CENSORED]. Sorry, folks. You won’t find me spilling the beans of Geek Vegas here, because after partaking in the greatest conference of MVP minds throughout the entire world, I have found an appreciated value in my nondisclosure agreement.

Many folks don’t truly understand the impact or the purpose of this Summit. Even as a second-year MVP, I didn’t fully understand. In fact, based solely on the stories that do make it out of this event, an outsider may believe the experience to be purely about back-patting, drinking, and self-sustaining ego building. I cannot state more emphatically than in bold text the following rebuttal: this is not the case.

That said, I was not surprised to learn that of 55 Dynamics CRM MVPs, our attendance total was 41. That means that 3 out of every 4 Dynamics CRM MVPs were at the summit, providing a voice for the community directly to the product teams. We truly represented every aspect of our community, from independent developers to ISVs, from small businesses to enterprises, and from end-users to administrators.

Microsoft’s product teams generally have little or selective involvement in direct customer engagement. Most of Microsoft’s public-facing customer involvement comes from either partners or Microsoft Support. This layer of abstraction and occlusion, though necessary, provides little for a product team by the way of direction. The MVPs are representative of the entire community, and help direct Microsoft’s products through updates, versions, and feature additions.

We love it. It was no more apparent than during some of the more heated discussions and debates that littered the entire Summit experience. Yet, at the end of the day, we all gathered at various Seattle bars to unwind with rounds of beers and drinks with umbrellas (you know who you were).

This isn’t a collection or even a community of experts. It’s a family. And I am damn proud to take part in it.

XRM Virtual Presentation

2012-01-07T13:21:00.001-07:00

On Jan. 10th, I’ll be making a presentation along such revered Dynamics CRM MVPs as Julie Yack, Scott Sewell, Donna Edwards, Leon Tribe, Shan McArthur, and Mitch Milam. Our topic matter will be specifically those lessons we’ve learned the hard way over our varied experiences with CRM.

XRM Virtual is an open-membership user group with a lean toward developers and integrators. If you’d like to register to attend this presentation, visit the Event Page.

Google+ Page for Dynamics CRM

2012-01-01T16:19:00.001-07:00

Lately, I’ve been trying to coalesce information streamed around various channels to which I’m attuned into a new Google+ page for Dynamics CRM.

Personally, I’ve become a heavier G+ user than Facebook, and not just because of its rock-solid performance—but because of many important privacy and intellectual property practices. I’d recommend it for anyone looking to break out of Facebook once and for all.

LinkedIn is still a great professional resource for sourcing CRM talent and even assistance, so you’re sure to find great resources there too. But its format and membership are rather rigidly defined compared to Facebook or Google+.

In any event, I welcome any contributions and “circling” of the G+ page, and hope to make it an active and engaging space for the CRM community, apart from the Microsoft public CRM forums where I can also be found.

Using XML-based Plug-in Configuration

2011-12-19T15:05:00.001-07:00

For more complicated and feature-rich Plug-in customizations for CRM, it can be appealing to use highly dynamic configurations. The Plug-in model offers simple string parameters to allow for the open interpretation by Plug-in developers. One of the more efficient and flexible configuration mechanisms is XML.

With XML configuration, there are three methods that can be used to varying degrees of efficacy:

Hard-parsing; dissecting XML with String manipulation (useful in dire situations)
XmlDocument parsing and node traversal; similar to JavaScript DOM manipulation and perhaps easier for web developers to grasp
XML-serialized classes; deserializing XML into one or more strongly-typed classes that represent the configuration

For the purposes of this post, I’m going to focus on the method that I prefer and find superior to the others: XML-serialized classes. The reason I believe this is superior is for the following reasons:

Serialized classes can be versioned with namespace declarations; meaning that updating code and providing for new configuration specifications can preserve older versions
Hard-parsing and XmlDocument traversal requires significantly more code to determine what was passed
Serialization and deserialization work both ways; Plug-in configuration can be performed by a utility (think Silverlight!) that understands the .Net class representing the configuration, and easily construct the XML; this ability is simplified to a great extent with WCF Data Contracts (which we’ll get to in a moment)
Hard-parsing and XmlDocument traversal code requires more effort to update or alter the configuration schema
Hard-parsing and XmlDocument traversal work better in situations when the XML document and its contents are either
1. Very simple and statically defined
2. Totally unknown and dynamic
Serialized classes define a rigid standard and schema for the configuration, but also offer a significant amount of flexibility while simplifying the interpretation of the configuration

As a caveat, I should state that I’m extremely comfortable with XmlDocument use. I’ve used it many times, and found it a natural fit for my long experience with JavaScript DOM programming. However, I recently implemented a project that needed a highly structured and very robust configuration model, and decided to look for ways to reduce the amount of code I needed to write. Additionally, I needed the process to be flexible, as I might change my mind about the operational needs from the configuration as the code evolved.

Starting with the concept of deserializing .Net classes from XML, I searched for the best method of implementation for CRM that I could identify. I found that there are a few ways within the .Net framework to serialize and deserialize classes into and from XML. Some are more flexible than others, but the CRM platform offers unique challenges that pretty much made my answer for me: WCF Data Contracts.

Why WCF Data Contracts? Well, I like to deploy my assemblies to the database. This is a practice that helps assure the interoperability of my code with CRM Online.

The problem with traditional, old-school XmlSerializer methods is that .Net requires the original assembly to be file-system accessible in order to reference for compilation into a “[foo].XmlSerializers.dll” assembly. If you really didn’t know what these assemblies were (as I didn’t) before now, allow me to explain. The XmlSerializer routines require strongly-typed interpretive classes that are Reflected out of the original assembly and built “on-the-fly” by the .Net CLR. It cannot achieve this with assemblies that exist only in memory, as database-deployed assemblies are. Therefore when CRM attempts to deserialize by calling these interpretive classes, they don’t exist—causing an “Object Is Not An Instance” exception.

Experienced developers know that these XmlSerializer assemblies don’t have to be built “on-the-fly”, and they can certainly be assembled and distributed in conjunction with the original assembly. However, CRM doesn’t support a shared-assembly model for database deployment. The assemblies could be deployed to disk or GAC, but again this isn’t compatible with CRM Online.

If you’re thinking, as I did, that perhaps the assemblies can be merged together with ILmerge and deployed together, think again. ILmerge generates a new AssemblyId attribute for the combined assembly metadata—which is only a problem for a the “[foo].XmlSerializers.dll” assembly because it strictly validates the AssemblyId of the calling code; and it imprints on the original assembly.

Before I discovered WCF Data Contracts, I was desperate enough to output the generated code for the XmlSerializer assembly and inject it into my project. This is as ugly and highly ill-advised as it is time-consuming. So, if you’re considering XML configuration for CRM Plug-ins, I strongly recommend using WCF Data Contracts.

For more reading, see the MSDN Article on WCF Data Contracts.

Some tricky “gotchas” with using WCF Data Contracts for newbies:

The order of XML nodes must be alphabetically ordered by their declared Data Contract name; this is a deserialization optimization requirement, and can be massaged to a certain extent by using advanced Data Contract directives.
There are no deserialized “attributes” for XML nodes. The only supported XML-node attributes are namespace declarations. Every Data Member is its own node, and its contents become the deserialized value.

Call for Comments: CRM 2011 Grid Editor

2011-11-03T09:57:00.001-06:00

One of the primary sources of traffic to my blog comes from my CRM 4 Grid Editor utility. Every day, it seems, some new visitor lands on my blog (according to Google Analytics) looking for this project. It seems to me, then, that the sooner I can update the utility to work with CRM 2011, the less disappointed these visitors may be.

First and foremost, I’d like to make a solemn announcement: I will no longer continue development on the CRM 4 Grid Editor. It’s reign started rather late in the CRM 4 life-cycle, and now that we’re well into CRM 2011’s life-cycle, I don’t see much benefit from continuing to develop it. For those who patiently waited for many bug fixes and feature enhancements, I apologize. Regular readers of this space know why I had to drop the project at the beginning of the year, and the unfortunate side-effect culminates with this announcement.

All is not for naught, however, as I intend to start very soon on the CRM 2011 Grid Editor update. In light of the experience I’ve had with implementers of the CRM 4 version, I’ve come to a few design decisions about the update that will impact the product overall:

I will no longer “hack” the CRM Grid control in an unsupported fashion.
I will no longer reuse CRM input controls in an unsupported fashion.
I will provide all of the feature enhancements and bug fixes that I had originally intended for the CRM 4 Grid Editor.

Understandably, these decisions will impact the total amount of time necessary to develop this project—but I may not be alone. Finally, I may actually have some help from interested contributors within the ranks of Microsoft. This kind of collaboration excites me, because it means that the turn-around for development could be much quicker and the end-result should be more uniform with the overall CRM experience.

The purpose of this announcement is to solicit comments from you about the features you would like to see from this effort, and the relative importance you might place upon them. If you’ve used the CRM 4 Grid Editor, then you’ll be in a good position to know what has already been accomplished. If not, however, I still want to hear your feedback.

So, kick me some comments below in this early, planning phase of the project so I can give appropriate consideration to the needs of the Dynamics CRM community.

Upgrade CRM 4 to 2011: For ITdiots

2011-10-18T01:53:00.001-06:00

Q: Who’s an ITdiot? A: Me.

I’ve been involved in the IT world since my early teen years. It started as the family computer expert, and evolved into advanced circuit configuration for ISPs and eventually a fulltime network administrator gig. All the while, I nurtured and evolved my passion for development.

Ordinarily, this blog is dedicated to the later talent and my trials and tribulations therewith. However, I cannot deny that the foundations of my career and experience have solid roots in the IT realm. Having never acquired any formal education for either talent is what makes me, your friendly (mostly) neighborhood CRM MVP, an ITdiot.

If it weren’t for Google, I wouldn’t have much of a career. While some things in the IT world have become intrinsically intuitive, I would be remiss to ignore the fact that my first real job at an Internet Helpdesk left me puzzled for longer than I care to admit as to why “.net” or “.org” worked to execute things on the computer, and “.com” was so much more prevalent than “.exe”.

At any rate, I recently gave a presentation for CRMUG geared toward the IT Crowd—not the British comedy (although if you’re in IT and haven’t yet seen it, you should), but my people. So, the following guide complements that presentation and the material I covered, and all that I had wished to cover but ran out of time for. This is a basic list of the considerations I make when considering the move from CRM 4 to CRM 2011.

CRM 2011 On-Premise Upgrade Requirements

Windows Server 2008 SP2 or R2; 64-bit
SQL Server 2008 SP1; 64-bit

Recommend a different SQL server than what hosts CRM 4 (otherwise, it will upgrade the CRM 4 configuration and default org databases in-place)

Removal of any unsupported customizations (see IRAD at bottom)
An active CRM Administrator account http://www.crmsoftwareblog.com/2011/07/user-mapping-error-upgrading-to-microsoft-dynamics-crm-2011/

What about Online?

Pros:

Reduced IT overhead; from infrastructure to support
Reduced deployment timeframe
Automatic/Scheduled updating

“Scheduled” becomes “Automatic” within a year

Aligns with Office 365 and SharePoint Online
Provides an easy to use Internet Lead Capture feature
Can be redeployed as 2011 On-Premise
Federated authentication is just around the corner (R7; Q4 2011 Service Update)

Cons:

May not be ideal for integrated systems (ERP, Accounting, etc)

Limited functionality connecting from CRM to external resource

No support for custom Workflow actions
Limits on number of Workflows and custom entities (200?)
Externally hosted email router (on-premise, hosting provider)
FetchXML reports only

Helpful Overviews

The Official Word http://technet.microsoft.com/en-us/library/gg554717.aspx
Business and Technical Impact Considerations http://blog.sonomapartners.com/2011/04/upgrading-to-crm-2011-our-story.html
Step-by-step guide http://weblogs.asp.net/pabloperalta/archive/2010/11/01/step-by-step-installing-crm-2011-on-premise-and-migrating-from-dynamics-crm-4-0-32-bits-on-premise.aspx

Upgrade Methods

Direct upgrade

Universally considered the riskiest route
Fastest/easiest option for GAC-deployed custom assemblies
Use virtual machines for Intermediary transition to land CRM 4, and good testing space for CRM 2011: http://rondegiusti.wordpress.com/2011/03/01/steps-when-upgrading-migrating-from-ms-crm-4-to-crm-2011/

Import CRM 4 Org to virgin CRM 2011 install ("Microsoft Migration")

Universally considered the safest route

Allows you to reserve a backup database copy and perform the import several times if necessary to massage the process for heavily customized CRM 4 environments

Doesn't import GAC and Disk deployed custom assemblies

Least impact to production environment and faster than using VMs
Requires some work to avoid the limitation of importing an org once http://www.dynamicscrmtrickbag.com/2011/04/08/migrating-from-crm-4-0-to-dynamics-crm-2011/

Integration utility to ship CRM 4 data (Scribe, InaPort) http://blogs.msdn.com/b/crm/archive/2011/09/30/using-inaplex-inaport-for-data-integration-with-microsoft-dynamics-crm.aspx

Handy for selective data import, obsoleting customizations that were problematic or could use changing
Difficult to ship CRM 4 custom assemblies (use the CRM 4 Plugin Export utility to help)
In short: a great way to break the "direct update" chain

Social Experiences

New Outlook Client behaviors: http://niiranen.eu/crm/2011/03/upgrade-gotchas-outlook-client-for-dynamics-crm-2011/

Opt for 32-bit over 64-bit Outlook Client, at least for a while

Silverlight compatibility issue; until Silverlight 5 rolls out. Many Marketplace solutions and customizations using Silverlight may not work in 64-bit Outlook.

No more favorite folders

To restore, one must disable the Outlook 2010 Solutions module; this may also impact Marketplace solutions or desired functionality

Windows Live Essentials

Avoid using, or be prepared repair installations of its component

Old Outlook Client behaviors: http://blogs.msdn.com/b/ukcrm/archive/2011/04/22/crm-4-0-client-upgrade-to-crm-2011.aspx

UR7 is compatible with CRM 2011
Offline functionality is disabled

Moving from CRM 4 Online to CRM 2011 On-Premise: http://www.magnetism.co.nz/blog/11-04-15/Issues_Upgrading_from_Dynamics_CRM_4_0_to_2011.aspx

Be sure to check that On-Premise users exist for mapping
Administrator account mapping should be manually mapped for accuracy

CRM 2011 may throw JavaScript errors, even when CRM 4 wasn't customized with JavaScript: http://blogs.msdn.com/b/emeadcrmsupport/archive/2011/08/31/crm-2011-form-errors-when-opening-non-customised-forms-object-doesn-t-support-property-or-method-form-load.aspx

A RewriteModule problem may exist in IIS 7, and need to be reinstalled

Personal Upgrade Process

Avoiding more than one direct upgrade

Never upgrade from CRM 3 to CRM 4 and then to CRM 2011; always make a clean break somewhere in the chain to avoid esoteric issues caused by upgrades daisy-chained this way

Wait for first adopters to uncover problems (sorry first adopters!)
Virtual Machines!

VMs are your IT friend. If you don’t think you can afford it, go grab VMWare ESXi—it’s free, man

[IRAD] unsupported customizations

Identify: know where you’re currently using them, and what they do
Remove: eliminate them to avoid upgrade issues
Analyze: determine whether or not new functionality allows you to replace them with supported customizations/features
Deploy: after the upgrade, update and redeploy any unsupported customizations deemed necessary for business

Farewell, Jim Glass

2011-10-08T02:28:00.001-06:00

With Jim’s recent announcement of his retirement from Microsoft, I thought I’d make a little space here to immortalize my thoughts of a man I never got to meet in person, but dearly wished to.

There’s something to be said about the Dynamics CRM community: chiefly that it is the most vibrant and active product community around any single Microsoft product. Why? Two reasons:

As I have long believed and been rewarded for such faith, it is simply the best product Microsoft has ever brought to market (that isn’t an Operating System); and
Fantastic community leadership, fostering an open, engaging dialog between the users of the product and the experts that know it.

Jim Glass is directly responsible for both. There’s no objective way for me to quantify that, however, so take that declaration as the biased opinion of one happy CRM MVP.

I’ve never known a CRM world without Jim, and long before I entered the MVP space, I met Jim on the battlegrounds we call the public CRM forums. Jim was always watching, carefully moderating and steering the forum to productive ends. He encouraged the MVPs, on a regular basis, to contribute and participate with the community at large—and the forums were just that.

There is no mistaking the emptiness that I feel now that I know he’s gone, and I wait patiently for his successor to fill his space as best as possible (daunting though that may be). Since I never had the opportunity to pay my respects and give my appreciation to Jim in person, I find myself obligated by duty to honor his legacy by applying myself to the forums in a way I know he would wish.

Those who knew Jim understand the impact and the gravity his absence will generate. Those who didn’t, may never understand what he did to improve their experience with CRM, the product or the community. In some small way, I wish I could impart that feeling; but I doubt I have the raw ability to put in words what Jim has done, for me—for us. I will miss him, and follow his social publications with great interest.

Farewell, Jim. To have known you from afar, is better than to never have known you at all.

“To leave, or not to leave--that is the question.
Whether ‘tis nobler in the mind to suffer
The pings and queries of MVP misfortune
Or to take charms against a sea of blogs
And by composing, mend them. To pry, to seek—
No more—and by seek to say we end
The madness, and the thousand natural questions
An MVP is heir to.”

60k Page Views!

2011-09-27T20:58:00.001-06:00

When I first started this blog, I really didn’t expect it to take me anywhere. I just wanted a neat little place to post my code, a place that would follow me wherever I went and be a sounding board for whatever I thought (about CRM).

This evening, while following up on my social activities (forum contributions, blog reading, and that Twitter thing), I discovered that the ticker on my page-view counter rolled past 60 thousand. A number I would never have expected. This comes on the tail of passing my first Microsoft Certification Exam. (I’m finally an MCP, too!)

Now, I’m not one to relish in popularity. I’m a pretty shy and reserved person. So, the only thing I hope to take from this statistic is that I have hopefully helped many Dynamics CRM implementers and developers who have come here looking for help (or free code *wink*).

If you have found value in this space, I’d love to hear about it. That kind of thing is what encourages me to contribute—and with more frequency.

On a positive note, I may start posting more frequently in this space (and others) regarding some very exciting learning opportunities that are coming my way in the near future. There will be unique challenges that I’ll get to address with CRM, and my company, JourneyTEAM, has given me motivation to contribute the value from my experiences with you, my audience.

So, thank you for your readership. I hope I have given you useful and helpful information, and a better idea of how to squeeze great things from Dynamics CRM.

Review: CRM 2011 Administration Bible

2011-09-17T06:12:00.001-06:00

Publisher: Wiley
Authors: Matt Wittemann, Geoff Ables
CRM Entropy Rating (in Baked Goods): 3.1415926535897

Matt, a fellow CRM MVP, sent me a copy of this book a long time ago, and I’ve pretty much only used it for reference material here and there until recently. I’ve read a handful of CRM 4 books in my day, and found a great deal of helpful information from them. The Microsoft Dynamics CRM 2011 Administration Bible marks my first in-depth read relating to CRM 2011.

The title of this book is both accurate and misleading—and I don’t mean from a theological standpoint. (Though I imagine, given the apologist forewords by Matt and Geoff, the word “God” was uttered on multiple occasions with various modifiers during its authoring.) This book is indeed a Bible in the sense that it combines a complete picture of CRM, from URL to SQL, from Form to Filter, and from Dialog to Migration. It really has it all.

However, don’t let the word “Administration” throw you for a loop. This book isn’t geared specifically for administrators of any kind, and it doesn’t just cover administration. It’s so thoroughly educational on the core processes of CRM, I dare say that it is the first and last book you’ll need for Microsoft Dynamics CRM 2011 (see my “Bible” comment above). Matt and Geoff take special care to make every reader an Administrator. And that’s why the damn thing is so thick! (Caution: Ordering more than 3 of these books at a time involves freight charges.^*)

The machines with which this Bible was written have long surrendered their keyboards to a higher power. The material is dense and enriching not only for newcomers to the CRM experience, but for those arriving to CRM 2011 looking for what changed from the previous version—like myself. As with a religious text, you’ll find yourself engaged in the index or table of contents quite a bit, if you’re working with CRM already. But, you will find value throughout the areas you don’t think you need to read.

This book will teach you all of the standard features that come with Dynamics CRM out-of-the-box, and then open your mind to the possibilities of custom enrichment. It wouldn’t be a book to buy if you’re only investigating Dynamics CRM (though it wouldn’t hurt to read); but it is an essential part of any CRM implementation, and its material is useful to every deployment and use of CRM that I can think of.

So, from this digital pulpit, I preach from one Bible, and that is the Microsoft Dynamics CRM 2011 Administration Bible! If you have Dynamics CRM, do yourself a favor and have this book, too.

^* I’m kidding! But really, you do get more words for your dollar… and the most helpful ones to boot!

CRM 2011 and WSDL

2011-09-13T23:06:00.001-06:00

CRM 2011 makes a dramatic change with the WSDL implementation compared to CRM 4.0. The biggest difference? The WSDL file you download is not a full definition of the service (for either Discovery or Organization).

Instead it’s a very small and self-conscious (“lightweight”) WSDL that points back to the same service (and host) with an import directive for the full WSDL. What does this accomplish? Well, WSDL-imports are supposed to allow a WSDL definition to be modular with reusable and multi-authored definitions. We really don’t see that being applied in CRM’s case in any sensible fashion (like importing out-of-the-box entity/attribute definitions separately from custom ones, or importing WSDLs with Solution-based scopes). All it seems to do is complicate the retrieval of information we need for our application.

So, if you prefer or require the late-bound Entity class, and you don’t have local access to a CRM system. Having a “full” WSDL file could help when you want to avoid…

…deployment of the CRM DLLs. This may be important when single-assembly functionality is imperative and assembly dependency deployment is a serious headache, such as CLR operations from SQL for integration projects. Or maybe the target system doesn’t use or support .Net.
…the code-generation tool. Let’s face it, the code-generation tool is nice for simple and quick developments, there’s no argument about the excellence of many of its Utility methods. However, it produces a lot more code than many will ever use—artificially inflating the assembly size unnecessarily. And the code it produces isn’t without its own bugs. Sometimes keeping things simple is its own reward.

So, when you need to have the “full” WSDL file, for your services, use links formatted like so:

Discovery Service

http[s]://<crmServer>/<crmOrg>/XRMServices/2011/Discovery.svc?wsdl=wsdl0

Organization Service

http[s]://<crmServer>/<crmOrg>/XRMServices/2011/Organization.svc?wsdl=wsdl0

DOM Events and CRM 2011

2011-09-12T15:52:00.001-06:00

[UPDATED: 2013.04.11 I've learned a lot since this premature post, and have struck out all the incorrect information.]

Recently, another MVP asked in a private forum how one might connect to the “onclick” event of a CRM field. With the new Xrm.Page namespace object model, it seemed that all references to the actual DOM element of the control were lost (or at least, very well hidden). Well, I did some poking around, and I discovered ~~two~~ one things:

Xrm.Page lives only within the scope of web-resources and their execution (wherever and however they are scripted to occur); this means that the old days of firing up the IE Developer Toolbar to hack CRM on-the-fly are gone.
The DOM elements are buried in undocumented members of the control object (as opposed to the attribute object). As a consequence, the following hack is unsupported~~, but also much easier to implement than the supported method of using a Web Resource to present your own custom controls that drive, in the background, CRM’s native controls~~.

So, here’s the method I found to achieve access to the DOM element control container, and how to assign a new “onclick” handler to it:

var controlname = "ownerid"; // The "Owner" field, as an example

function myFunction ()
{
alert("I have been clicked");
}

Xrm.Page.getControl(controlName)[“_control”][“_element”].attachEvent(‘onclick’, myFunction);

Wasn’t that easy?

Ask the MVP (CRMUG)

2011-09-07T12:26:00.001-06:00

There’s an upcoming roundtable event, hosted by CRMUG, where many CRM MVPs have agreed to come together and address questions submitted to the “Ask the MVP” event site. After the bulk of the event, I understand there will be time afterward for free-form, open floor discussion and Q&A. However, if you want to make sure your question is asked, drop an email to Janet Lampert or Donna Edwards well in advance! As with most CRMUG events, attendance is limited to CRMUG members—become a member today, and reap the benefits.

I’m personally excited to get involved in this event, since this is the second CRMUG event to which I’ve been invited to participate. Hopefully, I am more useful to the discussion than a fly-on-the-wall. Many long-time MVP greats will be coming to the table, and I’m honored to find myself among them. We haven’t seen the question list yet, so I’m anxious to find out what you, the audience, want to know!

Copying Lookup Values

2011-08-25T13:52:00.001-06:00

Very recently a poster in the CRM Development forum asked why she could not copy the value from a Contact Lookup field into the “To” field of a Phone Call entity. On the surface, her code was very simple and would largely be expected to work. What ended up working was basically creating a new value for the PartyList that recreated values from the Contact Lookup.

Why was this necessary? I don’t really know, and haven’t looked any deeper into CRM 2011 yet, but what I know from CRM 4 is that certain expressions of the DataValue for a Lookup field can contain extra, undocumented data elements. I suspect that CRM 2011 has expanded the use and perhaps number of these undocumented data elements, and their presence from one Lookup field prevents the direct assignment of the value to another Lookup field.

Perhaps this is limited to Single-to-PartyList copies, but perhaps not. Either way, I’ve whipped up a handy function that can help easily copy or append values into Lookups when those values are taken from other Lookups. Also, it allows you to provide a delegate function to which it will pass each entity reference and expect a boolean indication as to whether or not the value should be accepted for inclusion in the target attribute.

function CopyLookupValue(sourceAttribute, targetAttribute, boolAppendSource, funcDelegate)
{
  var sourceValue = sourceAttribute.getValue();
  var newValue = [];

  if (typeof boolAppendSource != "undefined" && boolAppendSource)
  {
    sourceValue = targetAttribute.getValue().concat(sourceValue);
  }

  foreach(var valueIndex in sourceValue)
  {
    var copyValue = true;

    if (typeof funcDelegate == "Function")
    {
      copyValue = funcDelegate(sourceValue[valueIndex]);
    }

    if (copyValue)
    {
      newValue.push({
        id: sourceValue[valueIndex].id, 
        name: sourceValue[valueIndex].name, 
        entityType: sourceValue[valueIndex].entityType});
    }
  }

  targetAttribute.setValue(newValue);
}

Using the thread that initiated this code as an example, here is how the above code would be used to copy the value of a Contact field on a parent form window to a To field on the child form window:

var remoteAttribute = window.parent.opener.Xrm.Page.data.entity.attributes.get("bc_contact");

CopyLookupValue(remoteAttribute, Xrm.Page.getAttribute("to"));

Changing Product Unit Groups

2011-08-22T13:19:00.001-06:00

I ran into a situation where a large list of Products had been imported into CRM 2011, but the Unit Groups for many of them needed to be changed after the fact. As many have discovered, even though the form customization options for the Product entity professes that the field is not flagged as “read only”, the field is in fact “read only” when Products are opened.

The workaround is fairly simple, but comes with some caveats: export the records to an Excel spreadsheet with the option “Make this available for re-importing by including required column headings” selected. You must export both the Unit Group field and the Default Unit field. In spreadsheet form, you can alter the Unit Group and the Default Unit. Now, here’s the caveats:

The Default Unit must be uniquely named. Multiple Units with identical names (in any Unit Group) will cause the import to fail, because it does not look for the Unit in a specific Unit Group. The failure is because CRM cannot properly resolve the Unit, due to name duplication.
Beware of any Price List Items configured to use the old Units configured for this Product. I don’t know what CRM will do to you if you try to use the Product in a Quote/Order/Invoice after you change its Unit Group in this way.

When you import the changed data, you should notice that the modifications to the Unit Group (and Default Unit) values have been properly changed.

[Update: Astute reader, Jevgenij, notes that the following Microsoft KB will also allow you to work around the problem using the Bulk Edit feature: http://support.microsoft.com/kb/949941 This is particularly useful for CRM administrators. The process above, however, will work for anyone with access Product catalog maintenance.]

Silverlight and CRM 4 (continued, again)

2011-07-08T18:38:00.001-06:00

When I delivered the code example in my last post on the subject, I knew that it would probably be worthwhile to pick apart the individual code elements in order to provide a better understanding of what’s going on underneath it all. This marks the final chapter of the saga which started as a 10-minute presentation, and culminates about 40-hours of work.

Again, this subject matter all stems from my participation in CRMUG’s ongoing 10@10of10 series. To date, I’ve slept in too long to catch any of the other presentations live—for that I apologize to the other presenters, because I really am interested in their content matter. Problem is, I’ve been up until 4 A.M. most mornings doing freelance work, or dealing with other things. Thankfully, CRMUG will be posting the session recordings to their site—or so I’m told.

The code I will present will be in snippets from the Simple CRM 4 Silverlight Application project that I’ve uploaded to CodePlex. If you didn’t already download it to build the application for yourself using my last post’s instructions, you’ll probably want to do so now for what follows. (You will also need the Silverlight 4 Tools for VS 2010 and the Silverlight 4 for Developers Runtime to work with the project files.)

What follows: A Silverlight primer

Ok, so… first thing’s first: If you’re inexperienced with Silverlight, I recommend the Silverlight Jumpstart book by David Yack (downloadable as a PDF). It serves as a pretty good primer for working with Silverlight in general. I used it, and found it very informative and useful.

Mr. Yack also wrote another book, CRM as a Rapid Development Platform that contains a chapter on Silverlight development for CRM. I also found that chapter useful in my project, but diverged from his examples by using the WSDL for web-service interaction. His point about WSDL bloat upon the final XAP file are valid, and should be considered when developing smaller, single-purpose products. However, for richer and fuller Silverlight apps, I find the WSDL to be integral to the speed of development.

I’m not going to get into the ins-and-outs of Silverlight development. There’s too much to cover for this space, and I will simply proceed under the assumption that you, the reader, will find this knowledge for yourself and use it to obtain an understanding from what follows.

What follows: Connecting to CRM

There are two things necessary to connect Silverlight to CRM:

knowing the service endpoint and authentication method¹
having an asynchronous interface to the endpoint methods³

For ease of use within the context of the ISV folder, I split these requirements across two projects, respectively:

an ASPX host page for the Silverlight control
the WSDL in the Silverlight application

Because Silverlight must ultimately satisfy both requirements internally, there is a third, intermediary requirement caused by my division of responsibility: passing service endpoint and authentication information from the host page into Silverlight².

Knowing the service endpoint and authentication method

Because I decided to use an ASPX page and code-behind file to meet this requirement, the process is decidedly simple, and is explained best in these snippets of code:

SimpleCrmApp.aspx.cs (line 35):

serviceUrl = this.Request.Url.Scheme + "://" + this.Request.Url.Host + "/MSCRMServices/2007/CrmService.asmx";

The snippet above uses the Page.Request member to assemble relevant components of the scheme used to view the page (“http” or “https”), and the hostname.

SimpleCrmApp.aspx.cs (lines 19 and 38):

orgName = Request.QueryString["orgname"];

//... jump over code

CrmAuthenticationToken token = CrmAuthenticationToken.ExtractCrmAuthenticationToken(Context, orgName);

The snippet above shows how the code-behind grabs the value of “orgname” from the same Page.Request to complete our ExtractCrmAuthenticationToken() method call. This parameter must be passed to the host page somehow. In our example, we accomplish this in this part of the SiteMap.xml configuration:

SiteMap.xml:

<SubArea Id="SimpleCrmApp" PassParams="1" Url="/../ISV/SCA/SimpleCrmApp.aspx" AvailableOffline="false">

Here, we rely on PassParams to do our dirty work for us.

Now, you might be misled into thinking that the token would be sufficient for Silverlight to authenticate its own SOAP messages. Many in the forums have. The reason you would be wrong is that the ExtractCrmAuthenticationToken() method provides you with the CrmAuthenticationToken instance used by CRM’s platform to communicate with the web service endpoints.

As I previously explained, this poses a problem because this token is designed to always operate under two conditions:

Use to communicate with SOAP under a CrmImpersonator() call, which removes impersonation from the thread, thereby bringing “SYSTEM” user network credentials for use with…
Integrated Authentication

It’s important to note that the reason token won’t work for Silverlight in strictly Integrated Authentication environments is because of the presence of the CallerId value. Any time this value is not Guid.Empty, CRM assumes impersonation is taking place, and checks the credentials for membership in the PrivUserGroup. Because CRM does not communicate with itself over IFD, the CrmAuthenticationToken provided with always have an AuthenticationType of “0” and will never contain a CrmTicket.

When authenticating via IFD, you must supply a value for CallerId. That’s what explains this bit:

SimpleCrmApp.aspx.cs (line 40):

callerId = token.CallerId.ToString();

Finally, I need a sensible way to determine if CRM is being used in an IFD scenario or not. I could go the complicated way, parsing the URL to find out if the hostname has the orgname in it—but that’s a lot of code. A more elegant way, is to look for the browser-cookie “MSCRMSession”:

SimpleCrmApp.aspx.cs (line 28):

// A broadly applicable mechanism for detecting IFD is the presence of the MSCRMSession cookie

if (Request.Cookies["MSCRMSession"] is HttpCookie)

    authType = "2";

else

    authType = "0";

Fun, huh?

Here’s why “MSCRMSession” is also important: it contains the value of the CrmTicket. See, whenever the browser is authenticated via IFD, it uses a browser-cookie (which is inaccessible through JavaScript or Silverlight) to hold this ticket value. The nice thing is, that it’s passed in every HTTP request header that originates from the browser (including Silverlight) to its domain of origin. Therefore, we do not need to worry about finding it or passing it through the headers of our own SOAP requests.

Notice how every value I’m taking is ending up in string format? Well that leads into the next requirement.

Passing service endpoint and authentication information from the host page into Silverlight

There are a handful of ways to obtain data from a Silverlight application’s hosting page:

Inspect the DOM.
Call a JavaScript function.
Use InitParams.

I’m sure there are others I’m unfamiliar with, but let me tell you why I choose the InitParams: it’s easy, and it’s a one-way stream into Silverlight that doesn’t require any backward movement by the Silverlight app into its execution context. It simply doesn’t care. In fact, if I had some other way that I would like to instantiate my Silverlight app in a wholly different context, I could rely on data passed into InitParams to define its operation.

To achieve this, there are two code-snippets on the server side, and one on the Silverlight side to illustrate how this works:

SimpleCrmApp.aspx (line 69):

<param name="initParams" value="<%= BuildInitValue() %>" />

The snippet above, from the <object> container for the Silverlight control, instructs Silverlight to receive the value and pass it into the Startup event arguments. To construct the value, I have this function:

SimpleCrmApp.aspx.cs (lines 43 – 47):

protected string BuildInitValue()

    // build a series of parameters to be piped into the Silverlight app from the hosting control page

    return "callerId=" + callerId + ",orgName=" + orgName + ",serviceUrl=" + serviceUrl + ",authType=" + authType;

Since the values are being embedded into the host page by this function, I need to work with strings—which flows from the code in the first requirement. Then, it’s a matter of examining the values from the Startup event arguments in Silverlight:

App.xaml.cs (lines 30 – 34):

if (e.InitParams == null ||

    e.InitParams["callerId"] == String.Empty ||

    e.InitParams["orgName"] == String.Empty ||

    e.InitParams["serviceUrl"] == String.Empty)

    throw new ArgumentException("This Silverlight application requires values for callerId, orgName, urlScheme, and serviceUrl parameters.");

The snippet above occurs as the first statement in the handler Application_Startup(), which has been attached to the Startup event of the Application class in my custom constructor:

App.xaml.cs (line 20):

this.Startup += this.Application_Startup;

As you can see, the type StartupEventArgs (and its instance, e) expose the member InitParams, from which I obtain the values I submitted from the hosting page via its implementation of IDictionary.

So, now what? Well, since we have all of the necessary information to connect to CRM, it’s time to start working with the code from my first post.

Having an asynchronous interface to the endpoint methods

Since I have all the information I need to connect to CRM within the Application_Startup() call, I refrain from storing the information and instead use it immediately to construct an instance of my CrmServiceInstance class:

App.xaml.cs (lines 36 – 51):

// Construct a new CrmAuthenticationToken from some of the InitParams elements

CrmAuthenticationToken authToken = new CrmAuthenticationToken();

authToken.AuthenticationType = Convert.ToInt32(e.InitParams["authType"]);

// This is an important piece for determining proper IFD communication

if (authToken.AuthenticationType != 0)

    authToken.CallerId = new Guid(e.InitParams["callerId"]);

else

    authToken.CallerId = Guid.Empty;

authToken.OrganizationName = e.InitParams["orgName"];

// Create a new CrmServiceInstance and assign a new CrmServiceConnectionParams object to its ConnectionParams member

CrmServiceInstance crmService = new CrmServiceInstance();

crmService.ConnectionParams = new CrmServiceConnectionParams(e.InitParams["serviceUrl"], authToken);

In the snippet above, you can see that I’m constructing a new CrmAuthenticationToken object, with all the various input received through InitParams. I then pass this and the endpoint URL (also taken from InitParams) to the ConnectionParams member of crmService.

Because I perform these immediately upon the application startup, I have no need to examine the IsCrmServiceReady member or attach any handlers to the OnCrmServiceReady event—it is simply ready for me to proceed. However, I put an example of how this might be performed in this code snippet from the MainPage_Loaded() event handler:

MainPage.xaml.cs (lines 42 – 46):

// Validate the readiness of the crmServiceInstance before proceeding further; use an event handler to work out the kinks

if (!crmServiceInstance.IsCrmServiceReady)

    crmServiceInstance.OnCrmServiceReady += new EventHandler<EventArgs>(crmService_OnCrmServiceReady);

else

    crmService_OnCrmServiceReady(this, new EventArgs());

Where this event is handy, is if I had created my CrmServiceInstance in XAML—rather than directly in the code, as with this example.

From here, I pass crmService into the customized constructor for my MainPage class. Once this is done, a connection to CRM has been adequately defined and is now available for my Silverlight page, MainPage, to use for what follows.

What follows: Using CrmServiceSoapClient

Because Silverlight requires web-service interaction to operate in an asynchronous way (for non-interfering performance reasons), all of the traditional methods from [I]CrmService are implemented in CrmServiceSoapClient with an “Async” suffix. Execute() becomes ExecuteAsync(), and RetrieveMultiple() becomes RetrieveMultipleAsync(), for example. Working with these asynchronous counterparts can be perplexing, considering that they all have no return.

The returns are provided through events. Each traditional method not only has an “Async” representation in Silverlight, but also a “Completed” event; ExecuteCompleted and RetrieveMultipleCompleted, for example. This means that every method call to the web-services is handled by every active event handler registered to these events. This can complicate the design of your Silverlight application, to a degree—given that:

You should always have the event handler in place before the method is called; and
Every event handler will catch every execution of the method for the same CrmServiceSoapClient instance

For our example, however, all I need is a simple, one-time query for all active Account names. I achieve that with the following code in the crmService_OnCrmServiceReady() method (again, this method is an event handler for the CrmServiceInstance.OnCrmServiceReady event, and is not needed by the code, but provided for example purposes):

MainPage.xaml.cs (lines 51 – 66):

// Query for active accounts

QueryByAttribute query = new QueryByAttribute();

query.EntityName = EntityName.account.ToString();

query.Attributes = new string[] { "statecode" };

query.Values = new object[] { 0 };

// Query three specific string columns

ColumnSet columns = new ColumnSet();

columns.Attributes = new string[] { "name" };

query.ColumnSet = columns;

// Assign a handler to deal with the results, before triggering the execution of the query

crmServiceInstance.CrmService.RetrieveMultipleCompleted += new EventHandler<RetrieveMultipleCompletedEventArgs>(CrmService_RetrieveMultipleCompleted);

crmServiceInstance.CrmService.RetrieveMultipleAsync(query);

Note that one statement before I call RetrieveMultipleAsync(), I attach the handler CrmServce_RetrieveMultipleCompleted() to the RetrieveMultipleCompleted event. I do this to prevent any possible—though unlikely—race condition by which the thread processing the “RetrieveMultiple” message might finish and trigger the event, before the event handler is assigned.

So, interpreting the return is an important function of CrmService_RetrieveMultipleCompleted(). Here’s the body of that method:

MainPage.xaml.cs (lines 69 – 82):

void CrmService_RetrieveMultipleCompleted(object sender, RetrieveMultipleCompletedEventArgs e)

    // Instantiate a new List<account> for our results

    List<account> retrievedAccounts = new List<account>();

    // Assign the results of our query to the new List

    foreach (account a in e.Result.BusinessEntities)

        retrievedAccounts.Add(a);

    // Push the results into our RetrievedRecords data context

    RetrievedRecords.AccountRecords = retrievedAccounts;

As you can see, RetrieveMultipleCompletedEventArgs (as an instance, e) has a Result member that contains our retrieved records, much the same way as the traditional RetrieveMultipleResponse would.

The rest of my code operates the way a basic Silverlight application should when pushing data to the view. To make a long story short, I use a “ViewModel” for the data, represented by a collection of DisplayAccount. These are handled by the class CrmRecords, which serves as the type for the RetrievedRecords member of MainPage. These serve as abstractions of the account type to limit the amount of columns automatically generated by the DataGrid.

What follows: Bed Time

Ok, I’ve been up late working on this post. Time for bed. Hopefully, it all makes sense. Comment below if you have additional inquiries.