Forem: Kinga

XPath in Power Automate - diagrams

Kinga — Fri, 11 Jul 2025 08:50:33 +0000

Visual examples available via GitHub Pages XPath in Power Automate - diagrams illustrate xpath transformation in Power Automate, focusing on syntax, node targeting, and transformation logic.

They are based on the concepts introduced in the original post XPath in Power Automate.

Display XML Nodes

When processing structured content in Power Automate, combining the Select action with xpath expressions provides a performant and scalable way to extract and reshape data.

The Display XML Nodes page demonstrates three different ways of displaying results of xpath queries. Usage of Apply to each and Create HTML table is purely for demonstration purposes.

Whenever possible, use Select actions, as they have a number of advantages when compared with Apply to each. They are much faster, especially when processing large volume of data, and reduce complexity in flow design.

Select nodes

"Select nodes" examples present results of xpath transformations using Apply to each action, with Compose using simple xml(item()).

Typically, the results of xpath transformations would be provided as a source for Select action, to aggregate necessary information

Select: nodes information, attributes, transformations

These examples are using Select actions. Nodes selected using xpath (From property) are further transformed using xpath expressions for each returned node.

GitHub Pages: XPath in Power Automate - diagrams

Add-PnPApp: Unable to connect to the SharePoint Online Admin Center

Kinga — Fri, 30 May 2025 13:15:17 +0000

Following our code freeze, I enjoyed a long moment of blissful ignorance =)

But last Wednesday, I was abruptly confronted by harsh reality... My deployment pipeline failed (?!)

It's not you, it's M..?

Of course I assumed I broke something. Perhaps I removed permissions that my pipeline is using?

But... I tested deployment in my development environment with Sites.FullControl.All for Microsoft Graph and Office 365 SharePoint Online APIs. Yes, Sites.FullControl.All. I still got an error.

And what does "admin center" have to do with deploying an app to a site-level app catalog? My guess would be... nothing (?)

And then I came across the [BUG] In Add-PnPApp overwrite is not working throws error The current user does not have the permission to access the App Catalog and realized that I'm not the only one. Moreover, it seems the command was not working 3 months ago, then got fixed a week later (💪) and 3 weeks ago another issue appeared, with the PnP PowerShell trying to access the Admin Center. It's been malfunctioning ever since.

I think I've had enough

Did you know that PnP PowerShell is basically a wrapper for a set of SharePoint REST and Graph APIs? The code for the Add-PnPAPp is here

All I had to do is to write my own PowerShell functions that would make the SharePoint REST API requests.

You will find them here: Gist

The SPFx-DeployApps.ps1 file is called from the pipeline, from the AzurePowerShell@5 task:

task: AzurePowerShell@5
          name: deploySPFxSolution
          inputs:
            azureSubscription: ${{parameters.serviceConnection}}
            azurePowerShellVersion: LatestVersion
            ScriptType: FilePath
            ScriptPath: $(scriptsDir)/SPFx-DeployApps.ps1
            ScriptArguments: >
              -tenantName '$(Az_TenantName)'
              -siteName '$(SPO_SiteName)'
              -folderPath '$(artifactsLocation)'

It calls functions defined in SPFX-deploysolutions.ps1 to upload and deploy the app.

Authentication

I'm not providing client ids, secrets, or certificates, because I'm using ServiceConnection with Workload Identity Federation.

The Service Principal used as the Pipeline Identity has Sites.Selected API Permissions on the target SharePoint site, with fullControl granted to the site to be able to "Manage Web" (=add an app).
You may use the Grant-APIPermissions-ServicePrincipal.ps1 to grant all the required permissions.

Client-script in Model-driven apps: do it right from the start

Kinga — Wed, 14 May 2025 07:34:37 +0000

One of the selling points of Power Platform is the "No code/low code" approach, which makes it easy for citizen developers to build apps without needing deep technical skills.
But if you ask anyone who was around Power Platform long enough, they'll tell you that the "no code/low code" ends pretty quickly.

I find it especially true when building Model-driven apps. Sure, the platform automatically generates the user interface based on the data model, and the modern UI lets app makers customize forms and views with ease. CRUD (Create, Read, Update, Delete) operations are handled by the platform, so makers can focus on what really matters. However, when it comes to adding more complex logic, things get tricky. The built-in business rules are quite limited, and for anything beyond basic functionality, app makers often need client scripts (JavaScript), custom PCF Components (TypeScript) , functions in Dataverse (PowerFx, today still in Preview), low-code plug-ins in Dataverse (PowerFx. still in Preview) or even Plug-ins (C#) .

This post focuses on extending forms in Model-driven apps with client script.

Getting started

If you haven't written any client scripts yet, I recommend the Perform common actions with client script in Power Platform - Training | Microsoft Learn guide on performing common actions with client scripts in Power Platform. This resource will provide you with a solid foundation and practical examples.

👉 Remember to add .js at the end of the client script resource. This will help you with debugging.

Reference other .js files

If you have external dependencies, such as other JS files, make sure to configure them as dependencies to the web resource so they are loaded with the form.

👉 Web resource dependencies do not provide any control over the order in which the web resources are loaded.

Forcing refresh of your client-side script

To ensure that the new version of your script is loaded to the user's browser, use the approach described in Force refresh of custom scripts in Power Platform model-driven apps.

Use TypeScript instead of JavaScript

I'm sure I don't have to convince you that TypeScript is better than JavaScript. It offers better tooling, type safety, and catches bugs early, which is a big win when building complex apps on the Power Platform.

If you're working with Dataverse and want a solid developer experience, the Dataverse DevTools extension for Visual Studio Code is a great choice. It helps you set up your project quickly, connect to your environment, and generate strongly-typed TypeScript classes for tables and columns. This makes it easier to write clean, maintainable code when working with client scripts.

👉If you don't see the "add typescript" after installing the extension, restart Visual Studio.

👉 The connection seems active even if it isn't. Always check if your scripts got deployed, or make a habit to reconnect in the morning.

Keep in mind that there are two build modes: build-dev for debugging and build for production deployment. When deploying production version (build), all your files will be bundled into a single JavaScript file to avoid external dependencies.

👉 If you import just one method from a class, the entire class (including unused methods) gets included in the build. To keep the final file size smaller, it’s better to export only the functions you actually need.

Debugging

Debugging locally can save you a lot of time since you don’t have to wait for the file to be deployed and published every time you make a change. To make this easier, check out Microsoft’s guide on using Fiddler Auto Responder for script web resource development in model-driven apps.

Build in dev mode

Be sure to rebuild your project using the build-dev mode for local testing.

Is Auto-responder working?

Ensure that capturing is enabled. If it’s active, and the mapping is configured correctly, the file information will be displayed in green.

Clear the cache

If your form was already open, the JavaScript might be cached. To clear it:

Press F12 to open DevTools
Go to Application > Cache Storage > WebResources
Delete the folder

still with DevTools open, use "Empty cache and hard refresh"

Unit tests

Once your codebase becomes more stable, it's a good idea to start writing unit tests. This helps ensure your logic works as expected and makes it easier to catch bugs when making future changes.

The Dataverse DevTools project installs @types/xrm to provide type definitions, but keep in mind that the actual XRM context isn’t available in the test environment - it’s only present when the app is running in the browser.

When writing unit tests, you may choose to:

Mock the Xrm object manually: This is a simple and lightweight approach that works well for small or straightforward apps. You'll need to manually mock every method your code calls, which can get tedious as complexity grows.
Use the xrm-mock library: This provides a more structured way to simulate the XRM environment. It covers many common methods, though some of them throw "Not implemented". If something’s missing, you can still use jest.spyOn (or a similar method in your test framework) to mock specific return values or behaviors.

Both methods have their place. Choose based on your project’s complexity and testing needs.

Automated testing

👉 It's funny how some of the most useful tools seem buried, isn't it? One great example is the Power Apps Test Engine - a powerful but often overlooked resource. It’s packed with tools, guides, and best practices to help you apply low-code testing effectively in your Power Apps projects. Whether you're just getting started or looking to level up your testing strategy, it's definitely worth exploring.

Business Rules vs Client Script

Kinga — Tue, 13 May 2025 13:33:20 +0000

Although Microsoft recommends implementing custom logic using configuration (such as Business Rules), it quickly becomes apparent that this approach has its limitations.

Business Rules can:

Set field values and default values (triggered only on "create"). The value can be static or based on another field's value, but no additional data transformations are supported (e.g. string concatenation).
Lock or hide controls.
Set "business required" to either "Business required" or "Not business required," with no option for "Business recommended".
Display error messages next to specific fields.
Provide recommendations: display business rationale and, if the user accepts the recommendation, set the field's value to a static value, another field's value, or leave it empty.

Business Rules are enforced either at the entity or form level, so you don't have to worry about your script failing.

Make sure that users have a security role that includes, at a minimum, user scope read privileges on the Process table. Otherwise Business Rules may not be executed.

Business Rules have certain limitations that need to be considered:

They cannot read if he field is disabled or hidden.
They can only be applied to fields, not to grids, sections, or tabs. To hide a whole section, each control within the section must be hidden separately.
They do not work with Multi-select choices 😢, unique identifier and rollup columns.
They cannot retrieve related records. This must be done using client script (JavaScript) and Web API.
They do not bubble events. If a control is changed by a Business Rule, it will not trigger its own Business Rule until the form is saved (or autosaved). It will also not trigger JavaScript events.
They cannot check user's roles, or global settings like user's preferences (e.g., language), organization settings, or client information.
There is no exception handling or debugging. You can see which Business Rules are loaded and in which order using Monitor.
Only up to 10 if-else conditions are supported in a Business Rule. According to my experience, it maximum 9.
Actions/conditions cannot be copied, which requires a lot of manual effort if your form is complex. However, you can copy Business Rules.
Business Rules cannot call JavaScript, so there is no way to perform string/date operations like concatenating strings or getting timestamps.
They won't fire on an editable grid when the editable grid is configured on a dashboard page.

Another issue is (probably an edge) scenario that I encountered creating a demo involved creating the following two Business Rules:

which results in a "cyclical reference" error once the second business rule is activated.

What runs first? Business rule or JavaScript?

Let's assume you have a Business Rule, and a client-script event handler defined for the same field.

JavaScript will execute first when it is attached to form events such as onLoad, onSave, or onChange. This is because JavaScript runs on the client side and can react immediately to user interactions on the form.

Business rules, on the other hand, are processed on the server side and are executed asynchronously.

Fields changed by a business rule will only trigger their own Business Rules once the form is saved (or auto saved). Field changes performed by Business Rules will not trigger JavaScript onChange event handler.

The demo below is configured as follows:

F.BR is set by a Business Rule based on the value the a START field,
F.JS is set by an onChange event handler associated with the START field,
F.BR.BR is set by a Business Rule based on the F.BR field's value,
F.BR.JS is set by an onChange event handler associated with the F.BR field,
F.JS.BR is set by a Business Rule based on the F.JS field's vlaue
F.JS.JS is set by an onChange event handler associated with the F.JS field.

As you see:

fields changed by an onChange event handler will trigger Business Rules and client-side event handlers. Remember to call fireOnChange(), though.
fields changed using Business Rules will not trigger client-side event handlers, and their own Business Rules will be executed once the form is saved.

Business rules execution sequence

The execution order of business rules can be managed based on their activation sequence.

To change the execution order:

deactivate all business rules.
activate them one by one in the desired order. The first activated rule will run first, and the last activated rule will run last. Yupp... 😶

How do you find the sequence then?

You can use Live Monitor to detect the execution order. Play your app, and filter the entries using Operation equals FormEvents.businessrule. Open the FormEvents.businessrule side panel and expand data, FormEvents.

For business rules activated in alphabetical order:

And once the rules are activate in descending order:

However, remember that they execute asynchronously. Even if you change the execution order, you cannot count on the first business rule completing before the next one is triggered.

Business Process Flow With Custom Buttons

Kinga — Thu, 17 Apr 2025 13:20:39 +0000

TLDR: I made a reusable script for model-driven apps that allows you to use custom buttons to move between business process flow stages. It also prevents user from using the default buttons. The unmanaged solution is here: GitHub/Releases and the code is here: GitHub

Business Process Flow in Power Platform guides app users through a sequence of predefined steps, ensuring that all the required fields are completed before progressing to the next stage.

The buttons allowing users to move to the next stage are.. well... well hidden.

Good choice? Bad choice?

Perhaps when working with a small group of users, it's manageable to show each person where to find the Next Stage / Previous Stage buttons. But when you're building an app intended for company-wide use, it becomes an obstacle.

Custom buttons

That's why it's common to add custom buttons to the toolbar (and to declutter it while you're at it).

These custom buttons can be shown or hidden (or enabled/disabled) based on specific conditions, such as whether the user has a certain role, the form is completed, or an approver has made a decision.

You may also use these buttons to trigger additional logic, like updating the "Status Reason" field, showing notifications, or even preventing the user from moving to the next stage based on custom conditions.

However, if you take this approach, make sure the default buttons cannot be used to bypass this additional logic.

Disabling / hiding BPF buttons?

It is of course possible to manipulate the DOM of your model-driven apps, but... it's not supported. The supported approach is to use the onPreStageChange event to call the executionContext.getEventArgs().preventDefault().

This event runs before the stage changes - whether triggered by a user clicking one of the standard Business Process Flow buttons (i.e. Next Stage, Previous Stage, or Set Active Stage), or by programmatic calls such as formContext.data.process.moveNext, formContext.data.process.movePrevious, or formContext.data.process.setActiveStage.

This means that when implementing custom logic, we need to make sure the custom buttons are allowed to perform the stage transition, while blocking all other requests.

Gotcha: the "Finish" action

Unfortunately, according to my tests, calling preventDefault() in either the OnPreStageChange or the OnProcessStatusChange will not stop the Finish action in Business Process Flow.

I worked around this issue by adding an additional, final stage and immediately completing the flow as soon as that stage is reached.
This stage wouldn’t be used by users - it is there to help finalize the process.

The solution

I made a "plan minimum" solution that covers the most important parts of the process. It consists of two custom buttons and a reusable script that:

ensures that only custom buttons can move business process flow between stages,
updates the record's Status Reason and Status fields according to the current stage,
calls rollback function if required,
displays notifications,
automatically finalizes the last stage,
restarts the business process flow if Previous Stage button is clicked in Finalized stgae

Move to the next stage

Move to the previous stage

This logic is supported by a client-side script used by the form and the custom buttons:

In the form's OnLoad, an event handler is added for the onPreStageChange event.
The onPreStageChange event handler ensures the request came from the custom buttons. Otherwise the navigation is cancelled using executionContext.getEventArgs().preventDefault().
The custom buttons set a isCustomButton to true to make sure the move to the stage will be allowed. The variable is saved in the browser's local cache.
The custom buttons handle any additional logic (e.g. set record's fields) and move to the next/previous stage. In case of errors they call rollback functions. Finally, they reset the isCustomButton to false.
The business process flow is finished by completing the process and setting the record to Inactive.
During process restart, the record is re-activated and the business process flow is moved back to the previous stage.

The code supports both scenarios: with and without automatic completion of the final stage.

Demo

In order to see this demo in action, download the packaged solution from Github and import it to your Power Platform Environment.

Source code

If you'd like to use this script in your own solution, the source code is also on GitHub. It's Typescript, you will need - Dataverse DevTools

Get SharePoint location for Dataverse record

Kinga — Wed, 26 Feb 2025 09:13:20 +0000

SharePoint document management for Dataverse offers numerous advantages. But while accessing documents and their locations via a model-driven Power Platform app is straightforward, retrieving them using Power Automate can be quite challenging.

If you need to archive attached documents in a different location or send them all via email as attachments, you must first locate the SharePoint Online (SPO) library and folder associated with the entity.

Get SharePoint location for record

The "Get SharePoint location for record" flow uses the Document Location Dataverse table to gather details about the attachment location, such as the Relative URL (folder name) and sharepointdocumentlocationid.

Once SharePoint integration with Dataverse is configured for an entity, an entry pointing to the library in SharePoint is added. Note that the library name is based on the table logical name:

Only when the first document is attached to a record, additional entry is created in the Document Location table , referencing a folder in the SharePoint library. The folder name is based on the record properties:

The above values are not enough to access the SharePoint location where the documents are stored, but can be used in a call to the RetrieveAbsoluteAndSiteCollectionUrl() Dataverse function to obtain the SharePoint Online site collection URL:

/api/data/v9.2/sharepointdocumentlocations(sharepointdocumentlocationid)/Microsoft.Dynamics.CRM.RetrieveAbsoluteAndSiteCollectionUrl()

The flow then executes a series of SharePoint REST api calls to obtain a full set of information, like

parameter name	description	example
`tenant_name`	the URL of the tenant's root site; also used as a hostname when retrieving SPO site using GUID.	`contoso.sharepoint.com`
`site_url`	The URL of the current SharePoint site, as defined in the `site URL` parameter.	`https://contoso.sharepoint.com/sites/XYZ`
`site_title`	Title of the current SPO site	`Project XYZ`
`site_id`	The `id` of the current SPO site in a `guid` format.	`xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`
`web_id`	The `id` of the current SPO web object in a `guid` format.	`yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy`
`library_absolute_url`	The full URL of the library.	`https://contoso.sharepoint.com/sites/XYZ/idapps_externalcloudservice`
`library_name`	The `RootFolder`. Used in the URL, is generated automatically and cannot be changed by users. It can be changed with PowerShell.	`idapps_externalcloudservice`
`library_title`	The title of the library. This property can be changed by the user.	`The Archive Library`
`library_id`	Library's id in a `guid` format	`zzzzzzzz-zzzz-zzzz-zzzz-zzzzzzzzzzzz`
`library_drive_id`	Used by Graph API when referencing libraries.	`b!S3SdNSBmTUGa4v5ffh_rslLJssoXH4xEuShkEO-uxKg9bblUMeoaTbQC5t69DJ-x`
`folder_absolute_url`	absolute url of a SPO library folder associated with the current teams channel	`https://contoso.sharepoint.com/sites/XYZ/idapps_externalcloudservice/test01_5437302CBC7A4D96AFD9BDFDAF15EF7F`
`folder_display_name`	display name of the folder; white spaces are not encoded	`test01_5437302CBC7A4D96AFD9BDFDAF15EF7F`
`folder_drive_id`	`driveItem Id` for the folder. Can be used in MS Graph API Get driveItem	`01JEVXUVBDVF6ZMUFRM5B34EGLOEDAUF5B`
`folder_id`	SPO list item id. Can be used in SharePoint REST API, or MS Graph API Get listItem	`15`
`error_message`	The error message if any of the actions failed, or empty string.	`{"Error":"..."}`
`success`		`True` or `False`

You may download the solution with Power Automate workflow including the above examples from Power Automate Utils GitHub repo.

Ever created a multi-lingual model-driven app, and had to add automation accessing user’s input? In the correct language, that is? If yes, you know it ain’t trivial :) Now you can use my Power Automate workflow to speed up your work.

Kinga — Tue, 25 Feb 2025 12:02:31 +0000

Get Localized choice values for Dataverse record

Kinga ・ Feb 25

#powerplatform #powerautomate #dataverse #powerapps

Get Localized choice values for Dataverse record

Kinga — Tue, 25 Feb 2025 11:00:31 +0000

Model-driven applications offer excellent support for building multilingual applications. Translations for UI elements and entity configurations can be easily provided using an Excel file, and the application adapts to the user's selected language through the Personalization settings (see Languages tab options).

When accessing record information through Power Automate, choice field values are presented as numerical codes rather than their display names. To obtain the choice display names in the user's language, these numerical values must be retrieved using tools like Power Automate.

Get Localized choice values for record

The "Utils - Get Localized choice values for record" workflow retrieves definitions of choice and multi-choice fields in a Dataverse table, providing numerical values and labels for each choice in a specified language. It can be used either as a child workflow or as a standalone flow, and accepts the following parameters:

Parameter name	Description
Table name	The logical name of dataverse entity, as defined in Properties / Advanced options / Logical name
lcid	LCID code of a language, e.g. 1033 for English. Consider saving the language used by the user when a record is created. You may retrieve the language code using JavaScript: `Xrm.Utility.getGlobalContext().userSettings.languageId`
lcid fallback	LCID code of language used as a fallback, in case the primary language is not detected. Use the default language of your environment.

The definitions of choice columns are retrieved using "Invoke an HTTP request" action, calling the following endpoints:

https://org0api.crm17.dynamics.com/api/data/v9.2/EntityDefinitions(LogicalName='ENTITY_NAME')/Attributes/Microsoft.Dynamics.CRM.PicklistAttributeMetadata request for single-choice, and
https://org0api.crm17.dynamics.com/api/data/v9.2/EntityDefinitions(LogicalName='ENTITY_NAME')/Attributes/Microsoft.Dynamics.CRM.MultiSelectPicklistAttributeMetadata request for multi-choice fields.

Important: The "HTTP with Microsoft Entra ID (preauthorized)" connector operates through a Microsoft 1st party trusted application. This application includes preauthorization for various Microsoft services and there is no need for administrators to explicitly grant consent for actions to be executed by the application on behalf of the user.
Microsoft also released a new version of the connector, the "HTTP With Microsoft Entra ID", allowing administrators to grant discrete consent.

The reason for using the "HTTP with Microsoft Entra ID (preauthorized)" connector in this workflow is to ensure it works immediately once configured, and no additional action must be executed by the administrators.

Update the workflow to use the "HTTP With Microsoft Entra ID" connector, if required.

The flow returns the following values:

Name	Description
Results	JSON object with the following structure: `[{"LogicalName":"fieldName","Options":[{"Value":339870000,"Label":""}]}]`
Error message	Empty, if success. Otherwise error message
Success	"True" or "False"

Importing solution

When importing a solution, you will need to provide a connection reference to your Power Platform Environment. Ensure that the connection is created using the URL of your Power Platform Environment.

The value of "URL of the request" does not include a host name. The request URL will be created by combining the URL specified in the referenced connection with the API endpoint defined in the "URL of the request" field.

Using the flow

The Get Localized choice values - test flow provides an example on how to use the results returned by the Get Localized choice values flow.

To speed up the retrieval of the localized label, the results from the child flow are converted into an XML object, and an xpath expression is used to quickly extract the correct value.

The sxPathQuery variable is set to the following expression:

//arr[LogicalName="{fieldName}"]/Options[Value={fieldValue}]/Label

The {fieldName} and {fieldValue} tokens are replaced by a field logical name and a numerical value, and used in the xpath() expression, e.g.

xpath(outputs('Compose:_Json_to_Xml'), concat('string(', replace(replace(variables('sxPathQuery'), '{fieldName}', 'kk_targetgroup'), '{fieldValue}', '339870000'), ')')), or

xpath(outputs('Compose:_Json_to_Xml'), concat('string(', replace(replace(variables('sxPathQuery'), '{fieldName}', 'kk_country1'), '{fieldValue}', '756'), ')'))

When building real-life solution, you would define the fieldValues based on the record's properties.

You may download the solution with Power Automate workflow including the above examples from Power Automate Utils GitHub repo.

XPath in Power Automate - cheat sheet

Kinga — Mon, 17 Feb 2025 13:32:50 +0000

While Power Automate documentation does not explicitly state the XPath version supported by the xPath() function, there are sources that confirm Power Automate supports XPath 1.0. Sources like... community discussions, or failed tests when using XPath 2.0 😉

For the XPath reference, including supported syntax and functions, see XPath Reference

the bookstore

Most of the examples I found for using xpath in Power Automate cover the very basic example of the bookstore.

Let's extend the example with additional books and chapter information.

<?xml version="1.0" encoding="UTF-8"?>
<bookstore>
    <book>
        <title lang="en">Harry Potter</title>
        <author>J K. Rowling</author>
        <year>2005</year>
        <price currency="USD">29.99</price>
        <info>
            <chapters>
                <chapter>
                    <name>The Boy Who Lived</name>
                    <page>1</page>
                    <description>Introduction to Harry Potter's early life.</description>
                </chapter>
                <chapter>
                    <name>The Vanishing Glass</name>
                    <page>15</page>
                    <description>Harry's encounter with a snake at the zoo.</description>
                </chapter>
            </chapters>
        </info>
    </book>
    <book>
        <title lang="de">Der Hobbit</title>
        <author>J.R.R. Tolkien</author>
        <year>1937</year>
        <price currency="USD">19.99</price>
        <info>
            <chapters>
                <chapter lcid="1031">
                    <name>Eine unerwartete Party</name>
                    <page>1</page>
                    <description>Bilbo Beutlin trifft die Zwerge.</description>
                </chapter>
                <chapter lcid="1031">
                    <name>Gebratenes Hammelfleisch</name>
                    <page>35</page>
                    <description>Die Zwerge begegnen Trollen.</description>
                </chapter>
            </chapters>
        </info>
    </book>
    <book>
        <title lang="en">1984</title>
        <author>George Orwell</author>
        <year>1949</year>
        <price currency="USD">14.99</price>
        <info>
            <chapters>
                <chapter>
                    <name>The Principles of Newspeak</name>
                    <page>1</page>
                    <description>Introduction to the language of Oceania.</description>
                </chapter>
                <chapter>
                    <name>War is Peace</name>
                    <page>50</page>
                    <description>Explanation of the Party's slogans.</description>
                </chapter>
            </chapters>
        </info>
    </book>
</bookstore>

Important! Remember to parse the string to xml object using xml() function.

Selecting Nodes

xPath expression	Result
`xpath(variables('oBookstoreXml'),'//book/*')`	all direct descendants of 'book' nodes
`xpath(variables('oBookstoreXml'),'//book/[@]')`	all direct descendants of 'book' nodes, which have at least one attribute of any kind
`xpath(variables('oBookstoreXml'),'//book[title[@lang="en"]]')`	all 'book' nodes where title has parameter lang='en
`xpath(variables('oBookstoreXml'),'//book/*[self::title or self::author]')`	all title and author elements of all book nodes ^*

^* The | operator, used for for selecting several paths, is not supported in xPath 1.0.

XPath functions

I'm using Select action in all the examples.

For a list of supported XPath functions, see XPath Functions.

Example 1

Select all direct descendants of 'book' nodes and read nodes information. This example used the following XPath functions: name(), string(), count(), concat(), position().

From: xpath(variables('oBookstoreXml'),'//book/*')
Map:

value	expression
nodeName	`xpath(item(), 'name(/*)')`
nodeValueAsString	`xpath(item(), 'string(/*)')`
chapterCount	`xpath(item(), 'count(//chapter)')`
chapterInformation	`xpath(item(), 'concat("This node has ",count(//chapter), " chapter child nodes")')`
nodePosition	`xpath(item(), 'position()')`

Results

[
  {
    "nodeName": "title",
    "nodeValueAsString": "Harry Potter",
    "chapterCount": 0,
    "chapterInformation": "This node has 0 chapter child nodes",
    "nodePosition": 1
  },
  {
    "nodeName": "author",
    "nodeValueAsString": "J K. Rowling",
    "chapterCount": 0,
    "chapterInformation": "This node has 0 chapter child nodes",
    "nodePosition": 1
  },
  //....
  {
    "nodeName": "info",
    "nodeValueAsString": "\n  \n    \n      The Boy Who Lived\n      1\n      Introduction to Harry Potter's early life.\n    \n    \n      The Vanishing Glass\n      15\n      Harry's encounter with a snake at the zoo.\n    \n  \n",
    "chapterCount": 2,
    "chapterInformation": "This node has 2 chapter child nodes",
    "nodePosition": 1
  },
  //...
]

The position() function returns 1 for each node, because the xpath expressions in the Map section only have access to the chunk returned by the From query.

Some string functions, .e.g. upper-case(), would throw an error because they are not supported in XPath 1.0.

Example 2

Select all direct descendants of 'book' nodes, which have at least one attribute of any kind. This example focuses on working with attributes: filtering based on their presence and accessing their values

From: xpath(variables('oBookstoreXml'),'//book/*[@*]')
Map:

value	expression
nodeName	`xpath(item(), 'name(/*)')`
attributeLang	`xpath(item(), '//@lang')`
attributeLangValue	`xpath(item(), 'string(//@lang)')`
anyAttribute	`xpath(item(), '//@*')`

Results

[
  {
    "nodeName": "title",
    "attributeLang": [
      "lang=\"en\""
    ],
    "attributeLangValue": "en",
    "anyAttribute": [
      "lang=\"en\""
    ]
  },
  //...
]

Example 3

Select all 'book' nodes where title has parameter lang='en', perform more complex transformations to retrieve results as string, array or a JSON object.

From: xpath(variables('oBookstoreXml'),'//book/*[@*]')
Map:

value	expression
titleAsArray	`xpath(item(), '//title/text()')`
chapterAsArray	`xpath(item(), '//chapter/name/text()')`
titlesAsString	`xpath(item(), 'string(//title)')`
chapterAsString	`xpath(item(), 'string(//chapter/name)')`
chaptersAfterPage10AsArray	`xpath(item(), '//chapter[page>10]/name/text()')`
chaptersAndPages	`xpath(item(), '//chapter/*[self::name or self::page]/text()')`
titleAndChaptersAsJSON	`json(concat('{"title":"',xpath(item(), string(//title)'),'","chapters":',xpath(item(), '//chapter/name/text()'),'}'))`

Results

[
  {
    "titleAsArray": [
      "Harry Potter"
    ],
    "chapterAsArray": [
      "The Boy Who Lived",
      "The Vanishing Glass"
    ],
    "titlesAsString": "Harry Potter",
    "chapterAsString": "The Boy Who Lived",
    "chaptersAfterPage10AsArray": [
      "The Vanishing Glass"
    ],
    "chaptersAndPages": [
      "The Boy Who Lived",
      "1",
      "The Vanishing Glass",
      "15"
    ],
    "titleAndChaptersAsJSON": {
      "title": "Harry Potter",
      "chapters": [
        "The Boy Who Lived",
        "The Vanishing Glass"
      ]
    }
  },
  //...
]

string() function converts nodes to strings, while /text() is a node test that selects text nodes directly.

The xpath(item(), '//chapter/*[self::name or self::page]/text()') expression selects multiple paths in a way supported by XPath 1.0.

The xPath expression used by titleAndChaptersAsJSON is a bit more involved and is using both, Power Automate and XPath functions.

json(
 concat(
  '{"title":"',
     xpath(item(), 'string(//title)'),
   '","chapters":',
     xpath(item(), '//chapter/name/text()'),
'}')
)

The json() function allows us to return an object. the concat() function generates string representing the object. Both of these functions are Power Automate functions.

The value returned as title is retrieved using string(//title) XPath expression ensuring that the returned value is a string.

The chapters list is retrieved using //chapter/name/text() XPath expression, returning a list of string values.

What didn't work.

The xpath(item(),'//book/concat(title/text(), " - ", author/text())') expression would be useful in transforming XML to an object with a simplified structure. Unfortunately, XPath 1.0 does not support the concat function directly within the path expression.

Beyond XML

xpath() is an incredibly useful and powerful function, that can speed up content transformations. And its application goes beyond to parsing XML files. Whenever the Select action is not enough, and I want to avoid using Apply to each, I transform JSON to XML and use xPath() for more power 🚀🚀🚀

Value: xml(json(concat('{ "root": { "arr": ',variables('jsonResponse'), '}}')))

If you are unsure when to use Select vs Apply to each action in your workflows, see Streamlining your Power Automate Flows with the Select Action.

You may download the solution with Power Automate workflow including the above examples from Power Automate Utils GitHub repo.

Stay tuned for my next example, showing the sheer power of Select and xPath working together.

My posts by technology

Kinga — Sun, 05 Jan 2025 14:36:47 +0000

Azure

CI/CD

Change Management in Infrastructure as a Code (IaC)

Security

Development

Azure DevOps

CI/CD

Not-so-random issues

Power Platform

Licensing

Development

Utils

SharePoint Development

Security

CI/CD

Development

Tools

SharePoint Migration with ShareGate PowerShell

Hacked by...

PowerShell

ImportExcel and Conditional Formatting

Get SharePoint library info from Teams context

Kinga — Sun, 05 Jan 2025 14:12:06 +0000

Integration between Power Apps and MS Teams allows creating context-aware applications, that access information stored for example in the SharePoint site connected to the team.

Embedding vs integrating

Embedding Power Apps canvas apps is different from creating Canvas Apps in MS Teams.

A Canvas App created in Teams can only be edited using Power Apps app in MS teams.
The environment is not displayed in https://make.powerapps.com/, but can be found using https://make.powerautomate.com/. This is useful when you need to export solution.👈 Still, you won't be able to edit this app via browser.
The app has access to a Teams integration object, which provides context information, for example team id and group id, and channel id.

Embedded Canvas App, on the other hand, is a standalone Canvas App, added to MS Teams.

Embedding Canvas Apps in MS Teams, available since March 2020, gives an app access to the team's context information using the Param('parameterName').

The team Id parameter

Sadly... the id returned by teamId parameter is not a team's guid, but an internalId.

The best explanation of these internalIds can be found in stackoverflow

I find it very unfortunate.
The internal id cannot be used with either the Teams Power Automate actions, or the MS Graph API.
Calling the https://graph.microsoft.com/v1.0/teams?$select=id,internalId returns null for the internalId. The only way of retrieving the guid is indeed retrieving all the teams the user has access to, and for each of them, retrieving the id and internalId values.
In terms of solution design, this seems like an anti pattern...

Moreover, the licensing document states that the M365 licenses provide "limited usage rights" to Power Platform, allowing users to extend the M365 services in order to support business processes. But finding the team's guid requires using Premium connector because the Send a Microsoft Graph HTTP request action does not support https://graph.microsoft.com/v1.0/teams?$select= id,internalId query.

So dissapointing...

Fetching `id`, `driveId`, `webUrl`, etc.

Nevertheless... I decided to build a flow that retrieves all the guids, ids, names and paths that might be useful in building Power Platform solutions.

Depending on which Power Automate action you are using, you will need to know the target location's URL, guid, driveId or list title. I briefly described this topic in my previous post: Data Source Environment Variables in Power Automate actions.

Retrieving these values based on the team and channel internalId requires the following steps:

get guids of all teams the user has access to and for each of them, fetch the internalId property. If the internalId is equal to teamId provided by the MS Teams context, this is the team you are looking for. the guid will be used to access team information with MS Graph. Unfortunately, the internalId is null when retrieving all teams with https://graph.microsoft.com/v1.0/teams?$select=id,internalId
get SharePoint folder information for the Teams channel, using the guid retrieved in the previous step, and the channelId from team's context. The https://graph.microsoft.com/v1.0/teams/{teamGuid}/channels/{channelId}/filesFolder?$select=id,name,parentReference query returns id, name and parentReference properties, which are used by drives API in the next step.
get SharePoint folder information by calling https://graph.microsoft.com/v1.0/drives/{driveId}/items/{id}/listItem?$select=id,webUrl,parentReference. This query returns folder id (integer), absolute URL and a reference to a SharePoint site used by the channel. The parentReference/siteId returns tenantName,SiteId,WebId.
get library information using https://graph.microsoft.com/v1.0/drives/{driveId}/list?$select=id,webUrl,name,displayName,parentReference. This query returns library information: display name, internal name which is used as part of the url, library guid and absolute URL
get site information using https://graph.microsoft.com/v1.0/sites/{siteId}?$select=name,weburl,displayName

Results

The output may be used in a parent Power Automate flow, to access library and folder used to store channel's documents.

To test it, add the Get Teams Channel Library Info - test Power App to a MS Teams channel.

The top section displays Teams context parameters. The Fetch folder information button triggers the Get Teams Channel Library Info flow, with results displayed below:

Prerequisites

This Power Automate Flow is using HTTP with Microsoft Entra ID connector, which requires Premium license.

In order to successfully execute the flow, you need to grant the PowerPlatform-webcontentsv2-Connector service principal the following API permissions to Microsoft Graph resource:

Channel.ReadBasic.All
Team.ReadBasic.All
Files.Read.All

Follow the Authorize the connector to act on behalf of a signed-in user procedure to grant the permissions.

Doesn't work!

If you see a " Missing scope permissions on the request." error, it is possible that you tested the flow before granting the required API permissions. Now you have to wait. According to my experience - approximately one hour.

Download the solution

You may download the workflow from the Power Automate Utils github repository.

The flow accepts two parameters: teamsId and channelId. Depending on the app type, use the following parameters:

	Embeded Canvas App	Integrated Canvas App
`teamId`	`Param("teamId")`	`Teams.ThisTeam.Id`
`channelId`	`Param("channelId")`	`Teams.ThisChannel.Id`

Resources

Invoke an HTTP request without a premium license: connectors summary

Kinga — Fri, 27 Dec 2024 13:31:00 +0000

As of today, there are six Power Automate standard connectors allowing us to send http requests to Microsoft 365 tenant.

These connectors provide Send an HTTP request actions that support only a subset of MS Graph API endpoints.
If they don't provide the required functionality, you may need to use a premium HTTP action to work around these limitations. At this point you need the align the structure of the API requests, with the segments supported by each Send an HTTP request action.

I personally like preparing my API requests using Graph Explorer first, as this allows me to explore the Microsoft Graph API, find out which parameters should be used, and what information is returned by the endpoints.

Important:These are not shareable connections. If the power app is shared with another user, another user will be prompted to create new connection explicitly.

HTTP actions summary

Also important: Below, I'm only providing evaluation of GET functions.
All the Send HTTP actions support GET, POST, PUT, PATCH and DELETE

Office 365 Users

Segments supported: 1st segment: /me, /users/, 2nd segment: messages, mailFolders, events, calendar, calendars, outlook, inferenceClassification.

Supported segments	Description
`/me`	Get the signed-in user's details. Get a user
`/users/{id / service principal}`	Gets a specific user by Id (GUID) or a service principal name (`user@contoso.onmicrosoft.com`). Get a user
`/users/{id}/messages`	Lists the user's email messages in their primary inbox. List messages
`/users/{id}/mailFolders`	Get the mail folders directly under the root folder of the signed-in user, including by default: `Archive`, `Conversation History`, `Deleted items`, `Drafts`, `Inbox`, `Junk Email`, `Outbox`, `Sent Items` List mailFolders
`/users/{id}/events`	Lists the user's upcoming events in their calendar. List events
`/users/{id}/calendar`	Returns the information about the user's default calendar. calendar resource type
`/users/{id}/calendars`	Get all the user's calendars from either the default or a specific calendar group. List calendars
`/users/{id}/outlook`	Returns Id in a `user-id#tenant-id` format. It is a unique identifier for a user within a specific tenant in Microsoft Graph.
`/users/{id}/inferenceClassification`	The inferenceClassification resource in Microsoft Graph API is used to classify a user’s messages to help them focus on the most relevant or important ones. This endpoint retrieves the list of overrides a user has set up. inferenceClassification resource type

Resources

Office 365 Outlook

Segments supported: 1st segment: /me, /users/, 2nd segment: messages, mailFolders, events, calendar, calendars, outlook, inferenceClassification.

Supported segments	Description
`/me`	The first segment is supported to access the second segment, but calling the `https://graph.microsoft.com/v1.0/users/me` endpoint without the second segment will result in an error
`/users/{id / service principal}`	as above

This action is almost identical to Send HTTP request from Office 365 users connector; see the Office 365 Users above for the documentation on the rest of the supported segments.

Resources

Office 365 Outlook| Send an HTTP request action
Office 365 Outlook connector documentation for known issues, shared mailbox support information, common errors, etc.

SharePoint

This action may execute any SharePoint REST API you have access to.

Rest API is different from MS Graph API, even though MS Graph API also provides actions that access SharePoint.
SharePoint REST API is older, is supported also in SharePoint on premise, and unlike MS Graph API does not require granting API permissions to the software that is using them.

Microsoft Graph, on the other hand, is a newer approach supporting various M365 services. New actions are added to SharePoint REST API using Microsoft Graph.

See Get to know the SharePoint REST service and SharePoint connector documentation for information about delegation, throttling limits, etc.

Microsoft Teams

Segments supported: 1st segment: /teams, /me, /users, 2nd segment: channels, chats, installedApps, [3rd segment]: messages, pinnedMessages.

Supported segments	Description
`/teams`	Although `/teams` is supported to access the second segment, calling the `https://graph.microsoft.com/v1.0/users/teams` or `https://graph.microsoft.com/v1.0/users/teams/{id}` endpoint without the second segment will result in an error
`/me`	as above
`/users/{user-id / service principal}`	as above
`/teams/{user-id}/channels`	Retrieve the list of channels in a team. List channels
`/me/chats`	List all "one on one" chats for the user. List chats
`/users/{user-id / service principal}/chats`	as above
`/teams/{team-id}/installedApps`	List all app installations within a team. List apps in team
`/teams/{team-id}/channels/{channel-id}/messages`	Retrieve the list of messages (without the replies) in a channel of a team. List channel messages
`/me/chats/{chat-id}/messages`	as above
`/users/{user-id / service principal}/chats/{chat-id}/messages`	Error `User Mri does not match request initiator!`

If a combination of 1st/2nd/3rd segment is not mentioned in the table above, it is probably (at least, based on my tests), not supported.

For example, calling https://graph.microsoft.com/v1.0/chats/{chat-id}/installedApps is a correct MS Graph API call, but is not supported by the "Microsoft Teams" connector and will result in an error.

I'm also not sure how to use pinnedMessages. I only found /chats/{chat-id}/pinnedMessages in the documentation, but chats cannot be used as a first segment.

Resources

Microsoft Teams connector

Office 365 Groups

There is one segment that is supported: /groups

Supported segments	Description
`groups`	List all the groups available to the current user. List groups
`groups/{group-Id}`	Get the properties and relationships of a group. Get group

Office 365 Groups Mail

Segments supported: 1st segment: me, users, groups, 2nd segments: messages, mailFolders, events, calendar, calendars, outlook, inferenceClassification.

Although groups is not mentioned in the error message of the Send an HTTP request action, it does work just like it used to.

This action seems identical to the Send HTTP request of Office 365 Outlook connector; see the Office 365 Outlook above for the documentation on the rest of the supported segments.

Forem: Kinga

XPath in Power Automate - diagrams

Display XML Nodes

Select nodes

Select: nodes information, attributes, transformations

Add-PnPApp: Unable to connect to the SharePoint Online Admin Center

It's not you, it's M..?

I think I've had enough

Authentication

Client-script in Model-driven apps: do it right from the start

Getting started

Reference other .js files

Forcing refresh of your client-side script

Use TypeScript instead of JavaScript

Debugging

Build in dev mode

Is Auto-responder working?

Clear the cache

Unit tests

Automated testing

Business Rules vs Client Script

What runs first? Business rule or JavaScript?

Business rules execution sequence

Business Process Flow With Custom Buttons

Custom buttons

Disabling / hiding BPF buttons?

Gotcha: the "Finish" action

The solution

Move to the next stage

Move to the previous stage

Demo

Source code

Get SharePoint location for Dataverse record

Get SharePoint location for record

Ever created a multi-lingual model-driven app, and had to add automation accessing user’s input? In the correct language, that is? If yes, you know it ain’t trivial :) Now you can use my Power Automate workflow to speed up your work.

Get Localized choice values for Dataverse record

Kinga ・ Feb 25

Get Localized choice values for Dataverse record

Get Localized choice values for record

Importing solution

Using the flow

XPath in Power Automate - cheat sheet

the bookstore

Selecting Nodes

XPath functions

Example 1

Results

Example 2

Results

Example 3

Results

What didn't work.

Beyond XML

My posts by technology

Azure

CI/CD

Security

Development

Azure DevOps

CI/CD

Not-so-random issues

Power Platform

Licensing

Development

Utils

SharePoint Development

Security

CI/CD

Development

Tools

Hacked by...

PowerShell

Get SharePoint library info from Teams context

Embedding vs integrating

The team Id parameter

Fetching id, driveId, webUrl, etc.

Results

Prerequisites

Doesn't work!

Download the solution

Fetching `id`, `driveId`, `webUrl`, etc.