Handling Dynamic Subgrid Forms in Microsoft Dynamics 365 CRM with JavaScript

 

Understanding the Scenario

Imagine you have an Account entity in Dynamics 365 CRM with two subgrids:

1. N Subgrid – where you track NDA-related attachments.

2. S Check Subgrid – where you track internal review attachments.

When a user clicks “Add” on a subgrid, you want to:

• Open a Quick Create form for a related entity (e.g., Attachment).

• Prepopulate the type of attachment based on the subgrid.

• Associate the new record with the current account.

• Prevent users from modifying the preselected type.

This requires capturing which subgrid the user interacted with, storing the account context, and applying logic when the form loads.

Key Concepts in Dynamics 365 CRM

Before diving into code, here are a few Dynamics 365 concepts that we rely on:

• formContext – Represents the current form, giving access to fields, controls, and entity data.

• Xrm.Navigation.openForm – Opens a new form (main or quick create) programmatically.

• Quick Create Forms – Lightweight forms for adding related records quickly.

• Subgrid Controls – Interactive grids embedded in forms to display related records.

• Local Storage – Browser storage used temporarily to pass context between forms.

Reusable JavaScript Template

The following JavaScript module, AttachmentHandler, handles dynamic subgrid creation in a reusable way:

var AttachmentHandler = (function () {

    const STORAGE_KEYS = {
        ACCOUNT_ID: "parentAccountId",
        ACCOUNT_NAME: "parentAccountName",
        SOURCE_GRID: "sourceGridName"
    };

    const TYPES = {
        N: 100000000,
        S: 100000001
    };

    function openQuickCreate(selectedControl, formContext) {

        if (!parent.window.location.href.includes("etn=account&id=")) {
            return;
        }

        const accountId = formContext.data.entity.getId().replace("{", "").replace("}", "");
        const accountName = formContext.getAttribute("name").getValue();

        const gridName = selectedControl?._controlDescriptor?.Name || null;

        localStorage.setItem(STORAGE_KEYS.ACCOUNT_ID, accountId);
        localStorage.setItem(STORAGE_KEYS.ACCOUNT_NAME, accountName);
        localStorage.setItem(STORAGE_KEYS.SOURCE_GRID, gridName);

        const formParameters = {
            "custom_type": gridName === "subgrid_sanitycheck"
                ? TYPES.S
                : TYPES.N,
            "custom_account": [{
                id: accountId,
                name: accountName,
                entityType: "account"
            }]
        };

        const entityFormOptions = {
            entityName: "custom_attachment",
            useQuickCreateForm: true
        };

        Xrm.Navigation.openForm(entityFormOptions, formParameters);
    }

    function onLoad(formContext) {

        const accountName = localStorage.getItem(STORAGE_KEYS.ACCOUNT_NAME);
        const sourceGrid = localStorage.getItem(STORAGE_KEYS.SOURCE_GRID);

        if (!accountName) return;

        if (formContext.ui.getFormType() === 1) { // Create form

            const typeValue = sourceGrid === "subgrid_sanitycheck"
                ? TYPES.SANITY_CHECK
                : TYPES.NDA;

            const typeAttribute = formContext.getAttribute("custom_type");
            if (typeAttribute) {
                typeAttribute.setValue(typeValue);
                formContext.getControl("custom_type").setDisabled(true);
            }
        }
    }

    return {
        OpenQuickCreate: openQuickCreate,
        OnLoad: onLoad
    };

})();

How It Works

1. OpenQuickCreate Function

   • Determines the current account and the subgrid from which the user clicked.

   • Stores context in localStorage.

   • Opens a Quick Create form for the attachment entity with prefilled parameters.

2. OnLoad Function

   • Runs when the Quick Create form opens.

   • Retrieves the stored context from localStorage.

   • Prepopulates the type of attachment (NDA or Sanity Check) based on the originating subgrid.

   • Locks the field so users cannot modify it.

Benefits of This Approach

• Reusable: Can be applied to multiple subgrids or entities without hardcoding names.

• Maintainable: Clear separation of OpenQuickCreate and OnLoad.

• User-Friendly: Prepopulates fields to reduce user errors.

• Clean: Avoids global prefixes and cluttered code.

Implementation Tips

• Always use formContext instead of global Xrm.Page for modern CRM versions.

• Store temporary data in localStorage or sessionStorage when passing between forms.

• Use constants or enumerations for option set values (TYPES.NDA) instead of magic numbers.