.Net'ers

** Note – the solution for this project is available for download.

I had a requirement to disable the export to excel functionality in CRM 2011. Fortunately, CRM has an privilege that can be set on security roles (open a security role, go to the Business Management tab and look under “Miscellaneous Privileges”) that enables or disables the export to Excel functionality. Unfortunately when this privilege is removed, users can’t save reports in any format such as a PDF file, an Excel file, a Word file, etc. (I understand that if you don’t want a user exporting to excel from a list view then why would you let them run a report and save it in Excel format, but it also removes the ability save as PDF. I didn’t make up this requirement.) I didn’t find much help in my searching the web so I started thinking about how I’d go about it. The idea that finally came to me was to do something like this:

1. Remove the standard MS CRM Export to Excel using the RibbonDiffXml.
2. Replace the standard MS CRM button with a custom button that looks like the standard Export to Excel button in the RibbonDiffXml.
3. Create a new security role that will determines if the user should have the Export to Excel functionality.
4. Create a custom EnableRule in the RibbonDiffXml that will get assigned to the custom button created above that calls a JavaScript function to check if a user has the needed security role to enable the Export to Excel button. If the user has that security role, the Export to Excel button will be enabled, otherwise it will be disabled.

Here are the steps to remove the standard Export to Excel button and replace it with a custom button that can be enabled/disabled based on security roles.

Step 1 – Create the Solution

Create a new solution – you can name it whatever you want. Add the “Application Ribbon” to this solution.

Step 2 – Create the Security Role

Create a new Security Role in MS CRM named “Export to Excel”. Capitalization matters because of the JavaScript involved later. You don’t need to grant any permissions to the role – just the existence of the role will be enough for the JavaScript to function correctly.

Step 3 – Modify the RibbonDiffXml

Modify the RibbonDiffXml so that does the following (these are general steps, specifics follow below):

1. Hides the existing Export to Excel button
2. Create a new Export to Excel button with a CommandDefinition and EnableRule that will call JavaScript that will return true or false which will enable or disable the new button.

I don’t want this to become a post on RibbonDiffXml, but I’ve found a dearth of info on how to customize the RibbonDiffXml, so I am going to explain what the RibbonDiffXml does in this particular instance. Below are more detailed steps on how to customize the RibbonDiffXml.

1. Export the solution created above.
2. Extract the “customizations.xml” from the exported solution zip file.
3. Edit the customizations.xml file and replace the entire RibbonDiffXml node and child nodes with the RibbonDiffXml (below).
4. Update the exported solution zip file with the updated customizations.xml file.
5. Import the updated solution file back into your CRM org.

Here is the RibbonDiffXml:

<RibbonDiffXml>
    <CustomActions>
      <HideCustomAction Location="Mscrm.HomepageGrid.{!EntityLogicalName}.ExportToExcel" HideActionId="TopLine.HomepageGrid.EntityName.ExportToExcel"></HideCustomAction>
      <CustomAction Id="TopLine.HomepageGrid.MainTab.ExportData.Controls.CustomAction" Location="Mscrm.HomepageGrid.{!EntityLogicalName}.MainTab.ExportData.Controls._children">
        <CommandUIDefinition>
          <Button Id="TopLine.HomepageGrid.{!EntityLogicalName}.ExportToExcel" ToolTipTitle="$Resources:Ribbon.HomepageGrid.Data.Export.ExportToExcel" ToolTipDescription="$Resources:Ribbon.Tooltip.ExportToExcel" Command="TopLine.ExportToExcel.Command" Sequence="35" LabelText="$Resources:Ribbon.HomepageGrid.Data.Export.ExportToExcel" Alt="$Resources:Ribbon.HomepageGrid.Data.Export.ExportToExcel" Image16by16="/_imgs/ribbon/exporttoexcel16.png" Image32by32="/_imgs/ribbon/exporttoexcel32.png" TemplateAlias="o2" />
        </CommandUIDefinition>
      </CustomAction>
      <HideCustomAction Location="Mscrm.SubGrid.{!EntityLogicalName}.ExportToExcel" HideActionId="TopLine.SubGrid.EntityName.ExportToExcel"></HideCustomAction>
      <CustomAction Id="TopLine.SubGrid.MainTab.ExportData.Controls.CustomAction" Location="Mscrm.SubGrid.{!EntityLogicalName}.MainTab.ExportData.Controls._children">
        <CommandUIDefinition>
          <Button Id="TopLine.HomepageGrid.{!EntityLogicalName}.ExportToExcel" ToolTipTitle="$Resources:Ribbon.HomepageGrid.Data.Export.ExportToExcel" ToolTipDescription="$Resources:Ribbon.Tooltip.ExportToExcel" Command="TopLine.ExportToExcel.Command" Sequence="21" LabelText="$Resources:Ribbon.HomepageGrid.Data.Export.ExportToExcel" Alt="$Resources:Ribbon.HomepageGrid.Data.Export.ExportToExcel" Image16by16="/_imgs/ribbon/exporttoexcel16.png" Image32by32="/_imgs/ribbon/exporttoexcel32.png" TemplateAlias="o1" />
        </CommandUIDefinition>
      </CustomAction>
    </CustomActions>
    <Templates>
      <RibbonTemplates Id="Mscrm.Templates"></RibbonTemplates>
    </Templates>
    <CommandDefinitions>
      <CommandDefinition Id="TopLine.ExportToExcel.Command">
        <EnableRules>
          <EnableRule Id="TopLine.ExportToExcel.Rule" />
        </EnableRules>
        <DisplayRules />
        <Actions>
          <JavaScriptFunction FunctionName="Mscrm.GridRibbonActions.exportToExcel" Library="/_static/_common/scripts/RibbonActions.js">
            <CrmParameter Value="SelectedControl" />
            <CrmParameter Value="SelectedEntityTypeCode" />
          </JavaScriptFunction>
        </Actions>
      </CommandDefinition>
    </CommandDefinitions>
    <RuleDefinitions>
      <TabDisplayRules />
      <DisplayRules />
      <EnableRules>
        <EnableRule Id="TopLine.ExportToExcel.Rule">
          <CustomRule FunctionName="CheckExportToExcelRole" Library="$Webresource:new_/js/DisableExportToExcel.js" Default="true" />
        </EnableRule>
      </EnableRules>
    </RuleDefinitions>
    <LocLabels />
  </RibbonDiffXml>

Here’s an image that has some numbered items that correspond to the numbers below with explanations of what the various components of the RibbonDiffXml does (click for a larger, more readable view):

1. Hide Custom Action – This is what hides the standard Export to Excel button when on the “HomepageGrid”. The {!EntityLogicalName} represents any entity. Below is a screen shot of the account HomepageGrid.

2. CustomAction – This is where the custom action (i.e., customization to the ribbon) for the HomepageGrid is defined.

3. CustomAction ID – This is a unique name for the customization we are making.

4. CustomAction Location – This defines where our button should be placed. The location tells it to appear on the Main tab for the entity, within the Export Data group, the controls within that group and it’s a part of the children. So, on the account list view, this would be the “Accounts” tab, the “data” group, and it’s one of the child controls.

5. CommandUI Definition – This is the section that defines the button we are placing in our CustomAction location.

6. Button definition ID – This is the name of the custom button.

7. Command – This is the name of the command that is associated with this button. The name here is important because it means there must be a CommandDefinition with the same name. The arrow in the above image of the RibbonDiffXml shows the two parts that are linked.

8. Sequence – This defines where within all the buttons our button should be placed.

Numbers 9 – 16 are essentially dupes of 1 – 8, but for the SubGrid as opposed to the HomepageGrid. A good way to think of the HomepageGrid is the list of items you see (such as accounts, contacts or opportunities) when in the main CRM window. The SubGrid is a list of items for a single record. So if you open the account form, you’ll see a list of contacts (a subgrid) and a list of opportunities (another subgrid).

9. Hide Custom Action – This is what hides the standard Export to Excel button when on the “SubGrid”. A SubGrid is a list of items when viewing the many items in a 1:N relationship. An example is the list of contacts when viewing an account detail page. The {!EntityLogicalName} represents any entity. Below is a screen shot of the contacts SubGrid on the account form.

10. CustomAction – This is where the custom action (i.e., customization to the ribbon) for the SubGrid is defined.

11. CustomAction ID – This is a unique name for the customization we are making.

12. CustomAction Location – This defines where our button should be placed. The location tells it to appear on the List Tools tab for the entity that makes up the N side in the 1:N relationship. (In the subgrid screen shot above, it’s the tab that’s currently selected). It specifies to show the within the Export Data group (labelled on the screen as Data), the controls within that group and it’s a part of the children.

13. CommandUI Definition – This is the section that defines the button we are placing in our CustomAction location.

14. Button definition ID – This is the name of the custom button.

15. Command – This is the name of the command that is associated with this button. The name here is important because it means there must be a CommandDefinition with the same name. The arrow in the above image of the RibbonDiffXml shows the two parts that are linked.

16. Sequence – This defines where within all the buttons our button should be placed.

17. This is the actual definition of the command (i.e., action) that should be associated with the button. Note the relationship between the ID and the Button definitions in the above image of the RibbonDiffXml.

18. This is the name of the rule that will be used to enable and disable the Export to Excel button. The arrow in the image shows that the name must be the same as the EnableRule in the RuleDefinitions section.

19. This is the name of the JavaScript function in the specified library that should be executed when the button is pressed. In this case we are specifying the exact same function that the standard button calls. Note that per this article (see the Ribbon Customization heading) this does not appear to be supported as this customization reuses the JavaScript functions defined in the ribbon commands, so two things to note: 1) unsupported doesn’t mean it won’t work, it’s just not supported, and 2) use this customization at your own risk. Also, you might want to keep this in mind during upgrades or when appying update rollups, as that’s the most likely time this might break.

20. This is the custom javascript rule. The FunctionName parameter is the javascript function name and the library is the name of the web resource to be called (created in the next step).

Step 4 – Create the JavaScript web resource

Create a new web resource named “new_/js/DisableExportToExcel.js”. The code should be as follows:

function UserHasRole(roleName) {
    var serverUrl = Xrm.Page.context.getServerUrl();
    var oDataEndpointUrl = serverUrl + "/XRMServices/2011/OrganizationData.svc/";
    oDataEndpointUrl += "RoleSet?$top=1&$filter=Name eq '" + roleName + "'";
    var service = GetRequestObject();
    if (service != null) {
        service.open("GET", oDataEndpointUrl, false);
        service.setRequestHeader("X-Requested-Width", "XMLHttpRequest");
        service.setRequestHeader("Accept", "application/json, text/javascript, */*");
        service.send(null);
        var requestResults = eval('(' + service.responseText + ')').d;
        if (requestResults != null && requestResults.results.length == 1) {
            var role = requestResults.results[0];
            var id = role.RoleId;
            var currentUserRoles = Xrm.Page.context.getUserRoles();
            for (var i = 0; i < currentUserRoles.length; i++) {
                var userRole = currentUserRoles[i];
                if (GuidsAreEqual(userRole, id)) {
                    return true;
                }
            }
        }
    }
    return false;
}

function GetRequestObject() {
    if (window.XMLHttpRequest) {
        return new window.XMLHttpRequest;
    }
    else {
        try {
            return new ActiveXObject("MSXML2.XMLHTTP.3.0");
        }
        catch (ex) {
            return null;
        }
    }
}
function GuidsAreEqual(guid1, guid2) {
    var isEqual = false;
    if (guid1 == null || guid2 == null) {
        isEqual = false;
    }
    else {
        isEqual = guid1.replace(/[{}]/g, "").toLowerCase() == guid2.replace(/[{}]/g, "").toLowerCase();
    }

    return isEqual;
}

function CheckExportToExcelRole() {
    if (UserHasRole("Export to Excel")) {
        return true;
    }
    else {
        return false;
    }

}

Step 5 – Set up users and test

To set things up to test you need to do several things.

• Remove the standard MS CRM “Export to Excel” privilege from ALL roles that you want to replace with the custom security functionality. Do this by opening each role, going to the Business Management tab and unselecting the “Export to Excel” privilege. (If you don’t want to modify the “base” roles, you can always copy them and modify the copy.)
• Set up a user without the system administrator and system customizer roles – just a regular user with a role such as Salesperson – just make sure the salesperson role has the standard MS CRM Export to Excel privilege removed.
• Make sure you publish all your changes.
• Log in as the salesperson user.
• Navigate to accounts or contacts – if everything is set up correctly then the “Export to Excel” button should be grayed out/disabled.
• Now, to test that your custom permission is working, log in as a system administrator user and grant the security role “Export to Excel” (created in step 2 above) to your “Salesperson” user and navigate to the accounts or contacts – the export to excel button should be enabled!
• Now that it’s working, all you need to do is grant the “Export to Excel” role to all other users.

The entire solution available for download here.