Posted on 28. January 2014

Chrome Dynamics CRM Developer Tools

Chrome already provides a fantastic set of Developer tools for HTML/Javascript, but now thanks to Blake Scarlavai at Sonoma Partners we have the Chrome CRM Developer Tools.

This fantastic Chome add in provides lots of gems to make debugging forms and testing fetchXml really easy:

Form Information
- Displays the current form’s back-end information
- Entity Name
- Entity Id
- Entity Type Code
- Form Type
- Is Dirty
- Ability to show the current form’s attributes’ schema names
- Ability to refresh the current form
- Ability to enable disabled attributes on the current form (System Administrators only)
- Ability to show hidden attributes on the current form (System Administrators only)


Current User Information
- Domain Name
- User Id
- Business Unit Id


Find
- Ability to open advanced find
- Set focus to a field on the current form
- Display a specific User and navigate to the record (by Id)
- Display a specific Privilege (by Id)


Test
- Ability to update attributes from the current form (System Administrators only)
- This is helpful when you need to update values for testing but the fields don’t exist on the form


Fetch
- Execute any Fetch XML statement and view the results


Check it out in the chrome web store - https://chrome.google.com/webstore/detail/sonoma-partners-dynamics/eokikgaenlfgcpoifejlhaalmpeihfom

Posted on 2. November 2013

CRM 2013 Script Loading Deep Dive

Ever since the script Web Resource loading behaviour changed in UR12 from series to parallel I've been interested in how to best standardise management the loading of script Web Resources. The fact that scripts are loaded from a variety of places makes the subject even more interesting. This post attempts to answer all of my questions about how scripts are loaded.

In order to fully understand how CRM 2013 loads scripts I examined the following script load points:

1. Form Libraries

Each form can specify multiple libraries, and a set of Events Handlers that are called when the form is loaded.

2. Ribbon Xml Command Actions

Command Bar JavaScript functions that are called when a Command Bar button is clicked. Multiple JavaScriptFunctions can be included in a Command Action and is often used to specify dependency scripts. The following example shows common.js being a dependency to library.js. The 'isNaN' function is simply a dummy function call because common.js only needs to be loaded.

<Actions>
    <JavaScriptFunction FunctionName="isNaN" Library="$webresource:new_common.js" />  
    <JavaScriptFunction FunctionName="fooBar" Library="$webresource:new_library.js" />
</Actions>

3. Ribbon Xml Enable Rule

Enable Rule JavaScript functions are evaluated to determine if a Command Bar is enabled (visible). Again, multiple functions can be specified for an enable Rule and is often used to specify dependency scripts in the same way as shown above for Command Actions.

<EnableRule Id="new.new_valuerulestest.BoolYes.EnableRule">
    <CustomRule FunctionName="isNaN" Library="$webresource:new_ common.js" />
    <CustomRule FunctionName="fooBar" Library="$webresource:new_ library.js" />
</EnableRule>

Approach

I created 6 scripts that each used console.log to write messages as they were loaded and when the functions were being executed. I also used Fiddler to introduce latency into the script downloads so that I could see the order that they were being requested. The terminology I use is in the results are as follows:

  • Script Download - The process of downloading the script web resource from the server.
  • Script Load – The actual evaluation of the script once it has been downloaded from the server. The script load defines any functions and object prototypes. If you have any code that is not contained within a function, then it will be executed at this time. Script load order becomes important when the Script Load includes references to functions that exist in other libraries such as name spacing functions or jQuery constructs. It is advisable to keep these kind of dependencies to a minimum due to requirement to have scripts loaded in a particular order.
  • Script Event Handler – Function registrations that are called on form events such as OnLoad or OnChange that call a function in a loaded script web resource. The Event Handers are different to the Script Load in that the Event Handler is called after the Script has been loaded.
  • Executed – If there is a function that is referenced by an Enable Rule or Command, the function is executed after the script is loaded.

Here are the things you need to know!

The following section summaries the results I discovered from my deep-dive:

Form Scripts

1) Form Script will download in parallel unless they are already loaded by an EnableRule.

2) Form Scripts are not guaranteed to load in the order that they are specified in the form properties. They will be requested asynchronously in parallel and then loaded in the order that they received from the server. This is similar to the CRM2011 UR12-UR14 behaviour meaning that you can't guarantee that a dependency script is loaded before a dependant script without using some custom code to handle dependencies.

3) Form Script OnLoad Event Handlers will execute only after ALL script specified in the Form properties are loaded.

4) Form Scripts that are loaded only by the Form (and not Enable Rules) will appear as a 'normal' script element with WebResource URL in the IE F12 debugger.

Enable Rules

1) EnableRule CustomRule Scripts are downloaded, loaded & executed in series and in the order they are specified in the EnableRule. The next script is loaded after the previous one has been loaded and executed.
2) EnableRule functions are executed immediately after their script is loaded and before the OnLoad form even handler. The function is re-evaluated if the ribbon is refreshed and when the button is clicked (before the command action is executed).

3) Form Scripts will start downloading after all Enable Rule Scripts have been loaded and executed. The Command bar is then available before the form on-load event has been run.

4) An interesting by-product of the fact that Enable Rules load in series before the form scripts is that if you specify the same scripts in an Enable Rule that are referenced by the Form, your scripts will always load in the correct order! I had some situations like this on an upgrade from CRM2011 and I couldn't work out why on some forms the scripts were loaded in series and some in parallel.

5) Scripts loaded by EnableRules will appear as dynamic 'script block' and not a named WebResource URL in the IE F12 debugger.

Commands

1) Command Action JavaScript Function scripts are loaded and executed in series and in the order that they are specified in the Command.

2) Command Action scripts are loaded when the button is clicked and not when the page is loaded (unless they are used by the form or enable rules in which they are already loaded).

3) Scripts loaded by Command Actions will appear as dynamic 'script block' and not a named URL in the IE F12 debugger.

4) I found an interesting boundary condition that if the same scripts were used in the form load and in command actions; you could click the button before all the scripts were loaded so that only part of the command would run. This would have the potential to cause script errors if a user clicked on a command button before the on-load event had fired.

General

1) Scripts are loaded only once per page even if they are referenced in multiple places (Commands, EnableRule and Form Libraries).

Script Loading Process Flow

So that you can fully understand the script loading process, I've attempted to show a good approximation in flow chart form.

Key points of note on the flow:

  1. Enable Rule Scripts are loaded in series
  2. Form Scripts are loaded in Parallel.
  3. Command Action Scripts are loaded in series
  4. Command Actions can be executed before the Form Scripts are loaded.

     

Working around the parallel loading of Form Scripts

When parallel loading of scripts first became an issue in CRM2011 with UR12 I used a timeout style approach to waiting for dependant scripts to load. You can read more about this on my blog post on the subject.

Now rather than use a timeout wait, I feel that a more deterministic approach would be more suited. By wrapping the script web resources in the following, my tests showed that were always loaded in the correct order. The scriptLoader uses a dependency registration mechanism that allows registration of scripts to be loaded only when all of the dependant scripts are also loaded.

var scriptLoader = scriptLoader || {
    delayedLoads: [],
    load: function (name, requires, script) {
        window._loadedScripts = window._loadedScripts || {};
        // Check for loaded scripts, if not all loaded then register delayed Load
        if (requires == null || requires.length == 0 || scriptLoader.areLoaded(requires)) {
            scriptLoader.runScript(name, script);
        }
        else {
            // Register an onload check
            scriptLoader.delayedLoads.push({ name: name, requires: requires, script: script });
        }
    },
    runScript: function (name, script) {      
        script.call(window);
        window._loadedScripts[name] = true;
        scriptLoader.onScriptLoaded(name);
    },
    onScriptLoaded: function (name) {
        // Check for any registered delayed Loads
        scriptLoader.delayedLoads.forEach(function (script) {
            if (script.loaded == null && scriptLoader.areLoaded(script.requires)) {
                script.loaded = true;
                scriptLoader.runScript(script.name, script.script);
            }
        });
    },
    areLoaded: function (requires) {
        var allLoaded = true;
        for (var i = 0; i < requires.length; i++) {
            allLoaded = allLoaded && (window._loadedScripts[requires[i]] != null);
            if (!allLoaded)
                break;
        }
        return allLoaded;
    }
};

scriptLoader.load("Script Name", [("Dependency Script 1","Dependancy Script 2"}, function () {

// TODO: Your script goes here!

});

You must encapsulate every form script that is a dependant or a dependency. The load function has the following parameters:

  • Name – Specify a unique name of each of your scripts
  • Requires – Specify an array of script names that must be loaded before the current one is loaded.

Of course, the script can be minified to reduce its impact on your individual Web Resources.

Conclusions

Armed with the information I've discovered in this deep-dive, I feel I'm equipped to make the right decision when designing solutions that include multiple script Web Resources.

@ScottDurow

 

 

Posted on 8. August 2013

jQuery and jQuery UI with Dynamics CRM 2011 & 2013

Since I’ve been converting Silverlight web resources over to Html & JavaScript and working on www.SparkleXrm.com , I’ve worked extensively with jQuery and jQuery-UI.

In the early days of Dynamics CRM 2011, you could use both these libraries without a problem, but with the Activity Feeds solution an instance of jQuery appeared that interfered with your custom scripts.
This is still the case in Dynamics CRM 2013 and so here are some simple steps to ensure your libraries are safe and will co-exist with other instances from other solutions.

1. Decide on a custom ‘namespace’ for your jQuery library. I am using ‘xrmjQuery’

2. On the end of your jquery.js script add the following line:

/* jQuery script goes here */
window.xrmjQuery = jQuery.noConflict(true);

3. Inside your jquery_ui.js script (notice the ‘-‘ has been changed to an underscore since CRM doesn’t allow them in web resource names), wrap the whole file in the following lines:

(function ($,jQuery) {
	/*! jQuery UI Goes here */
})(window.xrmjQuery,window.xrmjQuery);

4. Inside your JavaScript web resource that use jQuery and jQuery-UI, wrap your code in the following:

(function($){
// Your Javascript goes here and can reference $ as usual
// e.g. var someField = $('#fieldName');
})(window.xrmjQuery);

This technique is called encapsulation and namespacing of jQuery.

My friend Carsten also has a blog post on a similar theme.

www.SparkleXrm.com uses the same technique and namespace is also ‘xrmjQuery’, so if you would like to quickly get access to the jQuery libraries in Dynamics CRM, you can install the SparkelXrm managed solution and include the web resource named ‘sparkle_/js/SparkleXrmUI_Dependancies.js’ – this is a single library that has both jQuery, jQueryUI as well as a few other goodies such as Knockout JS!

 

@ScottDurow

Posted on 29. March 2013

Asynchronous loading of JavaScript Web Resources after U12/POLARIS

We all know that UR12/POLARIS was a monumental release for Dynamics CRM what with the new Process Forms and Cross Browser support, but also included were some performance optimisations. One such improvement was a change to the way JavaScript Web Resources are loaded on forms so that they load and execute asynchronously rather than in the order that they were added to the form. The drawback with this optimisation is that it can cause the '..is undefined' script error if you have scripts that depend on other scripts being loaded first.

This post describes the loading behaviour and some possible solutions.

How did it work before UR12/POLARIS?

In my example I have 3 scripts, each dependant on the last. Mscorlib.js is the Script# system library that is needed before any other libraries can be loaded. I'm not talking about code that runs in the 'onload' event of a form but global code that is run after the script has downloaded used to define the prototypes of the objects that are used by the onload code.

In the Client.js, I might have some Script# generated code that requires a core Script# (ss.IEnumerable) type that is defined in a different script file.

Xrm.Sdk.DataCollectionOfEntity.registerClass('Xrm.Sdk.DataCollectionOfEntity', null, ss.IEnumerable);

For this code to run, the mscorlib.js must be loaded and executed first. The same applies if you are using jQuery and jQuery-UI.

The form definition used to have each script added in order so that they would be added to the 'head' section of the page as follows:

<head>
..
<script src=”/%7B635001685810000000%7D/WebResources/fdocs_/js/mscorlib.js” type=”text/javascript”></script>
<script src= /%7B635001685810000000%7D/WebResources/fdocs_/js/Xrm.js” type=”text/javascript”></script>
<script src=” /%7B635001685810000000%7D/WebResources/fdocs_/js/Client.js” type=”text/javascript”></script>
..

The resulting load pattern would be something like:

  • The script load/execution would be approximately:

    1. Mscrolib.js downloads and then executes
    2. Xrm.jsd downloads and then executes after mscrolib.js has completed executing since it follows it in the <HEAD> section of the page
    3. Client.js downloads and then executes after Xrm.js has completed executing since again it is added to the <HEAD> section in this order.
    4. The On Load event code then runs when all the scripts have loaded and finished executing

     

     

    What changes with the UR12/POLARIS update?

    Scripts are no longer in the <HEAD> section but are loaded asynchronously via the 'loadScriptAdv' function:

    loadScriptAdv('\x2f\x257B635001707050003339\x257D\x2fWebResources\x2ffdocs_\x2fjs\x2fmscorlib.js', '\x2f\x257B635001707050003339\x257D\x2fWebResources\x2ffdocs_\x2fjs\x2fmscorlib.js', false);
    loadScriptAdv('\x2f\x257B635001707050003339\x257D\x2fWebResources\x2ffdocs_\x2fjs\x2fXrm.js', '\x2f\x257B635001707050003339\x257D\x2fWebResources\x2ffdocs_\x2fjs\x2fXrm.js', false);
    loadScriptAdv('\x2f\x257B635001707050003339\x257D\x2fWebResources\x2ffdocs_\x2fjs\x2fClient.js', '\x2f\x257B635001707050003339\x257D\x2fWebResources\x2ffdocs_\x2fjs\x2fClient.js', false);
    

    The new asynchronous load behaviour results in the OnLoad being run after a smaller wait time since each script can execute without waiting for the preceding ones. This is a good performance gain but causes scripts to fail if the dependant scripts are not loaded at the point of execution.

  • The interesting thing is that this wasn't immediately apparent or was only an intermittent problem because once the scripts are loaded into the browser cache, the execution would usually be in the correct order. I can consistenly reproduce the issue by clearing down the browser cache and then disabling all caching.

    Ribbon JavaScript

    It's been a common technique to add dependant libraries to Ribbon Commands by adding them as Command Actions with a function of 'isNaN'

    <Actions>
    <JavaScriptFunction Library=”$webresource:mscorlib_crm.js” FunctionName=”isNaN”/>
    <JavaScriptFunction Library=”$webresource:xrm.js” FunctionName=”isNaN”/>
    <JavaScriptFunction Library=”$webresource:RibbonCommands.js” FunctionName=”someCommand”/>
    </Actions>
    
    

    It seems that the same issue exists with these libraries since they are loaded in an asynchronous fashion.

    Solutions

    Unfortunately, any solution that uses depending scripts in this way has to be updated – and like with all things, the right solution depends on your specific case.

    1) All script in a single library

    By far the simplest solution is to put all of your scripts into a single file in the correct order.

    I didn't' settle for single script option for the following reasons:

    1. A single script is harder to maintain
    2. Common libraries can't be shared between solutions
    3. All code must be downloaded on first use, rather than only downloading what is required at the time.

    2) RequireJs or HeadJs

    There are some good JavaScript loading libraries out there such as RequiresJs or HeadJs. These libraries allow you to dynamically load dependant script before you execute code that needs them.
    Gayan has an example of this technique on his blog. Maarten also has a good tutorial on his blog.

    I didn't settle for the RequireJs/HeadJs option for the following reasons:

    1. It requires you to manually set the Cache key to ensure that scripts are not downloaded every time they are needed
    2. It completely bi-passes the Dynamics CRM script loading mechanism in an 'unsupported' way
    3. There is some possibility that a backward compatibility option may be added into a future release (I'm ever the optimist!). Adopting this approach would make it harder to revert back to the standard script registration approach.

    3) Manually wait for required libraries to load

    The approach I took was to build a simple wait function to wrap code in that prevented execution until the required scripts had loaded. Each time a script completes, it adds its name to a semaphore array that is waited on by other libraries. The result is much the same as before UR12:

  • The difference here is that the scripts start executing as soon as they are loaded, but then wait using setTimeout until the required scripts have completed. The code will work on pre-UR12 systems as well, but because the wait is unnecessary, the code will simply execute the script without checking dependancies. setTimeout is used to release control to other scripts because Javascript is single-threaded.

    The Code

    Each script that has dependencies must be wrapped in the following:

    waitForScripts("client",["mscorlib", "xrm",],
    function () {
    //Original Code goes here
    });
    

    The first parameter provides the name of the current script, and the array is the list of scripts that must be loaded first.

    So in the Xrm.js library, you would wrap it in:

    waitForScripts("xrm",["mscorlib"],
    function () {
    //Original Code goes here
    });
    

    Each script must also include the waitForScript function at the bottom:

    function waitForScripts(name, scriptNames, callback) {
        var hasLoaded = false;
        window._loadedScripts = window._loadedScripts || [];
        function checkScripts() {
            var allLoaded = true;
            for (var i = 0; i < scriptNames.length; i++) {
                var hasLoaded = true;
                var script = scriptNames[i];
                switch (script) {
                    case "mscorlib":
                        hasLoaded = typeof (window.ss) != "undefined";
                        break;
                    case "jquery":
                        hasLoaded = typeof (window.jQuery) != "undefined";
                        break;
                    default:
                        hasLoaded = window._loadedScripts[script];
                        break;
                }
                allLoaded = allLoaded && hasLoaded;
                if (!allLoaded) {
                    setTimeout(checkScripts, 10);
                    break;
                }
            }
            if (allLoaded) {
                callback();
                window._loadedScripts[name] = true;
            }
        }
        // Only check for async loading of scripts if later than UR12/POLARIS
        if (typeof(APPLICATION_FULL_VERSION)!='undefined' && parseFloat(APPLICATION_FULL_VERSION.replace('5.0.',''))>9690.2835) {
    	setTimeout(checkScripts, 0);
        }
        else {
    	callback();
            window._loadedScripts[name] = true;
        }
    }

    Script# 'Script.template'

    I almost exclusively use Script# in my Dynamics CRM projects. What made this solution really work well for me was that I just include the code in the Script.template file to wrap the '#include[as-is] "%code%"'. The beauty is that I can now forget it's there and it just gets minified along with the rest of the code when deployed.

    This issue has affected a number of people I know, and I'm sure it'll start to become more of an issue as people start to upgrade to the latest Rollup. If you have any suggestions/comments, please let me know.

    The code was originally posted by me in the MSDN forums:

     http://social.msdn.microsoft.com/Forums/en-US/crmdevelopment/thread/fdca4779-e866-4e51-bab9-97a159f9cd37

     

    UPDATE: This issue is now fixed in UR15 -http://support.microsoft.com/kb/2843571

    @ScottDurow

    Posted on 12. January 2013

    getServerUrl is Deprecated. Use getClientUrl instead.

    Although at the time of writing UR12 is not yet released - I was checking though the changes in the latest SDK documentation.

    In addition to the Ribbon Workbench being listed (yay!) I noticed the following statement about the getServerUrl function

    "Deprecated. Use getClientUrl instead. This method is deprecated as of Microsoft Dynamics CRM 2011 Update Rollup 12 and the Microsoft Dynamics CRM December 2012 Service Update."

     

    Out with the old

     

    Using getServerUrl on it's own always had the potential to cause 'Access Denied' messages if the browser domain Url was different to the server Url stored in the CRM database. This was to do with cross domain access restrictions in IE. A work around was to use a method similar to Daniel Cai gives in his post on the subject - http://danielcai.blogspot.co.uk/2012/02/get-right-server-url-in-your-crm-client.html

    In with the new

    The SDK described the new getClientUrl as:

    "Returns the base URL that was used to access the application."

    The function nolonger blindly return the server Url in the database - but looks at the url that was used to access CRM so that cross domain access issues will be a thing of the past!

    Read more in the SDK:
    http://msdn.microsoft.com/en-us/library/d7d0b052-abca-4f81-9b86-0b9dc5e62a66#BKMK_getClientUrl

    @ScottDurow

     

    Posted on 27. September 2012

    Script# (ScriptSharp) delete statement

    I've been using Script# very succesfully for sometime now to generate CRM2011 Javascripts (you can get a version of the Xrm library for Script# at http://sharpxrmpage.codeplex.com/).

    I problem I encounted recently was where I needed to issue a delete statement. E.g.

    delete xmlDoc;

    There is only Type.DeleteField support in Script# which allows deleting of a field on an object, but there is no way of outputing a simple local scope delete statement.

    I orignally used:

    Script.Literal("delete xmlDoc");

    This worked fine for debug scripts, however when using the release scripts that are minified, of course the variable xmlDoc is output as something like $1_0 and so the literal statement fails.

    After some research I found that the following statement works:

    Script.Literal("delete {0}",xmlDoc);

    Hope this helps.

    Posted on 18. January 2012

    iPad killed the Silverlight star?

    After the initial Statement of Direction in May and then the interview with Brad Wilson the then general manager of Dynamics CRM, there has been quite some excitement about cross-browser support for Dynamics CRM 2011. The timescale given was "the first half of 2012" being release with UR8. The thought of access to Dynamics CRM from an iPad is quite an attractive prospect I have to admit - and I'm really excited to see how Microsoft are going to structure the CRM user interface when they deliver it through cross browser HTML5.

    • Are we going to get a single cross browser interface, or will there still be a IE specific one with richer functionality?
    • Will the cross browser support be more like the mobile client - with it's own form design - Will IE still be the preferred browser?
    • You will still need IE to use the Outlook Client so will the cross browser support be more of a 'selling point' than something that actually makes a significant difference to business users?

     

    Cross browser HTML5 will mean replacing the IE specific .htc 'behaviours' which is quite a considerable piece of work - but a subject closer to my heart is the future of Silverlight in CRM2011. Silverlight is supported on most modern browsers (http://www.microsoft.com/getsilverlight/get-started/install/default.aspx#) but not on iPads. Could this mean an end to Silverlight WebResources just so that we can get iPad support?

    Only time will tell, but it might make it harder to choose the developer productivity and user experience gains that come with Silverlight. The iPad is not a desktop replacement. There are limitations with SalesForce.com on the iPad (http://www.crmverse.com/using-salesforce-com-on-ipad/). Unless a client has decided to use iPads as a primary user interface device, I am still recomending developing Silverlight WebResources but structuring them in a way that will make it easier to port them to an HTML5 user interface when the developer tooling support is improved.

    Maybe with Windows 8 Tablets the problem will go away...then again...maybe not!

    References:

    Posted on 6. January 2012

    Adding an Advanced Find Query to a Form Sub grid

    I've yet to see a clear post on how to add an Advanced Find Query as a subgrid on an entity form for CRM 2011. This is something that was quite common in CRM 4 due to the lack of sub grid support - but with CRM 2011 occationally we come up against the limitation of only showing related records and fields of only a single relationship away from the root entity.

    Here are the steps:

    1. Find the SavedQueryId of the default advanced find view for the entity you are reporting on. Use the following SQL against the MSCRM database to find it:

    Select Name,SavedQueryId,ReturnedTypeCode,FetchXml,LayoutXml from SavedQuery where QueryType=1 and IsDefault=1
    Order by ReturnedTypeCode

    2. Create a webresource named 'new_SubGridFetchXml.htm' of type 'Web Page (HTML)'

    Provide the following html:

    
    <HTML><HEAD><TITLE></TITLE>
    <SCRIPT type=text/javascript src="ClientGlobalContext.js.aspx"></SCRIPT>
    <SCRIPT type=text/javascript>
        function submitForm() {
            var form = document.forms[0];
            var context = GetGlobalContext();
            form.action = context.getServerUrl() + '/AdvancedFind/fetchData.aspx';
            form.LayoutXml.value ='<LAYOUTXML>';
            form.FetchXml.value = '<FETCHXML>'
            form.submit();
             }
    </SCRIPT>
    <META charset=utf-8></HEAD>
    <BODY onload=submitForm()>
    <FORM method=post action="">
    <INPUT name=FetchXml type=hidden> 
    <INPUT name=LayoutXml type=hidden> 
    <INPUT name=EntityName value=contact type=hidden> 
    <INPUT name=DefaultAdvFindViewId value=<SavedQueryID> type=hidden> 
    <INPUT name=ViewId value=<SavedQueryID> type=hidden> 
    <INPUT name=ViewType value=4230 type=hidden> 
    <INPUT name=SortCol value=<SortColumnLogicalName>:1; type=hidden> 
    <INPUT name=UIProvider type=hidden> <INPUT name=DataProvider type=hidden> </FORM></BODY></HTML>
    
    

    Adjust the <SavedQueryID> reference to the default advanced find query id found in step 1.

    Adjust the <SortColumnLogicalName> to be the logical name of the field you want to sort by.

    Replace the LayoutXml and FetchXml strings with the values returned from the query in 1 - you can then adjust them to suit your particular needs.

    IMPORTANT:

    If you add the web resource to a sub 'virtual path', you must alter the reference to the ClientGlobalContext.js.aspx to include the corresponding number of '../'

    Don't worry about the script error when saving the page in the WebResource editor.

    Your finished page would look something like

    
    <HTML><HEAD><TITLE></TITLE>
    <SCRIPT type=text/javascript src="ClientGlobalContext.js.aspx"></SCRIPT>
    <SCRIPT type=text/javascript>
        function submitForm() {
            var form = document.forms[0];
            var context = GetGlobalContext();
            form.action = context.getServerUrl() + '/AdvancedFind/fetchData.aspx';
    form.LayoutXml.value ='<grid name="resultset" object="2" jump="lastname" select="1" icon="1" preview="1"><row name="result" id="contactid"><cell name="fullname" width="300" /><cell name="telephone1" width="125" /></row></grid>';
    form.FetchXml.value = '<fetch version="1.0" output-format="xml-platform" mapping="logical" distinct="false"><entity name="contact"><attribute name="fullname"/><attribute name="telephone1"/><attribute name="contactid"/><order attribute="fullname" descending="false"/></entity></fetch>';
                form.submit();
             }
    </SCRIPT>
    <META charset=utf-8></HEAD>
    <BODY onload=submitForm()>
    <FORM method=post action="">
    <INPUT name=FetchXml type=hidden> 
    <INPUT name=LayoutXml type=hidden> 
    <INPUT name=EntityName value=contact type=hidden> 
    <INPUT name=DefaultAdvFindViewId value={00000000-0000-0000-00AA-000000666400} type=hidden> 
    <INPUT name=ViewId value={00000000-0000-0000-00AA-000000666400} type=hidden> 
    <INPUT name=ViewType value=4230 type=hidden> 
    <INPUT name=SortCol value=fullname:1; type=hidden> 
    <INPUT name=UIProvider type=hidden> 
    <INPUT name=DataProvider type=hidden> </FORM></BODY></HTML>
    
    
    

    3. Add the webresource to the form that you want to show it on.

    4. Publish and Go!

    Usual disclaimers apply - and this is not a fully supported solution since it uses un-documented functionality

    Posted on 8. September 2011

    Calling a function in an HTML Web Resource from another JavaScript Web Resource

     

    If you have a field value on an entity form that an Html Web Resource is dependant on, you might have the following in your onload event of the Html Web Resource:

    var crmForm = window.parent.Xrm.Page;
    var lookup = crmForm.getAttribute("customerid").getValue();
    if (lookup != null) customerid = lookup[0].id;
    

     

    If so, will need to ensure that when this value changes, you update the values displayed on the html web resource. Rather than simply re-loading the web resource, it's going to be better for the user if you create a function to update the values without it blanking and re-loading.

    You can do this by implementing a function in your html web resource and then calling it from the onchange event of the dependent field:

    Xrm.Page.getControl("WebResource_<Name>").getObject().contentWindow.window.fooBar();
    

    Hope this helps.

     

    Posted on 3. June 2011

    Embedding CRM reports in IFrames using the CRM2011 Report Viewer

    It is quite common for users to request that reports be included in Iframes on forms, or in Dashboards. Although this can be done by pointing the Iframe directly at SQL Reporting services, this essentially bypasses the CRM Report connector and relies on the user authenticating directly with SQL Reporting Services and SQL Server. If you have SQL Server and Reporting Services on the same server or Kerberos is set up correctly, this isn't a problem. If however your users can only access the report through the CRM Front end, then you need to use the CRM Report review rather than the Reporting Services native one.

    1) Create a html web resource named 'ReportViewer' or similar

    <html>
    <head>
    <title></title>
    <script src="ClientGlobalContext.js.aspx" ></script>
    <script type="text/javascript">
        function submitForm() {
            var form = document.forms[0];
            var context = GetGlobalContext();
            form.action = context.getServerUrl() + '/CRMReports/rsviewer/reportviewer.aspx';
            form.uniquename.value = context.getOrgUniqueName();
    
            var query = window.location.search.substring(1);
            var vars = query.split("&");
            var idSet = false;
    
            for (var i = 0; i < vars.length; i++) {
                var pair = vars[i].split("=");
                switch (pair[0]) {
                    case 'data':
                        var params = unescape(pair[1]).split("&");
                        for (var j = 0; j < params.length; j++) {
                            var param = params[j].split("=");
                            switch (param[0]) {
                                case 'id':
                                    form.id.value = param[1];
                                    idSet = true;
                                    break;
                                case 'hideparams':
                                    form.PromptAreaCollapsed.value = param[1];
                                    break;
                                case 'iscustomreport':
                                    form.iscustomreport.value = param[1];
                                    break;
                                default:
                                    // Add any other values as report parameters
                                    var paramInput = document.createElement('input');
                                    paramInput.setAttribute('type', 'hidden');
                                    paramInput.setAttribute('name', 'p:' + param[0]);
                                    paramInput.setAttribute('value', param[1]);
                                    form.appendChild(paramInput);
                                    break;
                            }
                        }
                }
            }
            
    
            if (idSet) {
                form.submit();
            }
            else {
                // Show message
                var dvMessage = document.createElement("div");
                dvMessage.innerHTML ="Report Id is not set";
                form.appendChild(dvMessage);
    
            }
        }
        
    </script>
    </head>
    <body onload="submitForm()">
    <form action ="" method="post">
    <input type="hidden" name="id" value="{xxx}" />
    <input type="hidden" name="uniquename" value="" />
    <input type="hidden" name="iscustomreport" value="true" />
    <input type="hidden" name="reportName" value="Report Name" />
    <input type="hidden" name="isScheduledReport" value="false" />
    <input type="hidden" name="PromptAreaCollapsed" value="false" />
    </form>
    </body>
    </html>
    
    
    

    2) Include in a Dashboard or Webresource on a form using the following Web Resource Properties (The Customer Parameter Data field):

    Id={xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx} (make sure you add the curly braces)

    You can also pass any report parameters you have by adding on :

    param1=value1&param2=value2

    If you want to have the report parameters hidden by default use:

    &hideparams=true

     

    So the whole data field would be something like:

    Id={xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}&hideparams=true&param1=value1&param2=value2

    I don't want to spoil all your fun – so I'll leave you to add the query to lookup the id by passing in the report name rather than the ID!

    Have fun!