To get the original, full-resolution image, you must use the file streaming message requests. This post provides a clean, reusable approach to extracting full image data as either a Base64 string or raw byte[] data.

The Problem: The "Thumbnail Trap"

In Dataverse, image fields are optimized for performance. When you call entity.GetAttributeValue<byte[]>("your_field"), the platform serves a compressed version to save bandwidth. For high-quality email signatures, document generation, or external integrations, this thumbnail is usually too blurry to use.

The Solution: Multi-Block Downloading

To bypass compression, you must treat the image as a file and download it in "blocks" (chunks). This ensures you pull the raw, uncompressed data directly from the storage layer.

The Implementation

Copy the following methods into your helper class. This logic is sandbox-safe and designed for high performance within the 2-minute plugin execution limit.

(Note: Ensure you have Microsoft.Crm.Sdk.Messages included in your using statements).

1. The Entry Function: GetFullImageContent

This is the method you will call from your main logic. It allows you to toggle the return format using a Boolean parameter.

/// <summary>
/// Retrieves full-resolution image data from a record.
/// </summary>
/// <param name="service">The IOrganizationService instance.</param>
/// <param name="entityName">Logical name of the entity (e.g., "account").</param>
/// <param name="recordId">The GUID of the specific record.</param>
/// <param name="imageFieldName">The logical name of the image attribute.</param>
/// <param name="asBase64">Set to true for Base64 string, false for byte array string.</param>
/// <returns>A string containing the image data.</returns>
public string GetFullImageContent(IOrganizationService service, string entityName, Guid recordId, string imageFieldName, bool asBase64)
{
    if (recordId == Guid.Empty || string.IsNullOrEmpty(entityName) || string.IsNullOrEmpty(imageFieldName))
        return string.Empty;

    // Create the reference to the target record
    EntityReference recordRef = new EntityReference(entityName, recordId);

    // Call the helper to stream the full bytes
    byte[] imageBytes = DownloadFullImage(service, recordRef, imageFieldName);

    if (imageBytes == null || imageBytes.Length == 0)
        return string.Empty;

    // Return the format requested by the caller
    return asBase64 ? Convert.ToBase64String(imageBytes) : BitConverter.ToString(imageBytes);
}

2. The Internal Streaming Helper: DownloadFullImage

This method manages the initialization and the loop required to piece the image chunks back together.

private byte[] DownloadFullImage(IOrganizationService service, EntityReference recordRef, string attributeName)
{
    // 1. Initialize the download session
    var initializeRequest = new InitializeFileBlocksDownloadRequest()
    {
        Target = recordRef,
        FileAttributeName = attributeName
    };

    var initializeResponse = (InitializeFileBlocksDownloadResponse)service.Execute(initializeRequest);

    string fileToken = initializeResponse.FileContinuationToken;
    long fileSize = initializeResponse.FileSizeInBytes;
    List<byte> fullFile = new List<byte>((int)fileSize);

    long offset = 0;
    long blockSize = 4 * 1024 * 1024; // 4 MB Chunk Size

    // 2. Loop through and download blocks until complete
    while (offset < fileSize)
    {
        var downloadBlockRequest = new DownloadBlockRequest()
        {
            BlockLength = blockSize,
            FileContinuationToken = fileToken,
            Offset = offset
        };

        var downloadBlockResponse = (DownloadBlockResponse)service.Execute(downloadBlockRequest);
        
        fullFile.AddRange(downloadBlockResponse.Data);
        
        // Move the offset forward by the actual amount of data received
        offset += downloadBlockResponse.Data.Length;
    }

    return fullFile.ToArray();
}

Key Technical Considerations

• Enable "Store Full Image": This code will only return the high-resolution file if the "Store full image" option is enabled in the column's definition within the Power Apps Maker Portal.

• SDK Versions: Ensure your project is referencing Microsoft.CrmSdk.CoreAssemblies (v9.0.2.x or higher) to access the InitializeFileBlocksDownloadRequest and DownloadBlockRequest classes.

• Performance: While 4MB is the standard block size, the code will automatically handle smaller files in a single pass.

• Base64 Use Case: Use asBase64 = true if you are injecting the image into an HTML template or returning it via a Web API.

• Error Handling: In a production environment, always wrap these calls in a try-catch block and use the ITracingService to monitor the fileSize and offset during execution.

Summary

By ensuring your Dataverse columns are set to Store full image and using the Initialize/Download pattern instead of direct attribute access, you can ensure your Dynamics 365 solutions handle images with the highest possible fidelity.

Happy coding, Wizards!

The Challenge

The standard Power Apps Maker Portal and the classic Dynamics 365 CE interface often show when a solution was modified, but finding the specific metadata for a single assembly—specifically the Modified By and Created By system user details—can be a hassle.

The Solution: Using the Dataverse Web API

Every plugin assembly in Dynamics 365 CE / Power Platform is stored in the pluginassemblies table. By targeting the specific GUID of your assembly, you can expand the record to include details from the systemuser table.

The API Query

Replace <your-org.crm.dynamics.com> with your environment URL and <PLUGIN_GUID> with the unique ID of the assembly you are investigating.

HTTP

GET https://<your-org.crm.dynamics.com>/api/data/v9.2/pluginassemblies(<PLUGIN_GUID>)?$select=name,modifiedon,createdon
&\(expand=modifiedby(\)select=fullname,internalemailaddress),createdby($select=fullname,internalemailaddress)

Breakdown of the Query:

• $select=name,modifiedon,createdon: Narrows the results to the assembly name and the specific timestamps.

• $expand: The Web API equivalent of a "Join," allowing us to reach out to the linked systemuser table.

• modifiedby(...): Retrieves the Full Name and Email of the user who last updated the assembly.

• createdby(...): Retrieves the Full Name and Email of the user who has created the assembly.

Understanding the Output

When you run this query in your browser or a tool like Postman, you will receive a JSON response. This provides clear visibility into which account performed the deployment.

Example Response:

JSON

{
  "@odata.context": "https://<your-org>.crm.dynamics.com/api/data/v9.2/\(metadata#pluginassemblies(name,modifiedon,createdon,modifiedby(fullname,internalemailaddress),createdby(fullname,internalemailaddress))/\)entity",
  "name": "XRM.ABC.CRM.Plugins.Core",
  "createdon": "2026-01-22T01:32:54Z",
  "pluginassemblyid": "5e96d04e-5435-48c0-9c01-637a210620cd",
  "modifiedon": "2026-04-22T14:22:15Z",
  "modifiedby": {
    "internalemailaddress": "AProcess@xyz.com",
    "fullname": "Auto Process"
  },
  "createdby": {
    "internalemailaddress": "AProcess@xyz.com",
    "fullname": "Auto Process"
  }
}

How to Find the Plugin GUID

If you don't have the GUID handy, you can find it using these common Dynamics 365 CE / Power Platform tools:

1. XrmToolBox: Use the Plugin Registration Tool or Metadata Browser.

2. Web API: Run a general query to list all assemblies: GET https://<your-org.crm.dynamics.com>/api/data/v9.2/pluginassemblies?$select=name,pluginassemblyid

Why This Matters

• Accountability: Easily identify which developer or service account (like "Auto Process") deployed the code.

• Troubleshooting: Compare the modifiedon date with the time a bug was first reported.

• Environment Auditing: Ensure that deployments across your Dynamics 365 CE and Power Platform instances follow your team's governance policies.

Pro-Tip: The Browser Shortcut

You don’t need a specialized tool to run this. As long as you are logged into your Dynamics 365 CE / Power Platform environment, you can paste the API URL directly into a new browser tab. The browser uses your authenticated session to return the data immediately!

You may need to block auto save when:

• A Canvas App or dialog is collecting additional data

• Auto-save triggers Power Automate flows too early

• Required fields are not yet filled

• You want to force users to save manually

• Background saves cause inconsistent or incomplete updates

In such situations, blocking auto save across the form—or only under specific conditions—can prevent unwanted logic from running prematurely.

Why Auto Save Can Cause Problems

Dynamics CE automatically performs a save every 30 seconds and during certain background operations.
This can cause issues like:

• Power Automate flows firing without required data

• Incomplete values (like file names) passed to plugins

• Business rules executing too early

• Canvas App dialogs submitting half-filled records

To avoid these issues, you can stop auto-save using JavaScript.

JavaScript Code to Block Auto Save

Here is the core script:

function blockAutoSave(eContext) {
    var saveEvent = eContext.getEventArgs();
    if (saveEvent.getSaveMode() === 70 || saveEvent.getSaveMode() === 2) {
        // autosave or background save
        saveEvent.preventDefault();
    }
}

Three Ways to Use This Script

Dynamics CE gives you complete flexibility depending on your scenario.

Option 1: Block Auto Save Permanently for the Form

Attach only the function blockAutoSave to the form’s On Save event.

This will:

• Block auto-save for the entire form

• Allow manual Save to work normally

Steps:

1. Open the Form Editor

2. Go to Form Properties

3. Add your JS Web Resource

4. Add event handler under "On Save":

   • Function name: blockAutoSave

   • Check Pass execution context

5. Publish

This option is ideal when an entity should never auto-save (e.g., Cases, custom entities with complex logic).

Option 2: Block Auto Save Only in Specific Scenarios

You can call:

formContext.data.entity.addOnSave(blockAutoSave);

This allows you to block auto save only when needed, for example:

• When your Canvas App dialog is open

• When required fields are empty

• When a specific flag or checkbox is true

• When the user executes a ribbon button action

This gives you more control because you decide when auto save should be blocked.

Option 3: Dynamically Add or Remove the Auto-Save Blocker

You can also enable or disable the blocker during runtime based on conditions.

Add the blocker

formContext.data.entity.addOnSave(blockAutoSave);

Remove the blocker

formContext.data.entity.removeOnSave(blockAutoSave);

⚠ Important

The function reference must be exactly the same.
This works:

formContext.data.entity.removeOnSave(blockAutoSave);

This does NOT work:

formContext.data.entity.removeOnSave(function(e){ ... }); // new function reference

Example: Enable or Disable Auto-Save Based on a Field Value

function onLoad(eContext) {
    var formContext = eContext.getFormContext();
    var isBlockingEnabled = formContext.getAttribute("new_enableblock").getValue();

    if (isBlockingEnabled === true) {
        // Block auto-save
        formContext.data.entity.addOnSave(blockAutoSave);
    } else {
        // Allow auto-save
        formContext.data.entity.removeOnSave(blockAutoSave);
    }
}

function blockAutoSave(eContext) {
    var saveEvent = eContext.getEventArgs();
    if (saveEvent.getSaveMode() === 70 || saveEvent.getSaveMode() === 2) {
        saveEvent.preventDefault();
    }
}

This is extremely useful when you want fine-grained control.

SaveMode Values Used in This Script

Dynamics 365 CE uses different Save Modes to indicate why a save was triggered. When your JavaScript OnSave event handler executes, you can inspect the Save Mode to decide what should happen.

Below are the relevant codes used when blocking auto save:

Why These Two Save Modes Are Blocked

These two modes—2 (Auto Save) and 70 (Background Save)—are the ones that Dynamics triggers without the user manually clicking Save, Save & Close, or Save & New.

Blocking them ensures that:

• Unfinished or partial data does not get saved

• Power Automate or plugin logic is not triggered prematurely

• Canvas App dialogs or additional UI components can work safely without the system trying to commit changes

• Users maintain control of when the record is saved

What Is Not Blocked

Your script does not block:

• Manual Save (Save Mode 1)

• Save & Close

• Save & New

• Script-triggered save operations (unless you explicitly check for them)

This ensures that users can still save the form normally—only auto or background saves are prevented.

By filtering only on Save Modes 2 and 70, the script provides protection from unwanted auto-saves while still allowing users to save intentionally.
This approach keeps the system predictable, prevents accidental triggers, and gives full control back to the user or your custom logic.

Step-by-Step Setup

1. Create a JavaScript Web Resource

• Go to Advanced Settings → Customizations → Solutions

• Add a new JS Web Resource

• Paste the script

• Save and publish

2. Add the Script to Your Form

Depending on which option you choose, attach:

• Only the function (blockAutoSave)

• Or call addOnSave() dynamically

• Or add/remove the event based on conditions

Conclusion

With a small amount of JavaScript, you gain full control over how data is saved in Microsoft Dynamics 365 CE.

You now have three powerful techniques:

1. Block auto save permanently for the entire form

2. Block auto save only in specific scenarios

3. Add or remove the auto-save blocker dynamically, based on real-time conditions

This prevents accidental triggers, incomplete data saves, and unwanted flows—keeping your system stable and predictable.

This blog will walk you through the process step by step.

Lets say you have a knowledge article with 3 attachments:

Step 1: Get the Knowledge Article ID

Before you can retrieve attachments, you need the Knowledge Article ID (knowledgearticleid) of the article that has attachments. This ID will be passed into the FetchXML query.

You can extract the knowledge article id from the URL:

Example:

86284168-ac72-4f7d-ae1b-7e1e68b0c8ca

Step 2: Build the FetchXML Query

Use the following FetchXML to retrieve attachments for a given knowledge article. Replace the knowledgearticleid value with your own.

<fetch version="1.0" output-format="xml-platform" mapping="logical" returntotalrecordcount="true" no-lock="false">
  <entity name="msdyn_kbattachment">
    <attribute name="msdyn_fileicon_url" />
    <attribute name="statecode" />
    <attribute name="msdyn_filename" />
    <attribute name="msdyn_filesize" />
    <attribute name="msdyn_kbattachmentid" />
    <attribute name="msdyn_filetype" />
    <order attribute="msdyn_filename" descending="false" />
    <link-entity name="msdyn_msdyn_kbattachment_knowledgearticle" intersect="true" visible="false" to="msdyn_kbattachmentid" from="msdyn_kbattachmentid">
      <link-entity name="knowledgearticle" from="knowledgearticleid" to="knowledgearticleid" alias="ka">
        <filter type="and">
          <condition attribute="knowledgearticleid" operator="eq" uitype="knowledgearticle" value="86284168-ac72-4f7d-ae1b-7e1e68b0c8ca" />
        </filter>
      </link-entity>
    </link-entity>
  </entity>
</fetch>

This query will return the following details for each attachment:

• File Name (msdyn_filename)

• File Size (msdyn_filesize)

• File Type (msdyn_filetype)

• Attachment ID (msdyn_kbattachmentid)

• File Icon URL (msdyn_fileicon_url)

• State Code (statecode)

Response:

Step 3: Download the Attachment Content

Once you have the msdyn_kbattachmentid from the FetchXML results, you can retrieve the actual file content using a Web API HTTP GET request.

Example request:

GET https://<your_org>.api.crm4.dynamics.com/api/data/v9.2/msdyn_kbattachments(<msdyn_kbattachmentid>)/msdyn_fileattachment

For example:

GET https://yourorg.api.crm4.dynamics.com/api/data/v9.2/msdyn_kbattachments(2b76e2ec-ce9a-f011-b4cc-000d3adead23)/msdyn_fileattachment

This will return a response a JSON with the base64-encoded file content.

{
"@odata.context": "https://yourorg.api.crm4.dynamics.com/api/data/v9.2/$metadata#msdyn_kbattachments(2b76e2ec-ce9a-f011-b4cc-000d3adead23)/msdyn_fileattachment",
"value": "JVBERi0xLjQKJeLjz9MKNCAwIG9iago8PC9UeXBlL..."
}

Step 4: Parse the JSON and Decode the Base64 Content

The HTTP GET response will return JSON with the value property containing the base64-encoded file.

Example:

{
  "@odata.context": "https://<org>.api.crm4.dynamics.com/api/data/v9.2/$metadata#msdyn_kbattachments/msdyn_fileattachment",
  "value": "JVBERi0xLjQKJeLjz9MKNCAwIG9iago8PC9UeXBlL..."
}

To save the file locally in C#:

// Extract base64 string from JSON response
string base64FileContent = jsonResponse["value"].ToString();

// Decode and save
byte[] fileBytes = Convert.FromBase64String(base64FileContent);
File.WriteAllBytes(@"C:\\Downloads\\Attachment.pdf", fileBytes);

Summary

• Use FetchXML to retrieve attachment metadata related to a knowledge article.

• Get the Attachment ID (msdyn_kbattachmentid).

• Call the Web API GET endpoint /msdyn_fileattachment to fetch the base64 content.

• Parse the JSON and Decode the base64 string and save the file locally.

This approach helps you programmatically fetch and download knowledge article attachments stored in Dynamics 365.

Prerequisites

Before you start, make sure you have:

• An app registered in Azure Active Directory

• The proper API permissions for Dynamics CRM

• Your Client ID and Client Secret

Step 1: Get an Access Token

You first need to authenticate with Azure AD. Send a POST request to the token endpoint:

POST: https://login.microsoftonline.com/{tenant_id}/oauth2/token

Headers:

Content-Type: application/x-www-form-urlencoded

Body:

grant_type=client_credentials
client_id={your_client_id}
client_secret={your_client_secret}
resource=https://yourorg.crm.dynamics.com/

This will return an access token you can use to call the API.

Step 2: Fetch Environments

With the token, send a GET request to the Power Platform environments API:

GET https://api.powerplatform.com/providers/Microsoft.BusinessAppPlatform/environments?api-version=2020-10-01

Headers:

Authorization: Bearer {access_token}
Content-Type: application/json

Step 3: Review the Response

The response will include all available environments with details like:

{
  "value": [
    {
      "id": "12345",
      "name": "Default",
      "location": "North America",
      "state": "Ready"
    },
    {
      "id": "67890",
      "name": "Sandbox",
      "location": "Europe",
      "state": "Ready"
    }
  ]
}

Step 4: Use the Data

Now that you have the list, you can use it in your application—for example, to let users pick which environment they want to work with.

Conclusion

Fetching available environments is a simple but powerful step when working with Dynamics 365 CRM. It allows you to dynamically manage solutions, automate processes, and build more flexible applications.

Understanding the Scenario

Consider a scenario where we need to fetch activities from Dynamics 365 CE and PowerApps and apply filters on related entities. Specifically, we want to filter activities based on a group attribute in two linked entities: contact and account. We need to use an OR condition to match the group attribute in either of the linked entities.

The FetchXML Query

Here's the FetchXML query with the OR condition applied to the linked entities:

<fetch version="1.0" output-format="xml-platform" mapping="logical" distinct="true">
    <entity name="activitypointer">
        <attribute name="activitytypecode" />
        <attribute name="subject" />
        <attribute name="statecode" />
        <attribute name="prioritycode" />
        <attribute name="modifiedon" />
        <attribute name="activityid" />
        <attribute name="instancetypecode" />
        <attribute name="community" />
        <attribute name="regardingobjectid" />
        <order attribute="modifiedon" descending="false" />
        <link-entity name="contact" from="contactid" to="regardingobjectid" link-type="outer" alias="an">
            <link-entity name="xrm_borrowercustomnn" from="xrm_borrower" to="contactid" link-type="outer" alias="ao" />
        </link-entity>
        <link-entity name="account" from="accountid" to="regardingobjectid" link-type="outer" alias="ap">
            <link-entity name="xrm_borrowercustomnn" from="xrm_borrower" to="accountid" link-type="outer" alias="aq" />
        </link-entity>
        <filter type="or">
            <condition entityname="ao" attribute="xrm_group" operator="eq" value="{C907238B-1B14-EF11-9F89-000D3AF2E8B8}" />
            <condition entityname="aq" attribute="xrm_group" operator="eq" value="{C907238B-1B14-EF11-9F89-000D3AF2E8B8}" />
        </filter>
    </entity>
</fetch>

Explanation of the FetchXML Query

Let's break down the key parts of this FetchXML query:

• Entity: We are querying the activitypointer entity to fetch various activity attributes such as subject, statecode, prioritycode, and modifiedon.

• Linked Entities: We are linking to the contact and account entities using outer joins. These linked entities have a further link to a custom entity xrm_borrowercustomnn.

• Filter Condition: The filter element is of type or, meaning it will match any of the conditions inside it. The conditions check if the xrm_group attribute in either the contact or account entity matches the specified value.

Practical Usage

This FetchXML query can be used in various scenarios where complex filtering is required. For example, you might want to display activities related to specific groups in a dashboard or report. By using the OR condition, you ensure that activities linked to either a contact or account with the specified group are included in the results.

Conclusion

Adding OR conditions in linked entities within FetchXML queries can significantly enhance the flexibility of your data retrieval in Dynamics 365 CE and PowerApps. By understanding and applying these techniques, you can create more powerful and efficient queries tailored to your business needs.

We hope this guide has been helpful. If you have any questions or need further assistance, feel free to leave a comment below.

This method is perfect for site owners or users with "Read" permissions who need a quick report of what's been deleted.

What You'll Need

• A web browser: Chrome, Edge, or Firefox.

• Access to your SharePoint site: You must be logged in with sufficient permissions to view the Recycle Bin.

• The JavaScript code snippet: Provided below.

Step 1: Navigate to the SharePoint Recycle Bin

First, open your web browser and go to your SharePoint site's Recycle Bin. You can usually find this by going to Site Contents and clicking Recycle Bin at the top right of the page.

Your URL will look something like this: https://yourdomain.sharepoint.com/sites/<YourSite>/_layouts/15/RecycleBin.aspx

Step 2: Open the Developer Console (F12)

Now, we need to access the browser's developer tools. This is where we'll paste and run our code.

• On Windows, press F12 or Ctrl + Shift + I.

• On macOS, press Cmd + Option + I.

This will open the Developer Tools panel. Click on the Console tab.

Step 3: Enable Paste in the Console

For security reasons, some browsers (like Chrome and Edge) will prevent you from pasting code directly into the console. You'll see a warning message like "Do not paste code here unless you understand what you're doing."

To bypass this, you'll need to type allow pasting or a similar command into the console and hit Enter. Follow the specific instructions provided in the warning message to enable pasting.

Step 4: Paste and Customize the Code

Copy the following JavaScript code snippet. This script is designed to page through the SharePoint API, retrieve all items from the Recycle Bin, and then automatically compile and download a CSV file.

async function getAllRecycleBinItems() {
  // ⚙️ USER CONFIGURATION: Update these variables for your specific needs
  const siteUrl = "https://yourOrg.sharepoint.com/sites/accounting"; // Your SharePoint site URL
  const rowLimit = 5000; // Number of items to fetch per API call (max 5000)
  const itemState = 1; // 1 for first-stage recycle bin, 2 for second-stage

  // 🤖 DO NOT EDIT THE CODE BELOW THIS LINE
  let all = []; // Array to store all collected Recycle Bin items
  let keepOnRunning = true;
  let lastRecordId = null; // Used for paging: ID of the last item in the previous result set
  let lastRecordTitle = null; // Used for paging: Title of the last item
  let lastRecordDeletedDate = null; // Used for paging: DeletedDate of the last item
  let currentPage = 1; // Counter for logging progress

  try {
    // Construct URL for the first page fetch
    let url = `\({siteUrl}/_api/web/GetRecycleBinItemsByQueryInfo(rowLimit=@a1,isAscending=@a2,itemState=@a3,orderby=@a4,ShowOnlyMyItems=@a5)?@a1='\){rowLimit}'&@a2=false&@a3=${itemState}&@a4=3&@a5=false`;

    console.log(`Starting to retrieve items from the Recycle Bin at: ${siteUrl}`);
    const resp = await fetch(url, {
      headers: { "Accept": "application/json;odata=verbose" }
    });

    if (!resp.ok) {
      // Check for a non-200 HTTP status code and throw an error
      throw new Error(`HTTP error! status: ${resp.status}`);
    }

    const data = await resp.json();
    // Navigate the JSON response to find the results array
    const page = data?.d?.GetRecycleBinItemsByQueryInfo || data?.d;
    let results = page?.results || [];

    if (results.length > 0) {
      // Map the results to a new array with only the required properties
      const selected = results.map(item => ({
        Title: item.Title,
        DirName: item.DirName,
        DeletedByName: item.DeletedByName,
        DeletedDate: item.DeletedDate,
        ItemType: item.ItemType,
        Size: item.Size
      }));
      all.push(...selected); // Add the mapped items to the main array
    }

    console.log(`✅ Page \({currentPage} fetched. Retrieved \){results.length} items. Total so far: ${all.length}.`);

    // Check if there are more pages to fetch
    if (results.length === rowLimit) {
      // Get the last item's details for the next page's URL
      lastRecordId = results[rowLimit - 1].Id;
      // Replace single quotes in the title to prevent URL errors
      lastRecordTitle = results[rowLimit - 1].Title.replace(/'/g, "%27");
      lastRecordDeletedDate = results[rowLimit - 1].DeletedDate.replace("Z", "");
    } else {
      keepOnRunning = false; // No more pages to fetch
    }

    // Loop to fetch all subsequent pages
    while (keepOnRunning) {
      currentPage++;
      // Encode the paging values for the URL
      const encodedId = encodeURIComponent(lastRecordId);
      const encodedTitle = encodeURIComponent(lastRecordTitle);
      const encodedDate = encodeURIComponent(lastRecordDeletedDate);
      // Construct the PagingInfo string
      const pagingInfo = `id=\({encodedId}&title=\){encodedTitle}&searchValue=${encodedDate}`;

      // Construct URL for subsequent pages, including the encoded PagingInfo
      let url2 = `\({siteUrl}/_api/web/GetRecycleBinItemsByQueryInfo(rowLimit=@a1,isAscending=@a2,itemState=@a3,orderby=@a4,pagingInfo=@a5,ShowOnlyMyItems=@a6)?@a1='\){rowLimit}'&@a2=false&@a3=\({itemState}&@a4=3&@a5='\){encodeURIComponent(pagingInfo)}'&@a6=false`;

      try {
        const resp2 = await fetch(url2, {
          headers: { "Accept": "application/json;odata=verbose" }
        });

        if (!resp2.ok) {
          throw new Error(`HTTP error! status: ${resp2.status}`);
        }

        const data2 = await resp2.json();
        const page2 = data2?.d?.GetRecycleBinItemsByQueryInfo || data2?.d;
        results = page2?.results || [];

        if (results.length > 0) {
          const selected = results.map(item => ({
            Title: item.Title,
            DirName: item.DirName,
            DeletedByName: item.DeletedByName,
            DeletedDate: item.DeletedDate,
            ItemType: item.ItemType,
            Size: item.Size
          }));
          all.push(...selected);
        }

        console.log(`✅ Page \({currentPage} fetched. Retrieved \){results.length} items. Total so far: ${all.length}.`);

        if (results.length === rowLimit) {
          lastRecordId = results[rowLimit - 1].Id;
          lastRecordTitle = results[rowLimit - 1].Title.replace(/'/g, "%27");
          lastRecordDeletedDate = results[rowLimit - 1].DeletedDate.replace("Z", "");
        } else {
          keepOnRunning = false;
        }

      } catch (error) {
        // Log the specific error for this page and stop the loop
        console.error(`❌ An error occurred during page ${currentPage} retrieval:`, error);
        keepOnRunning = false;
      }
    }

    console.log(`\n🎉 All items have been retrieved.`);
    console.log(`Final retrieved records count: ${all.length}.`);

    if (all.length > 0) {
      // Prepare data for CSV
      const headers = Object.keys(all[0]).join(",");
      const rows = all.map(obj =>
        // Format each value, handling commas and quotes within the data
        Object.values(obj).map(v => `"${String(v).replace(/"/g, '""')}"`).join(",")
      );
      const csv = [headers, ...rows].join("\n");

      // Trigger the browser to download the CSV file
      const blob = new Blob([csv], { type: "text/csv" });
      const link = document.createElement("a");
      link.href = URL.createObjectURL(blob);
      link.download = "RecycleBinItems.csv";
      document.body.appendChild(link);
      link.click();
      document.body.removeChild(link);

      console.log(`⬇️ CSV downloaded with ${all.length} records.`);
    }

  } catch (error) {
    // Log any errors from the initial fetch or overall process
    console.error("❌ An error occurred:", error);
    console.log("Process terminated due to an error.");
  }
}
getAllRecycleBinItems();

Before pasting, you must customize the siteUrl variable at the top of the code to match your SharePoint site. For example, if your site is at https://yourcompany.sharepoint.com/sites/accounting, change the line to:

const siteUrl = "https://yourcompany.sharepoint.com/sites/accounting";

Step 5: Run the Code

After pasting the code, press Enter.

The script will immediately begin to run. You will see progress messages in the console, showing how many items have been fetched on each page. The process will continue automatically, retrieving pages of up to 5,000 items at a time.

Once the script has fetched all the items, you will see a final success message in the console.

Step 6: Download the CSV File

After the final message appears, your browser will automatically prompt you to save a file named RecycleBinItems.csv.

If your browser blocks the download, you may need to check your browser's download settings or a pop-up blocker. The console will also log a message, ⬇️ CSV downloaded..., confirming the action.

Open the downloaded file in a spreadsheet program like Microsoft Excel or Google Sheets to view all your SharePoint Recycle Bin items, including their titles, deletion dates, and who deleted them.

That's it! You've successfully exported your SharePoint Recycle Bin contents without needing any administrative tools or special software.

Conclusion

By using this straightforward JavaScript approach, you can efficiently bypass the typical limitations of SharePoint's user interface, which often hides important data behind multiple clicks and lacks an export function. This method empowers you to quickly generate an auditable record of all deleted files and items, providing valuable insights into a site's history and helping you manage its content more effectively. This technique demonstrates how a few lines of code can solve a common problem, offering a powerful alternative to complex administrative tools and saving you time.

• How to use IPluginExecutionContext to access context and target entity.

• How to use IOrganizationService for CRUD operations.

• How to run queries using QueryExpression and FetchXML (with advanced examples).

• How to execute special requests using the service.

• Practical use cases where each technique is applied.

Whether you’re starting with plugins or looking to refine your expertise, this blog will serve as a comprehensive reference.

Understanding Context and Target

When a plugin executes, the platform provides important runtime information through the IPluginExecutionContext. This includes details such as:

• The message (e.g., Create, Update, Delete).

• The primary entity name.

• The stage in the pipeline (PreValidation, PreOperation, PostOperation).

• Input and output parameters.

The most important input parameter is often the Target, which represents the record that triggered the event.

Example: Accessing Context and Target

public void Execute(IServiceProvider serviceProvider)
{
    IPluginExecutionContext context = (IPluginExecutionContext)
        serviceProvider.GetService(typeof(IPluginExecutionContext));

    IOrganizationServiceFactory serviceFactory =
        (IOrganizationServiceFactory)serviceProvider.GetService(typeof(IOrganizationServiceFactory));
    IOrganizationService service = serviceFactory.CreateOrganizationService(context.UserId);

    if (context.InputParameters.Contains("Target") && context.InputParameters["Target"] is Entity entity)
    {
        string logicalName = entity.LogicalName;
        Guid id = entity.Id;

        // Example use case: Log the target entity
        tracingService.Trace($"Plugin triggered on entity: {logicalName}, Id: {id}");
    }
}

Use case: You can use context and Target to determine whether a specific attribute was updated and conditionally run your logic. For example, only trigger follow-up actions when the status of a Case changes.

Retrieve a Single Record

Entity account = service.Retrieve("account",
    new Guid("00000000-0000-0000-0000-000000000001"),
    new ColumnSet("name", "telephone1", "primarycontactid"));

string accountName = account.GetAttributeValue<string>("name");

Use case: Retrieve account details when a related contact is updated, ensuring consistent synchronization between entities.

Retrieve Multiple Records (QueryExpression)

QueryExpression query = new QueryExpression("contact")
{
    ColumnSet = new ColumnSet("fullname", "emailaddress1", "parentcustomerid")
};
query.Criteria.AddCondition("statecode", ConditionOperator.Equal, 0);
query.Criteria.AddCondition("emailaddress1", ConditionOperator.NotNull);

query.Orders.Add(new OrderExpression("fullname", OrderType.Ascending));

EntityCollection contacts = service.RetrieveMultiple(query);

foreach (var contact in contacts.Entities)
{
    string fullname = contact.GetAttributeValue<string>("fullname");
}

Use case: Fetch all active contacts with valid email addresses for syncing into a mailing system.

Retrieve Multiple Records (FetchXML – Advanced)

FetchXML allows more complex queries that are sometimes easier to write than QueryExpression, especially when dealing with joins or aggregates.

Example 1: Retrieve All Active Opportunities With Related Account Name

string fetchXml = @"
<fetch>
  <entity name='opportunity'>
    <attribute name='name' />
    <attribute name='estimatedvalue' />
    <filter>
      <condition attribute='statecode' operator='eq' value='0' />
    </filter>
    <link-entity name='account' from='accountid' to='customerid' alias='acc'>
      <attribute name='name' alias='accountname' />
    </link-entity>
  </entity>
</fetch>";

EntityCollection opportunities = service.RetrieveMultiple(new FetchExpression(fetchXml));

Use case: Useful when building dashboards or reports that need both opportunity and account details in one query.

Example 2: Aggregate – Count Active Contacts Per Account

string fetchXml = @"
<fetch distinct='false' aggregate='true'>
  <entity name='contact'>
    <attribute name='contactid' aggregate='count' alias='contactcount' />
    <link-entity name='account' from='accountid' to='parentcustomerid' alias='acc'>
      <attribute name='name' groupby='true' alias='accountname' />
    </link-entity>
  </entity>
</fetch>";

EntityCollection results = service.RetrieveMultiple(new FetchExpression(fetchXml));

Use case: Helps managers quickly see how many contacts each account has, without exporting data.

Create a Record

Entity newContact = new Entity("contact");
newContact["firstname"] = "John";
newContact["lastname"] = "Doe";
newContact["emailaddress1"] = "john.doe@example.com";

Guid contactId = service.Create(newContact);

Use case: Automatically create a new Contact record when a lead is qualified.

Update a Record

Entity updateContact = new Entity("contact", contactId);
updateContact["telephone1"] = "123-456-7890";

service.Update(updateContact);

Use case: Update a contact’s phone number whenever the related account’s main phone number changes.

Delete a Record

service.Delete("contact", contactId);

Use case: Automatically clean up orphaned records when the parent entity is deleted.

Execute a Special Request

Dynamics 365 CRM includes specialized messages that can be executed through service.Execute().

Example: Win an Opportunity

WinOpportunityRequest winRequest = new WinOpportunityRequest
{
    OpportunityClose = new Entity("opportunityclose")
    {
        ["subject"] = "Opportunity Closed as Won",
        ["opportunityid"] = new EntityReference("opportunity", opportunityId)
    },
    Status = new OptionSetValue(3) // Won
};

service.Execute(winRequest);

Use case: Automate opportunity closure workflows, such as updating pipeline metrics or notifying stakeholders.

Conclusion

Plugins in Microsoft Dynamics 365 CRM give developers the ability to enforce business rules directly within the platform’s execution pipeline. By mastering context, target, and the use of IOrganizationService, you can perform everything from simple CRUD operations to complex queries with FetchXML or QueryExpression.

With these skills, you can:

• Validate and enforce business rules before data is saved.

• Automatically create or update related records.

• Perform advanced queries for reporting or automation.

• Execute system messages to integrate seamlessly with CRM processes.

Learning to harness these capabilities ensures your plugins are both powerful and efficient, helping organizations get the most from their Dynamics 365 CRM investment.

• JavaScript (form scripts)

• Power Automate (Flow)

• Plugins (C#)

• Web API (OData / REST API)

Finally, we’ll walk through real-world examples you can apply directly in your projects.

🔹 1. Handling Lookups with JavaScript in Dynamics 365 CRM

Form scripts are useful when you want to manipulate lookup fields directly on CRM forms.

✅ Get a Lookup Value in JavaScript

function getLookupValue(executionContext) {
    var formContext = executionContext.getFormContext();
    var lookup = formContext.getAttribute("parentaccountid").getValue();

    if (lookup != null) {
        var id = lookup[0].id;       // GUID of the record
        var name = lookup[0].name;   // Display name
        var entity = lookup[0].entityType; // Entity logical name

        console.log("ID: " + id + " | Name: " + name + " | Entity: " + entity);
    }
}

✅ Set a Lookup Value in JavaScript

function setLookupValue(executionContext) {
    var formContext = executionContext.getFormContext();

    var lookupValue = [{
        id: "B0D4F3F4-1D3A-4D2A-9A54-8A1B2E6A9F6C",
        name: "Contoso Ltd",
        entityType: "account"
    }];

    formContext.getAttribute("parentaccountid").setValue(lookupValue);
}

🔹 2. Handling Lookups in Power Automate (Flow)

In Power Automate, lookup fields need to be set using the @odata.bind notation.

✅ Get a Lookup Value in Flow

When retrieving a Contact, a lookup field looks like this:

"_parentaccountid_value": "b0d4f3f4-1d3a-4d2a-9a54-8a1b2e6a9f6c"

✅ Set a Lookup Value in Flow

To set a lookup, use:

"parentaccountid@odata.bind": "/accounts(b0d4f3f4-1d3a-4d2a-9a54-8a1b2e6a9f6c)"

💡 In Flow expressions, you can build it dynamically:

concat('/accounts(', outputs('Get_Account')?['body/accountid'], ')')

🔹 3. Handling Lookups in Plugins (C#)

In Dynamics 365 Plugins, lookups are handled using the EntityReference class.

✅ Get a Lookup Value in Plugin

if (entity.Contains("parentaccountid") && entity["parentaccountid"] is EntityReference lookup)
{
    Guid id = lookup.Id;
    string name = lookup.Name;       // Sometimes null depending on context
    string logicalName = lookup.LogicalName;
}

✅ Set a Lookup Value in Plugin

entity["parentaccountid"] = new EntityReference("account", 
    new Guid("B0D4F3F4-1D3A-4D2A-9A54-8A1B2E6A9F6C"));

🔹 4. Handling Lookups in Dynamics 365 Web API

When working with the Dataverse Web API, lookup values are accessed using the _fieldname_value convention.

✅ Get a Lookup Value via Web API

GET [Organization URI]/api/data/v9.2/contacts(11111111-2222-3333-4444-555555555555)?$select=fullname,_parentcustomerid_value

Response:

{
  "fullname": "John Doe",
  "_parentcustomerid_value": "b0d4f3f4-1d3a-4d2a-9a54-8a1b2e6a9f6c",
  "_parentcustomerid_value@OData.Community.Display.V1.FormattedValue": "Contoso Ltd",
  "_parentcustomerid_value@Microsoft.Dynamics.CRM.lookuplogicalname": "account"
}

• _parentcustomerid_value → The GUID of the lookup

• FormattedValue → The display name

• lookuplogicalname → The entity type

✅ Set a Lookup Value via Web API

PATCH [Organization URI]/api/data/v9.2/contacts(11111111-2222-3333-4444-555555555555)
Content-Type: application/json

{
  "parentcustomerid_account@odata.bind": "/accounts(b0d4f3f4-1d3a-4d2a-9a54-8a1b2e6a9f6c)"
}

🔹 Real-World Examples

Let’s look at some common business scenarios where you’ll need to get or set lookup fields.

Example 1: Setting a Contact’s Parent Account (JavaScript)

When a user selects an Industry, automatically assign the Contact to a default Account:

if (formContext.getAttribute("industrycode").getValue() === 42) {
    var accountLookup = [{
        id: "D1C5E8F2-91AA-4C3E-8A14-7C32F1B9F77B",
        name: "Default Industry Account",
        entityType: "account"
    }];
    formContext.getAttribute("parentaccountid").setValue(accountLookup);
}

Example 2: Assigning a Record Owner in Power Automate

When a new Lead is created, assign it to a specific user:

"ownerid@odata.bind": "/systemusers(5a4b8f3f-1122-44aa-bbbb-998877665544)"

Example 3: Updating Related Account from a Plugin

If a Contact is marked as "VIP", set its Parent Account to “VIP Clients”:

if (entity.Contains("new_vipstatus") && (bool)entity["new_vipstatus"] == true)
{
    entity["parentaccountid"] = new EntityReference("account", 
        new Guid("E2F6B8D1-99F1-4B4D-8CC9-11B2A3D3F1AA"));
}

Example 4: Web API — Linking a Case to a Customer

PATCH [Organization URI]/api/data/v9.2/incidents(11111111-2222-3333-4444-555555555555)
Content-Type: application/json

{
  "customerid_contact@odata.bind": "/contacts(b0d4f3f4-1d3a-4d2a-9a54-8a1b2e6a9f6c)"
}

🎯 Conclusion

• JavaScript → Use getValue() and setValue() with {id, name, entityType} objects.

• Power Automate (Flow) → Use @odata.bind with /entityname(guid) syntax.

• Plugins (C#) → Work with EntityReference.

• Web API → Use _lookupfield_value for retrieval and @odata.bind for updates.

Understanding how to get and set lookups across different technologies in Dynamics 365 CRM makes your solutions more flexible, scalable, and maintainable.

Auditing in Microsoft Dataverse helps in maintaining a log of all data changes. This is important for:

• Maintaining a history of data modifications

• Meeting compliance and regulatory standards

• Troubleshooting data integrity issues

Enable Auditing in Dataverse

System Settings:

• Navigate to Power Apps admin centre (https://admin.powerplatform.microsoft.com/home) > choose your environment > Settings > Audit Settings

• Under the Auditing tab, ensure start auditing is enabled

• /msdyn_blobfile/$value align="left")

Enable Table-Level Auditing:

• Select the table (e.g., Account)

• Enable “Audit changes to its data” in the table properties (Advanced Options)

  

Enable Column-Level Auditing:

• Select individual columns (e.g., Telephone1)

Enable the “Enable Auditing” option

/msdyn_blobfile/$value align="left")

Create Power Automate Flow to Retrieve Audit Data

1. Trigger: Use When a row is modified for the table you are tracking.

   

2. List Audit Records:

   

   Query Expression:

   objecttypecode eq 'account' and _objectid_value eq 'triggerOutputs()?['body/accountid']'
   

   • Add a List rows Dataverse action

   • Use this OData filter query:

   • Sort by createdon desc

3. Parse Audit Data:

   1. Use a Parse JSON action:

      

      Content expression:

      first(outputs('List_rows')?['body']?['value'])?['changedata']
      

      Response:

      {
        "OldValue": {
          "field1": "Old Value 1"
        },
        "NewValue": {
          "field1": "New Value 2"
        }
      }
      

4. Extract Old and New Values:

   1. Use a Compose action with below expression:

      

      outputs('Compose')?['changedAttributes'][0]['OldValue']
      

      outputs('Compose')?['changedAttributes'][0]['NewValue']
      

Conclusion

Audit logs provide a transparent trail of changes made to data within Dataverse. When combined with Power Automate, they empower users to create intelligent flows that not only respond to changes but also reference historical data. This setup is particularly valuable for quality control, approvals, and governance automation.

We hope this guide helps you understand how to retrieve old and updated data using audit logs in Power Automate. Feel free to leave a comment or reach out for further assistance.

What is Dataverse Search?

Dataverse (formerly known as Common Data Service) is a cloud-based data storage and management platform provided by Microsoft. It allows users to store and manage data used by business applications. The Dataverse Search functionality enables users to perform searches across the data stored within Dataverse, providing a powerful way to query and retrieve relevant information.

By using Dataverse Search, you can query various types of data, including entities and fields, and filter results based on specific criteria. This feature is particularly useful for applications that need to provide search capabilities to end users, allowing them to find data quickly and efficiently.

Why Use Web API for Dataverse Search?

Accessing Dataverse using the Web API provides several advantages:

• Flexibility: The Web API allows for dynamic querying and integration with various applications, offering greater control over how data is accessed and manipulated.

• Scalability: Web APIs are designed to handle a large number of requests and can scale according to the needs of your application.

• Standard Protocol: The Web API uses standard HTTP methods (GET, POST, PUT, DELETE), making it easy to integrate with different technologies and platforms.

• Security: The Web API supports OAuth 2.0 for secure authentication and authorization, ensuring that only authorized users can access the data.

Using the Web API for Dataverse search allows you to harness these benefits and build robust, scalable applications that can interact with Dataverse data seamlessly.

Implementation

Below are two code examples demonstrating how to implement search in Dataverse using the Web API. The first example shows how to perform a search, and the second example demonstrates how to handle the API call to retrieve results.

Performing the Search

public async Task<HttpResponseData> SearchKWArticles()
{
    try
    {
        // Retrieve an access token for authentication from a helper method
        String token = await GetAccessTokenAsync();
        
        // Initialize the response variable
        HttpResponseData response = null;
        
        // Define hardcoded search parameters
        string searchQuery = "sample search text";  // The search query string
        bool countResults = true;  // Whether to count the number of results
        int topResults = 10;  // Maximum number of results to return
        string[] orderBy = new string[] { "createdon desc" };  // Sort results by creation date in descending order
        string filter = "createdon gt 1900-01-01";  // Filter results based on creation date
        
        // Define the Web API endpoint for performing the search
        String urlForConfigs = "/api/search/v2.0/query";
        
        // Construct the JSON request body for the Web API
        var jsonRequest = JsonConvert.SerializeObject(new
        {
            search = searchQuery,  // The search term
            count = countResults,  // Whether to count the results
            top = topResults,  // Limit on the number of results
            entities = JsonConvert.SerializeObject(new List<object>
            {
                new {
                    name = "knowledgearticle",  // The entity to search within
                    selectColumns = new List<string> { "title", "createdon","articlepublicnumber","description" },  // Columns to select
                    searchColumns = new List<string> { "title","articlepublicnumber","description" },  // Columns to search
                    filter = "statecode eq 3 and isprimary eq true"  // Filter to include only primary articles
                },
            }),
            orderby = JsonConvert.SerializeObject(orderBy),  // Sorting order
            filter = filter  // Additional filtering criteria
        });
        
        // Call the method to retrieve search results from the Web API
        String data = await RetrieveSuggestions(token, urlForConfigs, jsonRequest);
        
        // Create and configure the HTTP response with the search results
        response = req.CreateResponse(HttpStatusCode.OK);
        response.Headers.Add("Content-Type", "application/json; charset=utf-8");
        response.WriteString(data.Replace(_baseUrl, _impersonateUrl));  // Replace base URL if needed
        
        return response;
    }
    catch (Exception ex)
    {
        // Handle exceptions by returning a bad request response with the error message
        return CreateBadRequestResponse(req, ex.Message);
    }
}

Retrieving Search Results

private async Task<string> RetrieveSuggestions(string accessToken, string queryURL, object postBody)
{
    try
    {
        // Set the authorization header with the Bearer token for authentication
        _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
        
        // Construct the full URL for the API request
        String url = _baseUrl + queryURL;
        
        // Send a POST request with the JSON body to the Web API
        var response = await _httpClient.PostAsJsonAsync(url, postBody);
        
        // Ensure the response indicates success
        response.EnsureSuccessStatusCode();
        
        // Read and return the response content as a string
        string content = await response.Content.ReadAsStringAsync();
        return content;
    }
    catch (Exception ex)
    {
        // Return error message in case of an exception
        return ex.Message;
    }
}

Additional Explanations

Here are some additional explanations to help you understand the code:

• Access Token: The GetAccessTokenAsync method retrieves an OAuth 2.0 token needed for authenticating requests to the Web API. This token ensures secure access to the Dataverse data.

• Search Parameters:

  • searchQuery: Defines the text or keywords used in the search.

  • countResults: Determines whether to include the count of search results.

  • topResults: Limits the number of results returned.

  • orderBy: Specifies how the results should be sorted.

  • filter: Applies additional conditions to filter the results based on specific criteria.

• RetrieveSuggestions Method:

  • Sets the HTTP request header with the access token for authentication.

  • Sends the JSON payload to the Web API endpoint using a POST request.

  • Reads and returns the response from the API call, handling any exceptions by returning error messages.

Conclusion

Accessing Dataverse using the Web API enables you to perform powerful searches and retrieve relevant data efficiently. The provided code and explanations should help you integrate search capabilities into your applications and leverage the full potential of Dataverse.