Logic apps: Create dummy PDFs with the SharePoint REST API

Benjamin Prins Power Platform

In one of our projects, we needed a way for users to generate a dummy PDF for a SharePoint document on demand. Not a copy of the original file, but a clearly identifiable placeholder PDF containing demo text such as “This is a dummy PDF”, while still preserving all relevant SharePoint metadata. This approach allowed users to work with a PDF representation without exposing or duplicating the original content.

Security and governance were important requirements. The dummy PDF had to be created using the SharePoint REST API, allowing a Logic App to authenticate via Managed Identity. This avoids client secrets or user credentials and results in a clean, secure, and fully automated setup.

The process is simple. A user sets a SharePoint column like “Create dummy PDF” to Yes, which triggers a Logic App. The Logic App creates the PDF via the REST API and then copies the metadata from the original document to the dummy PDF. In this blog, I’ll explain how this works, how to set values for different SharePoint column types using API calls, how to find the correct __metadata type for a document library and how to find the ServerRelativeUrl.

How to find the metadata type for a SharePoint document library

The metadata type for the SharePoint list is needed to update the properties of the created PDF file.

    • To get the metadata type, we need to find what is called the ListItemEntityTypeFullName of the SharePoint document library.
    • This can be done using the following REST API call.
    • Change the domain, site and document library name and use the API call in a browser.
    https://[domain].sharepoint.com/sites/[site]/_api/web/lists/getbytitle('[Document library name]')?$select=ListItemEntityTypeFullName

https://demo.sharepoint.com/sites/demosite/_api/web/lists/getbytitle('Documenten')?$select=ListItemEntityTypeFullName
    • Look for the ListItemEntityTypeFullName and save the value.
    • In my example the value is: SP.Data.Gedeelde_x0020_documentenItem

    How to find the ServerRelativeUrl

    The server relative URL of the document library is required for the creation of the PDF file. I noticed that this URL is not always the same as the URL you see in the browser. With this API call you can find the correct value.

    • To get the Server Relative URL, we need to find what the ServerRelativeUrl of the SharePoint document library.
    • This can be done using the following REST API call.
    • Change the domain, site and document library name and use the API call in a browser.
    https://[domain].sharepoint.com/sites/[site]/_api/web/lists/getbytitle('[document library name]')?$select=RootFolder/ServerRelativeUrl&$expand=RootFolder

https://demo.sharepoint.com/sites/demosite/_api/web/lists/getbytitle('documenten')?$select=RootFolder/ServerRelativeUrl&$expand=RootFolder
    • Look for the ServerRelativeURL property and save the value.
    • In my example the value is: /sites/demo/Documenten.

    Create a PDF file with SharePoint REST API

    • Add an HTTP action to you logic app.
    • Use the following API call to create a PDF file.
    • Change the domain, site, set the correct Server Relative URL, provide a file name.
    https://[domain].sharepoint.com/sites/[site]/_api/web/GetFolderByServerRelativeUrl('/sites/[site]/[document library]')/Files/add(url='[file name].pdf',overwrite=false)
    • Set the Method to POST.
    • Set a header called Accept to application/json;odata=verbose.
    • Set a header called Content-Type to application/pdf.
    • Set the body with the following code. If needed, change the content value to match your requirements.
    base64ToBinary('JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXQogICAvQ29udGVudHMgNCAwIFIgL1Jlc291cmNlcyA8PCAvRm9udCA8PCAvRjEgNSAwIFIgPj4gPj4gPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA0NCA+PgpzdHJlYW0KQlQKL0YxIDI0IFRmCjEwMCA3MDAgVGQKKER1bW15IGRvY3VtZW50LikgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmCjAwMDAwMDAwMTAgMDAwMDAgbgowMDAwMDAwMDYwIDAwMDAwIG4KMDAwMDAwMDExNyAwMDAwMCBuCjAwMDAwMDAyNzMgMDAwMDAgbgowMDAwMDAwNDE4IDAwMDAwIG4KdHJhaWxlcgo8PCAvUm9vdCAxIDAgUiAvU2l6ZSA2ID4+CnN0YXJ0eHJlZgo1MzAKJSVFT0Y=')
    • Set the Authentication to Managed identity.
    • Select the correct managed identity.
    • Set the Audience to your SharePoint domain.

    Update the PDFs file properties using the SharePoint REST API

    • Add an HTTP action to you logic app.
    • Use the following API call to update the properties of the PDF file.
    • Change the domain, site, document library name and the correct item ID.
    https://[domain].sharepoint.com/sites/[site]/_api/web/lists/getbytitle('[document library]')/items([item ID])

https://demo.sharepoint.com/sites/demosite/_api/web/lists/getbytitle('Documenten')/items(1)
    • Set the Method to POST.
    • Set a header called Accept to application/json;odata=verbose.
    • Set a header called Content-Type to application/json;odata=verbose.
    • Set a header called X-HTTP-Method to MERGE.
    • Set a header called IF-MATCH to *
    • The basic code for the body is as follows, but you will need to add in your specific SharePoint properties. In the paragraph JSON Examples for property types, you can see the syntax required for different types of SharePoint columns.
    • Set as the type of the __metadata the ListItemEntityTypeFullName of the document library.
    {
  "__metadata": {
    "type": "SP.Data.Gedeelde_x0020_documentenItem"
  },
  "Title": "G.104612",
  "ContentTypeId": "0x010100000AAAAAA111111D9C039461496B7308010097DF96DFF524EA4E900ED55E769ECEAF"
}
    • Set the Authentication to Managed identity.
    • Select the correct managed identity.
    • Set the Audience to your SharePoint domain.

    JSON Examples for property types

    SharePoint uses different column types to store data. Depending on the column type, different JSON syntax is required. Always use the internal name of the SharePoint column.

    Setting a string: "Title": "This is my string"
    Setting a number: "Number": 1
    Setting a choice field: "ChoiceField": "Choice 1",
    Setting a date field: "Date": "2026-04-20T00:00:00Z"
    Setting a Lookup where multiple values are allowed: "LookupId": { "results": [ 1, 3 ] }
    Setting a Lookup where multiple values are not allowed: "LookupId": 1
    Setting an empty date field: "Date": null
    Setting an empty string: "Title": ""
    Setting an empty number: "Number": null
    Setting a choice field to empty: "CreateDummyPDF": null
    Setting a Lookup where multiple values are allowed to empty: "LookupId": { "results": [] }
    Setting a Lookup where multiple values are not allowed to empty: "LookupId": null

    Note for lookup fields you need the field name plus Id.

    Power Automate: Add a tab to a Teams channel

    Benjamin Prins Power Platform

    Creating a team from a Teams template is a great starting point, but in most real-world scenarios you’ll want to enhance that team with additional structure and content. In my previous post, Power Automate: Creating a Team from a team template, I walked through how to provision a new team via API using Power Automate.

    In this follow‑up, I’ll take the next step: adding a tab to a channel in the newly created team. To do that, we first need to retrieve the team’s GUID, identify the correct channel, and then make the appropriate API call to create the tab. This post walks you through each part of that process, step by step.

    Find the team guid

    • Initialize a variable: Add an Initialize variable to the top of the flow, name that variable TeamGuid.
    • Parse the HTTP response headers: After the HTTP action that creates the team, add a Parse JSON action. Use the response headers as the content and apply the following schema:
    {
    "type": "object",
    "properties": {
        "Location": {
            "type": "string"
        },
        "Strict-Transport-Security": {
            "type": "string"
        },
        "request-id": {
            "type": "string"
        },
        "client-request-id": {
            "type": "string"
        },
        "x-ms-ags-diagnostic": {
            "type": "string"
        },
        "Date": {
            "type": "string"
        },
        "Content-Location": {
            "type": "string"
        },
        "Content-Length": {
            "type": "string"
        }
    }
}
    • Extract the GUID: Add a Set variable action, select the TeamGuid variable, and use the following expression. This pulls the team GUID from the Content-Location property:
    first(split(last(split(body('Parse_JSON_-_Headers_-_Department')?['Content-Location'],'(''')),''')'))
    • With the team GUID stored, we can now use it in subsequent API calls—such as retrieving channels and creating tabs.

    Find the channel ID

    To add a tab to a specific channel, we first need the channel’s unique ID. Using the team GUID retrieved in the previous step, we can query Microsoft Graph to list all channels and extract the one we need. Follow these steps:

    • Initialize a variable: Add an Initialize variable action at the top of your flow and name it General Tab ID (or another name if you're targeting a different channel).
    • Retrieve the team's channel details: Add a HTTP action and call it HTTP - Get Team Details.
      • Set the Method to Get.
      • Set the header key Authorization to value Bearer [access_token].
      • Set the header Content-Type to value application/json.
      • Set the header key Accept to value application/json.
      • Set the URI to:
    https://graph.microsoft.com/v1.0/teams/variables('TeamGuid')
    • Parse the response: Add a Parse JSON action and set the Content to the body of the Get Teams Details HTTP action. Us the following schema:
    {
    "type": "object",
    "properties": {
        "@@odata.context": {
            "type": "string"
        },
        "@@odata.count": {
            "type": "integer"
        },
        "value": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "id": {
                        "type": "string"
                    },
                    "createdDateTime": {
                        "type": "string"
                    },
                    "displayName": {
                        "type": "string"
                    },
                    "description": {
                        "type": [
                            "string",
                            "null"
                        ]
                    },
                    "isFavoriteByDefault": {},
                    "email": {
                        "type": "string"
                    },
                    "tenantId": {
                        "type": "string"
                    },
                    "webUrl": {
                        "type": "string"
                    },
                    "membershipType": {
                        "type": "string"
                    },
                    "isArchived": {
                        "type": "boolean"
                    }
                }
            }
        }
    }
}
    • Filter for the correct channel: Add a Filter array action.
      • Set the From to the value of the Parse JSON action.
      • Set the filter to displayName is equal to [name of the channel] in my example I used the default General channel.
    • Store the Channel ID: Add a Set variable action and select the General Tab ID.
      • Set the value to the id from the Filter array.
    • This will automatically create an Apply to each around the set variable action, because in theory there could be more than one tab with the name General.

    Add the website tab

    With both the team GUID and the channel ID available, we can now create a new tab in the target channel. In this example, we’ll add a website tab, but the same approach applies to other tab types supported by Microsoft Teams.

    • Create the tab request: Add a HTTP action and call it HTTP - Get Team Details.
      • Set the Method to Get.
      • Set the header key Authorization to value Bearer [access_token].
      • Set the header Content-Type to value application/json.
      • Set the header key Accept to value application/json.
      • Set the URI to:
    https://graph.microsoft.com/v1.0/teams/variables('TeamGuid')}/channels/variables('General Tab ID')/tabs
    • Define the tab configuration: Set the body of the request to the following JSON, and update the display name and website URLs to match your scenario:
    {
  "displayName": "Ben Prins Blog",
  "teamsApp@odata.bind": "https://graph.microsoft.com/v1.0/appCatalogs/teamsApps/com.microsoft.teamspace.tab.web",
  "configuration": {
    "entityId": "Ben Prins Blog",
    "contentUrl": "https://benprins.net",
    "websiteUrl": "https://benprins.net"
  }
}
    • This call creates a new website tab in the specified channel using the provided configuration. Once executed, the tab will appear immediately in the team, giving users quick access to the linked content.

    Power Automate: Creating a Team from a team template

    Benjamin Prins Power Platform

    Creating Microsoft Teams through automation can be a real time‑saver, especially when your organization relies on consistent structures for collaboration. Using a team template is a great way to ensure that every new team starts with the right channels, settings, and tabs in place. In this blog post, I’ll walk you through how to create a new team from a Teams template using Power Automate. We’ll cover the required app registration setup, retrieving an access token, and finally making the Graph API call needed to deploy your team—fully automated and ready to use.

    Creating the app registration

    Before we get started, I’ll assume you already know how to create an app registration in Azure AD and how to generate a client secret. For the flow we’re building, the app registration needs the following Microsoft Graph API permissions to successfully create a team and add tabs:

    • Directory.ReadWrite.All
    • Group.ReadWrite.All
    • Notes.ReadWrite.All
    • Team.Create
    • TeamsTab.ReadWrite.All
    • Teamwork.Migrate.All
    • User.Read

    Make sure these permissions are added and granted admin consent. With that in place, we can move on to using the app registration in Power Automate.

    Create the team template

    To prepare your Teams template for use in Power Automate, follow these steps:

    • Go to the Teams admin center.
    • Navigate to Teams and click on on Team template.
    • Click on add to create a new team template and configure it as needed
    • After saving the template, make sure to copy and store the Template ID — you’ll need it later when creating the team through a Graph API call.

    Getting access token for API calls

    To authenticate your Graph API requests, you first need to retrieve an access token. You can do this directly within your Power Automate flow:

      • Add a HTTP action to your Power Automate Flow and name it HTTP - Get access token.
      • Set the Method to Post.
      • Set the URI to:
      https://login.microsoftonline.com/[yourtenantid]/oauth2/v2.0/token
        • Add a header:
          • Content-Type and set the value to application/x-www-form-urlencoded.
        • In de body, add the following code and replace the client id value and client secret values with your own values.
        client_id=[value]&
scope=https://graph.microsoft.com/.default&
client_secret=[secret]&
Grant_type=client_credentials
        • Add the Parse JSON action, set the content to the Body of the HTTP - Get Access token action.
        • Set the schema to the following, to be able to use the returned access token.
        {
    "type": "object",
    "properties": {
        "token_type": {
            "type": "string"
        },
        "expires_in": {
            "type": "integer"
        },
        "ext_expires_in": {
            "type": "integer"
        },
        "access_token": {
            "type": "string"
        }
    }
}

        Create the team

        In this example, the team’s description and owner come from a SharePoint list item. Depending on your setup, the steps below may vary slightly.

        • Add a Initialize variable, to create an Array called ArrayOwner1
        • Set the value to the following code, to change the SharePoint column value from Owner to an array.
        createArray(triggerOutputs()?['body/Owner1'])
        • Add a Select action to the flow and name is Select - ArrayOwner1.
        • Set the from to the variable ArrayOwner (can only contain 1 person).
          • You can only set one owner when creating the team.
        • Click on switch button to set the Map field in text mode.
        • Add the following code to the Map (in text mode).
        • This code will create the correct json for the body of the API call. If you manually set this in the Body, then the body will break because of the ' symbols.
        json(concat('{"@odata.type": "#microsoft.graph.aadUserConversationMember","roles": ["owner"],"user@odata.bind": "https://graph.microsoft.com/v1.0/users(''', item()['Email'], ''')"'))
        • Add a HTTP action and call it HTTP - Create Team.
        • Set the Method to POST.
        • Set the URI to: https://graph.microsoft.com/v1.0/teams.
        • Set the header key Authorization to value Bearer [access_token].
        • Set the header Content-Type to value application/json.
        • Set the header key Accept to value application/json.
        • Set the body as follows, but change the template id, display name and description if needed.
        {
  "template@odata.bind": "https://graph.microsoft.com/v1.0/teamsTemplates('[Template ID')",
  "displayName": "Team Example Name",
  "description": "@{triggerOutputs()?['body/Description']}",
  "members": 
    @{body('Select_-_Owner')}
}

        PowerShell in Azure Function App: Microsoft.CrmSdk.CoreTools

        Benjamin Prins Power Platform

        The Microsoft.CrmSdk.CoreTools package is a collection of essential utilities for working with Microsoft Dataverse and Power Platform solutions. These tools are designed to help developers and administrators automate common tasks such as solution management, schema handling, and deployment processes.

        One of the most powerful utilities included in this package is the Solution Packager, which allows you to unpack a solution ZIP into individual files for editing and then repack it for deployment. This capability is invaluable when you need to customize components like Power Automate flows or forms as part of an automated pipeline.

        In this post, we’ll focus on how to install and use Solution Packager in an Azure Function App, so you can integrate it into your serverless workflows for Power Platform automation.

        How to install the Microsoft crmsdk coretools

        How to use the Solution Packager

        • Set up the following variables.
        • $toolPath → Path to the Solution Packager executable.
        • $inputZip → The original solution ZIP you want to unpack.
        • $outputFolder → Where the unpacked files will be stored.
        • $outputSolutionZip → The new ZIP after repacking. 
        $toolPath = "c:/home/site/wwwroot/microsoft.crmsdk.coretools.9.1.0.179/content/bin/coretools/SolutionPackager.exe"
$inputZip = "c:/home/site/wwwroot/MySolution.zip"
$outputFolder = "c:/home/site/wwwroot/UnpackedSolution"
$outputSolutionZip = "c:/home/site/wwwroot/PackedSolution/PackedSolution.zip"
        • Invoke Solution Packager using & followed by the action type:
        • For unpacking use /action:Extract.
        • For repacking use /action:Pack.
        & $toolPath /action:Extract /zipfile:$inputZip /folder:$outputFolder
& $toolPath /action:Pack /zipfile:$outputSolutionZip /folder:$outputFolder
        • Here’s the complete PowerShell snippet for unpacking and repacking a solution:
        # Define paths
$toolPath = "c:/home/site/wwwroot/microsoft.crmsdk.coretools.9.1.0.179/content/bin/coretools/SolutionPackager.exe"
$inputZip = "c:/home/site/wwwroot/MySolution.zip"
$outputFolder = "c:/home/site/wwwroot/UnpackedSolution"
$outputSolutionZip = "c:/home/site/wwwroot/PackedSolution/PackedSolution.zip"

# Unpack the solution
& $toolPath /action:Extract /zipfile:$inputZip /folder:$outputFolder

# Make your changes to the unpacked solution

# Repack the solution
& $toolPath /action:Pack /zipfile:$outputSolutionZip /folder:$outputFolder

        PowerShell in Azure Function App: Modules and CLI Integration

        Benjamin Prins Power Platform

        PowerShell is a powerful scripting language that can be run in an Azure Function Apps. However, working with PowerShell in this environment often requires adding custom modules and enabling command-line tools (CLI). In this post, I’ll walk through multiple approaches for adding PowerShell modules and several ways to integrate CLI tools into your Function App. Before adding any module, it’s important to check whether it’s already loaded and confirm that it’s compatible with the version of PowerShell your Function App uses. By the end, you’ll have practical options to choose from based on your scenario.

        How to check if a module is available

        To check if a specific module is available run the Get-Module command. For example for the Microsoft PowerApps Administration PowerShell module.

        Get-Module -Name Microsoft.PowerApps.Administration.PowerShell -ListAvailable

        How to check if CLI is available

        You can verify PAC CLI availability by checking its path or running its version command:

        & "c:/home/site/wwwroot/Modules/paccli/tools/pac.exe" --version
        
$pacPath = "c:/home/site/wwwroot/Modules/paccli/tools/pac.exe"
if (Test-Path $pacPath) {
    Write-Host "PAC CLI is installed at $pacPath"
} else {
    Write-Host "PAC CLI is NOT installed"
}

        Get-Command pac.exe -ErrorAction SilentlyContinue

        How to install CLI

        You can install the CLI by running the script below directly in your Function App, or run it locally and then manually upload the extracted CLI folder to the Function App’s file system. For better organization, I recommend placing the CLI inside the Modules folder.

        # Download PAC CLI NuGet package only needed once. You can also do this locally and manual place the PAC CLI files on the function apps file drive
Invoke-WebRequest -Uri "https://www.nuget.org/api/v2/package/Microsoft.PowerApps.CLI/1.50.1" -OutFile "paccli.nupkg"

# Extract NuGet package. You can also do this locally and manual place the PAC CLI files on the function apps file drive
Expand-Archive -Path "paccli.nupkg" -DestinationPath "c:/home/site/wwwroot/Modules/paccli"

        How to install the Microsoft crmsdk coretools

        How to install a module

        Before installing any modules, make sure they aren’t already available in your Function App. You can either install the modules locally and upload the module folder to the Function App’s file system, or configure the Function App to install them automatically by updating the requirements.psd1 and host.json files.

        • Make sure that in the host.json file (c:\home\site\wwwroot\host.json) managedDependency is set to Enable true.
        • I included my whole host.json file to demonstrate where to place the code.
        {
  "version": "2.0",
  "isDefaultHostConfig": true,
  "managedDependency": {
    "Enabled": true
  },
  "extensionBundle": {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[4.*, 5.0.0)"
  }
}
        • Open the requirements.psd1 file, or create a new one if it doesn't exist.
        • Add the modules that need to be installed inside the @{ }.
        • In my example below, the modules are commented out, so they won’t be installed.
        • Restart your Function App to begin the installation process. This step can take several minutes to complete.
        # This file enables modules to be automatically managed by the Functions service.
# See https://aka.ms/functionsmanageddependency for additional information.
#
@{
    # For latest supported version, go to 'https://www.powershellgallery.com/packages/Az'. 
    # To use the Az module in your function app, please uncomment the line below.
    #'Az.Accounts' = '2.*'
    #'Microsoft.PowerApps.Administration.PowerShell' = '1.*'
    #'Microsoft.PowerApps.PowerShell' = '1.*'
}
        • After the installation is done, make sure to import the installed modules.
        Import-Module "c:/home/site/wwwroot/Modules/Microsoft.PowerApps.Administration.PowerShell/2.0.216/Microsoft.PowerApps.Administration.PowerShell.psd1" -Verbose
Import-Module "c:/home/site/wwwroot/Modules/Microsoft.PowerApps.PowerShell/1.0.45/Microsoft.PowerApps.PowerShell.psd1" -Verbose

        How to upload file to the Function Apps drive

        Each Windows-based Function App includes a file system where you can store files. You can access this file system through your browser using Kudu, available under the Advanced Tools settings.

        • Open your Function App and look for Advanced Tools or Kudu in the menu.
        • Click on Advanced Tools, then click on Go.
        • A new tab will open with the advanced Kudu tools.
        • Click on Debug console, then choose either CMD or PowerShell.
        • Navigate to the folder where you want to upload files. I most cases, this will be the C:\home\sites\wwwroot folder.
        • Drag and drop the files you want to upload into the selected folder

        Power Platform: Monitoring a power app

        Benjamin Prins Power Platform

        When building apps in Power Apps, understanding what happens behind the scenes is essential for smooth performance and reliable functionality. The Monitor tool provides a powerful way to observe your app in action, offering real-time insights into its behavior and interactions.

        Monitor acts as a live event viewer, capturing everything from data operations to user-triggered actions. It helps makers identify issues quickly, optimize performance, and validate logic without guesswork. Whether you’re troubleshooting a connector, analyzing load times, or verifying formula execution, Monitor gives you the visibility you need.

        With Monitor, you can capture:

        • Performance metrics (load times, data refresh times)
        • Function calls (e.g., ClearCollect, Patch, Navigate)
        • Network requests (to SharePoint, Dataverse, APIs)
        • Errors and warnings
        • Trace logs (from Trace() statements)

        How to use the monitor tool

        • In Power Apps Studio, from the app list, select Details → Live monitor under the app’s menu (3 dots).
        • The Monitor window will open for your app.
        • Click Play published app to run the app. It will open in a new browser tab.
        • Use the app as you normally would, focusing on the parts you want to monitor.
        • Events will appear live in the Monitor window as you interact with the app.
        • Use filters to narrow down event types such as Errors, Warnings, or Trace messages.
        • Click any event to view detailed information, including formula execution, data payload, and timing.

        How to use Trace()

        The Trace function allows you to send custom messages to the Monitor log while your app runs. This is useful for debugging and understanding the flow of your app. You can log simple text messages, variable values, or even complex objects and collections. You can also specify the severity of the message, such as Information, Warning, or Error. Trace is only available in canvas apps and does not work in model-driven apps.

        To send a message only when a specific condition is met, wrap the Trace function inside an If statement. This helps you log errors or warnings only when they occur, instead of flooding the log with unnecessary messages.

        Trace("Start of OnScreen"); // Manual text message

Trace("Value of varCompHeigh" & varCompHeight); // A variable

Trace("Value of gblAppColors" & JSON(gblAppColors)); // An object as JSON

Trace("Trace Warning", TraceSeverity.Warning); // Trace of type warning

Trace("Trace Critical", TraceSeverity.Critical); // Trace of type Critical

Trace("Trace Error", TraceSeverity.Error); // Trace of type Error

Trace("Trace Information", TraceSeverity.Information); // Trace of type Information

If(IsEmpty(colDesks), Trace("Collection is empty: " & JSON(colDesks), TraceSeverity.Error)) // Trace within If condition

Trace("End of OnStart"); // Manual text message

        Logic App: Tips and tricks

        Benjamin Prins Power Platform

        Whether you're just getting started with Logic Apps or looking to refine your workflows, this post shares practical tips that can save you time and headaches—especially when working with SharePoint integrations. From handling approval status correctly to formatting JSON for field updates and managing choice fields in conditions, these insights will help you build smarter, more reliable automations. Let’s dive into the details.

        Approve or reject an SharePoint item

        To approve or reject a SharePoint item, use the Set content approval status action. This cannot be done using Create item or Update item actions.

        Using JSON to Update SharePoint Fields

        When creating or updating SharePoint items in Logic Apps, you’ll need to use JSON formatting to set field values correctly.

        {
  "Current Status": {
    "Value": "Closed"
  }
}

        For a text or date fields:

        {
  "Date": "YourDateValue",
  "Text": "Example"
}

        For a number field:

        {
  "Number": 1
}

        Using the Approval Status Field in SharePoint

        To check the approval status of a SharePoint item, refer to the Approval Status field (Dutch: Goedkeuringstatus). This field reflects whether an item is Pending, Approved, or Rejected.

        When using this field in Power Automate or other logic-based tools, keep in mind:

        • Always use {ModerationStatus} when referencing this field in condition actions.
        • The display name of the field is Approval Status.
        • The internal name used in conditions or expressions is {ModerationStatus}.
        • Although you might see _ModerationStatus in the URL when filtering or viewing list settings, that version cannot be used directly in expressions or dynamic content.

        Condition check for SharePoint choice field

        When working with choice fields in SharePoint (e.g. Status), you can't directly compare with the field name in a condition. The actual value is nested deeper in the JSON structure. Instead of checking just Status, you need to check Status.Value. This ensures you're comparing the actual selected value of the choice field, not the object that contains it.

        @items('For_each')?['Status']?['Value']

        Adding a Line Break (enter) in an Append to String action

        When working with a For Each loop in Logic Apps, it is often useful to collect output from each iteration. One effective approach is to use the Append to string variable action. In my solution, I needed to build a list where each item appears on a new line. To achieve this, simply add the <br> HTML tag at the end of each appended string to insert a line break.

        Power App: Tips & Tricks

        Benjamin Prins Power Platform

        Today, we will delve into some practical tips and tricks that can enhance your experience while working with Power Apps. Whether you're a seasoned developer or just starting out, these tips will help you streamline your workflow and make the most out of the Power Platform.

        In this post, we'll cover various aspects of working with Dataverse forms in canvas apps, including how to handle different form modes, retrieve the last submitted data, and reset variables in SharePoint-integrated Power Apps. Additionally, we'll explore how to use the concurrent function to load multiple data sources quickly, get current user details, and cache data for better performance.

        Form modes

        When working with a Dataverse form in a canvas app, you sometimes need different behavior for the edit, new, or view mode of the form. Each mode is represented by a number, and you can use the following code to check the current FormMode. Form2 is the name of the form.

        If(Form2.Mode = 0, "Edit", Form2.Mode = 2, "View", "New")
        Enum NameNumeric Value
        FormMode.Edit0
        FormMode.New1
        FormMode.View2

        It can also be done by comparing the Mode of the form SharePointForm1.LastSubmit.ID with the FormMode.Edit / View or New code.

        If(Form2.Mode = FormMode.Edit, "Edit", Form2.Mode = FormMode.View, "View", "New")

        Last submitted data

        When working with a form to submit data to Dataverse you can get the last submitted data. You can get the ID of the created record by calling the LastSubmit followed by the name of the ID column.

        Form1.LastSubmit.Contact

        This can also be done with a SharePoint integration power app by calling the LastSubmit code from the SharePoint form.

        SharePointForm1.LastSubmit.ID

        Reset variables in SharePoint integrated Power App

        When you set variables in a SharePoint integrated Power App don't forget to reset them when the user closes the app either resetting the variables in the OnCancel or OnSave or resetting them when the form gets opened.

        Set(varStatus, Blank());
Set(varFlag, false);

        Use concurrent to load multiple sources quicker

        When you want to store multiple sources locally, you can load them in a collect one after the other. 

        ClearCollect(Account, Accounts);
ClearCollect(Contact, Contacts);

        But you can also load them in parallel by using the concurrent function. This will load them faster by loading them at the same time.

        Concurrent(
    ClearCollect(colAccount, Accounts),
    ClearCollect(colContact, Contacts)
);

        Get current users details

        You can get the current user's details by using the User() function.

        User().EntraObjectId;
User().Email;
User().FullName;
User().Image;

        Cache data that does not change but is used in multiple locations

        When you are calling the same function again to access a resource to get the same data it is better (faster) to retrieve it once and store it in a variable.

        Set(varCurrentUserName

        Set(varUsername, User().FullName);
Set(varMyAccountName, LookUp(Accounts, 'Account Name' = "Contoso, Ltd."));

        Drop-down not showing the correct values

        Sometimes when you add a drop-down to a canvas app the displayed values are item 1, item 2 etc. Instead of the actual values. This happens when the drop-down list options are not loaded correctly.

        Go to the DisplayFields property of the drop-down and set the it to ["Value2"] instead of ["Value"]. The canvas app will see that this is incorrect and change it back to ["Value"] and refresh the drop-down values. Now all the correct values will be visible.

        Power App: How to export and import a SharePoint Power App Form

        Benjamin Prins Power Platform

        At this moment there is no out-of-the-box way to export/import a SharePoint Power App form between SharePoint list. Even when you duplicate the SharePoint List the custom SharePoint Power App form will not be duplicated. But fear not, there is a way to transfer the form. However its not for the faint of heart you will need to manual edit the forms code.

        Exporting the form

        • Open the settings of the SharePoint list with the SharePoint Power App form.
        • Click on Form settings.
        • Click on See versions and usage; this will open the app in the Power App Studio.
        • Click on Export package.
        • Give the package a name and set the import setup to Create as new.
        • Click on Export.

        Duplicate the SharePoint list

        We will need a exact copy of the original SharePoint list, otherwise the names (references) will not be the same.

        • Click in SharePoint on the menu on the left on the +
        • Click on Existing list
        • Select the SharePoint site and the select your list, my list is called My Demo List.
        • Leave the name the same and click on Create.
        • A duplicated list is now created, but without the SharePoint Power App form.
        • For the manual changes we will need to get the list id
        • Open de list settings and copy the list ID from the URL.

        Manually changing the references

        • Navigate to the exported SharePoint Power App form create a copy of it and unzip it.
        • Open the unzipped folder.
        • Navigate to Microsoft.PowerApps - Apps - [numeric value].
        • Open the JSON file with only numbers in its name in your favorite code editor (I am using Visual Studio Code).
        • Find the old list id and replace it with the new ID. Depended on you app, the ID might need to be replaces multiple times.
        • Now find the site URLs that reference the old site and change them to the new site. There might be multiple URLs that need to be updated, my app had 5.
        • Save the changes to the file.
        • Now we need to unzip the MSAPP File.
        • Change the type from msapp to zip and unzip the folder.
        • Open the unzipped folder.
        • Open the Properties.json and change the old URL to the new URL.
        • Open the DataSources file.
        • Change al the old URLs to the new URL, be aware there are some partial URLs that need to be changed.
        • Save all the changes and remake the zip file.
        • Remove the old MSAPP file.
        • Rezip the folder and set the name to be exactly the same as the old msapp file.
        • Make sure you did not add an extra folder layer to the new zip file.
        • Change the file type of the zip file to msapp.
        • Remove the unzipped folder.
        • Go to the top level of the folder and rezip the whole app.
        • Make sure you did not add an extra folder layer to the new zip file.

        Importing the form

        • Upload the updated exported package (zip).
        • Change the name of the app, the names of app need to be unique.
        • If required setup the connections.
        • If required select the flows.
        • Click on import.
        • Wait for the import to finish.
        • Open the new (duplicated) SharePoint list.
        • Click on Integrate - Power Apps - Customize forms.
        • This will open the imported app.
        • Publish the app.
        • Go back to the list and create an item, the SharePoint Power App form will now be opened.
          • You might need to refresh the page for the app to appear.

        Power Platform: Enhancing SharePoint Integrated Power Apps with Post-Submit Actions

        Benjamin Prins Power Platform

        Creating a seamless user experience in a SharePoint integrated Power App (Canvas App) can be challenging, especially when performing actions after form submission. Once a form is submitted, it closes, but the OnSuccess property allows you to run code post-submission.

        In this blog, I'll show you how to use the OnSuccess property to make changes to the newly created SharePoint item. Although you can't use ThisItem or link directly to data cards, I'll guide you through the process to ensure your app functions smoothly.

        By the end, you'll know how to enhance your Power App's functionality and improve user experience. Let's dive in!

        Create a SharePoint list

        • Create a SharePoint list on any SharePoint site.
        • Add 1 text column named OnSuccesData.

        Create the SharePoint integrated power app.

        • Open the created SharePoint list.
        • Click on Integrate, Power Apps, Customize Forms app.
        • This will create a basic SharePoint integrated power.
        • Remove the Attachments DataCard.
        • Click on the SharePointForm1 and add a custom datacard.
        • Add a label and a Text Input objects on the datacard.
        • Rename the label to lbl_OnSuccesData.
        • Rename the Text Input to txt_OnSuccesData.
        • Set the OnChange to the following code.
          • We need to store the Text value in a variable, because when you call directly for txt_OnSuccesData.Text it will work for editing items but not for creating items.
        Set(varOnSuccesData, txt_OnSuccesData.Text);
        • Set the 2 objects below each other.
        • Set the text of the label to On Succes Data.
        • Set the Default of the text input to "".
        • Create a new blank Power Automate flow from the power app.
        • Name the flow to Actions after submission.
        • Set the following text inputs.
          • ItemID
          • OnSuccesData
        • Add the SharePoint action Update item and set it for the earlier created SharePoint list.
        • Set the Id to ItemID from the power app.
        • Set On Succes Data to OnSuccesData from the power app.
        • Save the Power Automate flow.
        • Open the Power App again.
        • Select the OnSuccess property of the SharePointForm1 object.
        • Add before the ResetForm(Self); code the following code to start the Power Automate flow.
        Actionsaftersubmission.Run(SharePointForm1.LastSubmit.ID, varOnSuccesData);
        • Test your app by putting a text in the title and a text in the second On Succes Data text input object.
        • After you save the form, the flow will start and store the On Succes Data in the SharePoint on success data column.