Tools

Power Apps Code Apps in Practice: Recreating Model-Driven App Patterns

Axel — Wed, 11 Mar 2026 14:56:40 +0000

Power Apps Code Apps in Practice: Recreating Model-Driven App Patterns Axel Wed, 03/11/2026 - 15:56

Body

Power Apps Code Apps went from preview to general availability in record time. With that, Microsoft has sent a clear signal that it is taking this technology very seriously.

In fact, Code Apps are something of a small revolution. They allow pro-code developers to deliver custom web apps directly within a Dataverse environment without the need to implement authentication libraries.

But that is not all: Low-code developers can benefit from them as well. With tools like GitHub Copilot and Claude Code, you no longer necessarily need to understand a programming language such as React in order to build full-blown web application. Instead, you can simply describe the features you want in a prompt and have them implemented.

This will fundamentally change the way how apps will be implemented in the future. React Fluent UI components can be integrated into Code Apps and open up entirely new possibilities for designing user interfaces such as accordions, cards or TreeViews.

Motivation

There is, however, one important point to consider: At the time of writing, Power Apps Code Apps are stand-alone apps. That means they are not integrated into a model-driven app, but exist as independent applications, similar to canvas apps. There is also no custom page in a model-driven app to represent a code app.

But what if you still need the typical built-in functionality of a model-driven app upfront, such as filtering records in a data grid? One option would be to add a button to the model-driven app or try to integrate the app through an iframe.

This article explores another approach: recreating typical model-driven app functionality directly inside the custom app. The goal is to assess how much effort this requires and how quickly something like this can be implemented, not to reinvent the wheel, but to demonstrate the capabilities and the power of Code Apps. And of course also to show that, for many use cases, you no longer need a model-driven app as the entry point.

PoC: Table Browser App

The goal was to build an new code app "Table Browser" from scratch which demonstrates that a standalone Power Apps Code App can reproduce familiar Model-Driven-App-style functionality, such as filtered and searchable record lists with the same look and feel like Model-Driven-Apps. This can serve as an entry point and opens the door to building a fully fledged standalone app with a much richer user experience, including features such as tree views and other advanced interface patterns that are difficult to realize in a traditional Model-Driven App.

It is also a proof of concept: each feature was chosen to answer a specific question about what Code Apps can do. A secondary goal was to evaluate these two tools in a real-world scenario and gain hands-on experience with AI-assisted development.

The entire app was built in a single Saturday — using both GitHub Copilot and Claude Code as AI coding assistants. Fun fact: Claude Code estimated the development effort for the entire app at 12 to 15 days if implemented by a senior developer without the help of AI.

Proof Points

Performance: Can a Code App render large Dataverse record sets noticeably faster than a Model-Driven grid? Yes.
Infinite scroll: How much code does it take to implement demand-driven pagination? Very little — a scroll event plus a getAll call with top and skip.
Metadata access: How easy is it to read column metadata at runtime? One SDK call to retrieveMultipleRecordsAsync on EntityDefinition gives you full attribute detail.
View definitions: Can a Code App read the default system view and use it to determine which columns to show? Yes — savedquery records expose the column layout as XML, which the app parses to build its default column set.
Form definitions: Can a Code App reconstruct the default form layout — tabs, sections, fields — without hardcoding it? Yes — systemform records contain the full form structure as JSON and XML, which the app uses to render the record detail dialog.
Column persistence: Can user preferences be stored in Dataverse instead of localStorage — cross-device, without a custom table? Yes, via personal views (userquery).

Key capabilities

Browse records from multiple Dataverse tables with infinite scroll and client-side search
Inspect column metadata and field properties (schema view)
Customize visible columns per table — persisted as personal views (userquery records) in Dataverse
View full record details in a form-based dialog with tabs and sections
Switch between list (DataGrid) and card grid layouts
Light/dark mode, display density, and accent color theming (persisted to localStorage)

UI Features

The goal was to implement the same look and feel that we know from Model-Driven-App. This can easily be achieved by using the React Fluent UI components library. The following chapters show which features have been implemented.

List View

The app uses the metadata to look for the default view of the table and shows all columns defined there.
Columns width can be changed by drag and drop.
Columns can be sorted. If sorted, an api call is used for server side sorting
Smooth paging: Scrolling to the end of the list reloads the next page of data (e.g. the next 50 records)

Search and highlighting

Search was implemented with a single field which searches in all text fields
- This was easier to implement
- A filter below every column, as in model driven apps could be another option for the future.
Highlighting the matched text was very easy to implement, so this functionality was added as well, even though it does not exist in model-driven apps

Column selection and reordering

A modal dialog window can be used to select the columns to display
A drag and drop component can be used to reorder the columns. The @dnd-kit/sortable library was used to implement this feature
The adjusted view is updated in the Dataverse personal view

Card View

A Card View as an alternative to a List View was implemented
This was quite easy because a card already exists as a UI component in the React UI Components
This view is especially useful for data with images

Detail View Edit Dialog

A detailed review was implemented to show and edit the current record
The code dynamically parses the system form record to create the layout dynamically from the defaults form definition (including tabs)
Field types text, text area, option set, lookup, yes/no, date/time are supported and fully working
Of course, the form doesn't support PCF or sub grids.
An alternative approach approach for the future, could be to redirect to a detail view, like a Model-Driven-App does

Table Column Definitions

A column meta data list was implemented
It automatically shows all columns of the table with display name, data type, required, and description
It proves that metadata can easily be fetched by the @microsoft/power-apps/data lib (for code apps)
The column metadata can also be filtered
The screenshot shows the list in dark mode. Of course, dark mode is available for the whole application.

Settings dialog

A small settings dialog was implemented for the settings of dark mode, display density, and accent color
This was very easy to implement since dark mode, accent color and density are just properties in the React Fluent UI library
The settings are stored in the local storage of the browser for simplicity

Lessons learned with GitHub Copilot and Claude Code

The project was developed almost entirely in "interactive agent-driven mode".
Both GitHub Copilot and Claude Code were used as active development assistants during the entire process.

The agents were involved in:

Concept discussions
Implementation
Refactoring
Architectural decisions
Documentation improvements
Iterative improvements to the collaboration workflow

In addition to generating code, the agents were also used to discuss best practices and improve the documentation and structure of the project itself. Both agents used the same model (Claude Sonnet 4.6), but produced different results due to their overall architectural differences.

Claude Code

Overall, Claude Code produced more consistent and reliable results.

Strengths included:

Better architectural reasoning
More structured implementations
Clearer explanations
Higher-quality refactorings

Claude Code was particularly strong when working across multiple files or when performing larger structural changes in the project. In the beginning it introduced reusable UI components even before having instructions to do so.
When working with Claude Code, development sessions occasionally reached usage limits. This required temporarily switching back to GitHub Copilot until the session limit reset. As a result, the project naturally evolved into a mixed workflow where both tools contributed to the final implementation.

GitHub Copilot

GitHub Copilot performed well for smaller tasks but showed some weaknesses when acting as a full development agent.

Some common issues included:
- Guessing instead of reasoning
- Repeating the same incorrect approach multiple times
- Getting stuck in loops when a problem was not clearly defined

However, some of these issues were likely influenced by better instructions given to the agent (e.g. links to the official documentation, instructions to always look there first)

At the beginning of the project, important rules were not yet defined, for example:
- Asking for confirmation before large refactorings
- Explaining architectural changes before applying them
- Avoiding speculative changes

Once clearer rules were established, the results improved.

Architecture

The architecture naturally follows the architecture of Power Apps Code Apps. Services for accessing data and model classes were generated using the pac tool.

The following architecture diagram was generated with Claude Code. This no longer has to be done manually by hand either...

Conclusion

It is extremely impressive how quickly and easily a Power Apps Code App can be developed with GitHub Copilot or Claude Code. What makes development so fast and straightforward is the combination of coding agents with an intelligent framework for app development.

Throughout the entire development process, there was never any sense of working with an unstable product or with something that had only recently reached general availability. There were no crashes at all, and deploying the app via solution to another environment also worked flawlessly.

Only in a few places does the API appear to be not entirely complete yet. For example, RetrieveRecordAsync did not work, so a workaround had to be implemented using GetAll with a filter expression. However, the most important actions for loading, filtering, and saving data are already very stable.

Code Apps will fundamentally change the way we build apps in Dataverse environments and across the Power Platform. Canvas Apps may soon become obsolete and be replaced by Code Apps. There may also be more options in the future to integrate Code Apps into Model-Driven Apps. Until then, however, both can coexist peacefully side by side.

Image

/sites/default/files/2026-03/Power-Apps-Code-Apps-in-Practice_1.png

Row Summary in Model-Driven Apps

Stephane Pelhatre — Tue, 14 Oct 2025 08:04:03 +0000

Row Summary in Model-Driven Apps Stephane Pelhatre Tue, 10/14/2025 - 10:04

Body

Introduction

In model-driven applications, forms often contain many fields spread across multiple tabs and sections, which can make it difficult and time-consuming to find key information. Navigating between these tabs slows productivity and increases the risk of missing important information. Finding key insights quickly can be a challenge.

The Row Summary feature solves this problem by displaying a clear and concise summary of the most important information. Makers can customize the columns to include and choose how the summary is presented (as bullet points or as a short paragraph). This allows users to get the necessary context at a glance, without having to scroll through the entire form.
Furthermore, the summary can include clickable links to related records.

At the time of writing this article, this feature is still in preview.
Summaries are currently only supported in the English language.
Preview features aren’t meant for production use and might have restricted functionality.

Enable Row Summary feature

Before you can configure a Row Summary, you need to enable the feature in your environment:

Go to Power Platform Admin Center
Select your environment
Go to Settings > Product > Features
Enable the feature AI Insight Cards

Once enabled, you’ll be able to access and configure the Row Summary feature in model-driven apps.

Configure Row Summary for a table

To configure a row summary for main forms for a specific table:

Open Power Apps Portal and select your environment
Select the table where you want to apply the row summary (e.g., Contact) from the left navigation pane and click on Row summary in the section Customizations

Another way is to select your table from the left navigation pane and click on Forms in the section Data experience

Then click on Row summary on the command bar and from the dropdown select Edit Summary to begin customization
Following window is displayed:
Now you have to define columns to include in the summary and write a prompt
- In the Prompt editor, click on +Add data or type "/" to choose the columns you want the AI to summarize (in my example: full name, job title, company name, marital status)
If you click on +Add data you can add several columns in one step which is not the case if you type "/"
- Write a custom instruction (prompt) describing how the summary should be generated
In my example below : Generate a concise summary using the selected fields. Use bullet points and return “No value” if a field is empty
Click on Test to preview the summary output (the most recently edited record is used to generate the test response)
Once satisfied, click on Apply to main forms to enable the summary across all main forms for your table

Display the list of forms : an AI icon is visible for forms where the summary is active (only main forms)

To modify an existing row summary:

In Power Apps Portal select your table where you want to modify the row summary
Click on Forms in the section Data experience
Then click on Row summary on the command bar and from the dropdown select Edit Summary

An alternative to the previous method (point 2) is to click on Row summary (applied) in section Customizations
Make your changes to the prompt or included columns and reapply

To remove a summary from all forms:

In Power Apps Portal select your table where you want to remove the row summary
Click on Forms in the section Data experience.
Then click on Row summary on the command bar and from the dropdown select Hide on all main forms

View Row Summary in Dynamics 365

Open your app in Dynamics 365 and navigate to the entity (e.g., Contact) where the row summary is configured.
Select a record in the view : an AI summary icon is displayed.

Click on this icon : AI-generated summary is displayed in a modal popup.

Note that you can copy the summary into the clipboard.

If you open a record (e.g., Contact) the summary is displayed at the top of the form in a collapsible bar (called Insights bar).

Image

/sites/default/files/2025-10/ChatGPT%20Image%20Oct%2020%2C%202025%2C%2006_24_24%20PM.png

Copilot Chat in Model-Driven Apps

Stephane Pelhatre — Mon, 06 Oct 2025 15:11:43 +0000

Copilot Chat in Model-Driven Apps Stephane Pelhatre Mon, 10/06/2025 - 17:11

Body

Introduction

Managing data in a model-driven app requires sometimes many clicks, manual navigation through views and dashboards.
With Copilot in Dynamics 365 model-driven apps users can access information instantly through AI-powered chat.

Copilot Chat is an AI assistant that helps the user to obtain information in natural language from the application data and allows an intuitive navigation. It also improves user productivity by easily accessing necessary information or menus within the application through direct access.

At the time of writing this article, this feature is still in preview.
Preview features aren’t meant for production use and might have restricted functionality.

How to enable Copilot in your environment

Go to Power Platform Admin Center
Select your environment
Go to Settings > Product > Features
Enable the feature Allow users to analyze data using an AI-powered chat experience.
3 values are available:

By Default: Copilot is turned on for Dynamics 365 licensed environments but turned off for Power Apps licensed environments
On: Copilot remains enabled, independent of the license type
Off: Copilot remains disabled, independent of the license type

How to disable Copilot Chat for a specific model-driven app

Even though Copilot is a great tool to increase productivity, sometimes you might want to disable it for a specific app.
To turn off Copilot Chat for a particular model-driven app:

Open the model-driven app in App Designer
Choose Settings from the command bar
Navigate to Upcoming
Select Off or Default for the Copilot control.

By choosing Reset to environment value in the same settings tab, you return Copilot control to the environment value.

How to use Copilot Chat

Once enabled, users can access Copilot directly via the Copilot icon in the right navigation pane.

You can start asking questions related to the tables present in the App.
For instance, I have asked a simple question to get the contacts created last week.
You can see the result below:

If you click on Show all on a page results are displayed on a specific page.

Likewise, you can ask different types of questions related to the data present in your App and explore on Copilot.
To navigate to a specific table page you can type "Navigate to..."
In the example below I entered "Navigate to Leads". The default view is displayed on the Leads page.

Dataverse Functions Deep Dive

Stephane Pelhatre — Thu, 28 Aug 2025 12:38:15 +0000

Dataverse Functions Deep Dive Stephane Pelhatre Thu, 08/28/2025 - 14:38

Body

Introduction

Microsoft released in 2024 Dataverse low-code plugins. The promise was great : writing plugins using low-code tools. No need to have development skills and use a development environment as Microsoft Visual Studio, write C# code and register plugin in your environment.

There are two types of low-code plugins supported in Dataverse : instant and automated. The difference is the trigger. For instant low-code plugin the trigger is manual, the plugin must be explicitly called (for example from a Power Automate flow). Automated low-code plugins work like classic plugins : the trigger is a Dataverse table event. For example you can create an automated low-code plugin on Create event for Account table. Low-code plugin feature is still in preview.

Then Microsoft has introduced Power Fx functions (eventually renamed Dataverse functions). Functions are a low-code/no-code way to write reusable logic directly within Dataverse. Functions use Power Fx to execute a set of commands within Dataverse that run on the server-side. The trigger is also manual, so a function must be called explicitly .
The situation is therefore somewhat confusing as instant low-code plugins resemble Dataverse functions and both features are available in preview.
Technically functions and low-code plugins are 2 different tools, with their own Microsoft Learn Docs having their own sections.

Officially instant low-code plugins are deprioritized and are replaced with Dataverse functions. Automated low-code plugins are still available. You can find more information here : Use low-code plug-ins in Dataverse

In this article we will first briefly examine low-code plugins. We won't go into detail because, as we will see, they don't really work.
Then we will examine Dataverse functions in detail.

Low-code plugins

Let's briefly talk about low-code plugins.
To access low -code plugins interface you need to install a model-driven app called Dataverse Accelerator:

Go to Power Platform Admin Center
Click on Environments on the left pane.
Then click on the ellipsis (...) next to your environment, select Resources and then Dynamics 365 apps
Click on Install app on the command bar
Select Dataverse Accelerator in the list and click on Next
Check I agree to the terms of service and click on Install
Once the installation is complete Dataverse Accelerator app is available in the list of apps

Now you can play the app and you will see the interface below:

As explained in the introduction there are two types of plugins : instant plugins that must be called explicitly and automated plugins that are triggered by an event on a table.
There is a button to create an instant plugin and another to create an automated plugin. Note that it 's a bit strange to have the option to create an instant plugin as this feature is deprioritized and replaced by Dataverse functions.

Then if you click on either of the two buttons ... nothing happens and the screen remains blank. I tried with several Dataverse environments located in different regions (US, Western Europe) with the same result : a blank screen.

This problem is understandable for instant plugins as they are replaced by functions. But regarding automated plugin it's a problem : it's impossible to create an automated plugin.
It was working a few months ago (but buggy as hell), but as of the date of writing this article (October 2025), it no longer works.
Maybe it will work again in the future or maybe Microsoft will remove this feature.

Dataverse Functions

Introduction

Functions are a low-code/no-code way to write reusable logic directly within Dataverse (running server-side) without having to write C# code or deploying plugins.
Functions can have parameters: parameters allow you to pass information between the function and the context that runs it, making it easier to design business logic that can be reused in varying situations. Input parameters are used to provide data to the function, and allow you to control how the function behaves by passing in different values you specify in the Power Fx formula. Output parameters allow you to retrieve the results of a function for further use in your program.

How to create a function

Open Power Apps Portal and select your environment
Open the solution where you want to build a function
Click on New --> Automation --> Function

Provide the following details:
- Display name : The human-readable name of the function. Can't be changed once created.
- Description : provide additional context about the function, such as purpose, behavior, and so on. Can't be changed once created.
- Input parameters(s) : add required input parameters. Input paramerts are optional.
To add a parameter click on + New input parameter
Following types are supported: Boolean, Datetime, Decimal, Float, Integer, String
- Output result(s) : add output results parameters. Output results are optional. To add an output result click on + New output result
- Table references : used to associate functions to specific tables. You can select up to five tables to read or write from in your function’s formula.
- Formula: custom function that can be used to perform actions or calculations, defined using the Power Fx expression language

Let's create a simple function to sum two numbers.
I define my function CustomSum with two inputs parameters x and y and one output parameter z.The Power Fx formula to sum the 2 numbers is : {z:x+y}

Another example: let's implement a function that creates a contact from two input parameters firstname and lastname (both with string data type)
This time we need to access a table to create a record, so I select 'Contacts' table in Table references
I also define an output result message to indicate that the contact was created successfully
In the Power Fx formula I use the function Collect() to create the record
```
Collect(contact,  
   { 
   firstname: firstname, 
   lastname: lastname 
   } 
   ); 
{ 
   message: "New contact " & firstname & "," & lastname & " created"
}
```
Click on Save to create the function
Various components are created and added to the solution:
- a Custom API
- a Function
- a FxExpression
- a custom API Request Parameter for each input parameter (2 in my example)
- a Custom API Response Property for each ouput result (1 in my example)

How to test a function

If you expect to find a button in the command bar when you select your function wihtin the solution, forget it. It is not possible to test a function inside a solution.
To test a function:

Come out of the solution
Click on More on the left pane and then click on Discover all
Click on Functions
Select your function and click on Test on the command bar

Another way is to click on the ellipsis (...) and select Test in the menu
Enter a value for each input parameter and click on Play
Result is displayed in the text area at the bottom.
In my example with function CustomSum I set x = 10 and y = 5 and we can see that value assigned to output result is 15
Result is : {"@odata.context":"https://orgxxxxx.crm.dynamics.com/api/data/v9.0/$metadata#Microsoft.Dynamics.CRM.cr0de_CustomSumResponse","z":15}

For the second function Create Contact I set firstname = 'John' and lastname = 'Doe'. You can see the result below:

How to delete a function

You must be careful if you want to delete a function. If you delete the function component in your solution only the function itself will be deleted, but related components (Custom API, FxExpression, custom API Request Parameters, Custom API Response Properties) will not be deleted. Therefore, you will end up with orphaned components.
To delete the function and all related components you must follow the same steps as for testing a function (see above): come out of the solution, click on More then Discover all and select Functions.
Then you can click on Delete on the command bar or click on the ellipsis (...) and select Delete.

Trace logs

You can access Dataverse functions trace logs in the same place as classic plugins.
Open Power Platform Environment Settings app and click on Plug-in Trace Log on the left pane.

You have access to execution information (duration, message block, exception, ...)

Invoke a function

We now know how to create and test a function, but it's time to use it.
As explained previously, functions are only triggered manually, so you need to call them explicitly.
You can invoke functions in Dataverse from:

a canvas app
a custom page in a model driven app
a Power Automate flow
from another function
in your code (Web API)

You can obtain a code snippet of your function that you will then use to call that function:

Open Power Apps Portal and select your environment
Click on More on the left pane and then click on Discover all
Click on Functions
Select you function and click on Copy code snippet on the command bar

Another way is to click on the ellipsis (...) and select Copy code snippet in the menu

Below the code snippet for my functions CustomSum and Create contact

Environment.cr0de_CustomSum({x:Value,y:Value})
Environment.cr0de_Createcontact({firstname:Value,lastname:Value})

Invoke a function from the Dataverse Web API

You can invoke a Dataverse function from the Web API with a POST request
Example with the function CustomSum:

POST [Organization URI]/api/data/v9.2/cr0de_CustomSum
OData-MaxVersion: 4.0
OData-Version: 4.0
Content-Type: application/json; charset=utf-8

{
   "x":4,
   "y":5
}

Here the result I get with the plugin WebAPI Launcher in XrmtoolBox:

Invoke a function from within another function

You can invoke a function from any other function.
To invoke a function within another function, use the syntax: Environment.MyFunction({inputParam1: value1, inputParam2: value2, ... inputParamN: valueN}).
Since the output is always a record, use the dot notation to access the output parameters.
For example, if the function MyFunction has two output parameters defined as out1 and out2, you can access them in either of these two ways:

Environment.ExistingFunction({inputParam1: value1, inputParam2: value2, ... inputParamN: valueN}).out1
Environment.ExistingFunction({inputParam1: value1, inputParam2: value2, ... inputParamN: valueN}).out2

To demonstrate this, I create a new function CustomSum2 to add 2 and 3. To perform this operation I use the first function CustomSum.
The new function CustomSum2 has no input parameter and one output result result (Integer type).
Power Fx formula of the new function:
{
result:Environment.cr0de_CustomSum({x:2,y:3}).z
}

Invoke a function from a Power Automate cloud flow

To use a function in a cloud flow:

Add a step to your flow
select Microsoft Dataverse connector
select Perform an unbound action action
In Action Name, select the function (cr0de_CustomSum in my example) and provide values for the input parameters (x = 6 and y = 3 in my example)
Add a compose action using the output of the unbound action as an input so that you can access the results of the function as needed

Below the result:

Limitations with functions

Functions have some limitations:

Max 5 tables per function
Only manual trigger, cannot be automated (that's the goal of low-code plugins)
Cannot call external API, limited to Dataverse
Still in preview : may have bugs. Not suitable for production
The following Power Fx function aren't currently supported with functions in Dataverse

Image

/sites/default/files/2026-01/dataver_functions2.png

Dataverse Managed Environments Deep Dive

julien.biedermann — Tue, 08 Oct 2024 12:45:19 +0000

Dataverse Managed Environments Deep Dive julien.biedermann Tue, 10/08/2024 - 14:45

Body

Dataverse Managed Environments Deep Dive:

What is Managed Environments ?

Managed environments is a set of features that allows administrators to manage Power Platform at scale with more control, less effort, and more visibility.

List of features available with Managed Environments for now (18/09/24) :

Limit sharing
Weekly usage insights
Data policies
Pipelines in Power Platform (preview)
Maker welcome content (preview)
Solution checker
IP Firewall
IP cookie binding
Customer Managed Key (CMK)
Lockbox
Extended backup
DLP for desktop flow
Export data to Azure Application Insights
Catalog in Power Platform
Default environment routing
Create an app description with Copilot
Virtual Network support for Power Platform

Requirements to enable Managed Environments

You may ask why to not activate this option on every environments ? What are the requirements and implications of enabling Managed Environments.

Everything is about licensing, when activating Managed Environments, every user that want to access the resources (Power Apps, Power Automate, Power Virtual Agents, and Power Pages website) in this environment must have a standalone licenses, Dynamics 365 Enterprise license or capacity add-ons.

Example of which licenses cannot run app in Managed Environments:

Microsoft/Office 365 licenses (Business, E1, E3, E5, F1, F3, …) that are coming with access to some limited Power Apps, Power Automate capabilities.

How to enable/disable Managed Environments ?

Permissions required

You must have the role of global admin, Power Platform service admin, or Dynamics 365 admin Microsoft Entra ID.
Any user with permission to see environment details can consult the Managed Environments property for an environment (from the list).

Users with the Delegated Admin role or the Environment Admin security role aren't allowed to change the Managed Environments property in an environment.

Enable Managed Environments in the admin center

Open the Power Platform admin center.

Enable Managed Environments using PowerShell

Below the script to enable Managed Environments (don't forget to replace <EnvironmentID>, it can be found here https://admin.powerplatform.microsoft.com) :

$GovernanceConfiguration = [pscustomobject] @{ 
    protectionLevel = "Standard" 
    settings = [pscustomobject]@{ 
        extendedSettings = @{} 
    }
}

Set-AdminPowerAppEnvironmentGovernanceConfiguration -EnvironmentName <EnvironmentID> -UpdatedGovernanceConfiguration $GovernanceConfiguration

Copy Managed Environment settings using PowerShell

These commands can be useful for deploying Managed Environments settings from one environment to another one. If the target environment wasn't a Managed Environment, copy settings will also enable it as a Managed Environment.

#Get settings from the source Managed Environment
$sourceEnvironment = Get-AdminPowerAppEnvironment -EnvironmentName <SourceEnvironmentId>

# Copy the settings from the source Managed Environment above to the target environment
Set-AdminPowerAppEnvironmentGovernanceConfiguration -EnvironmentName <TargetEnvironmentId> -UpdatedGovernanceConfiguration $sourceEnvironment.Internal.properties.governanceConfiguration

Disable Managed Environments using PowerShell

Managed Environments can be disabled by administrators using PowerShell. Before disabling Managed Environments, the administrator must ensure that none of the Managed Environments capabilities are in use.

Below the PowerShell script to disable Managed Environments :

$UpdatedGovernanceConfiguration = [pscustomobject]@{
    protectionLevel = "Basic"
}
Set-AdminPowerAppEnvironmentGovernanceConfiguration -EnvironmentName <EnvironmentID> -UpdatedGovernanceConfiguration $UpdatedGovernanceConfiguration

Quick overview of the available features

Limit sharing

Canvas app can be shared with users. With this feature, admins can limit how broadly users can share canvas apps. It is possible to restrict sharing with security groups and also set a limit on the number of individuals with whom the app can be shared.

Here is what the user will see when trying to share an app that is not matching the limit sharing rule:

Usage Insights

Keep updated on the status of your managed environments with Power Platform's weekly admin digest. Receive analytics detailing your top apps, most influential makers, and inactive resources that can be safely cleaned up, all conveniently delivered to your mailbox every week.

Here is the setting to enable Usage Insights (please note that also need to enable tenant-level analytics to get usage insights):

Who will receive the weekly digest ?

The weekly digest is sent to all users with the roles of Power Platform administrator and Dynamics 365 service administrator.

To include more recipients, choose "Add additional recipients for the weekly email digest", then opt for "Weekly digest" and input email addresses into the "Additional recipients" box.

What information is presented in the weekly digest ?

The first part of the weekly digest shows the number of apps used and active users in your managed environments in the past month.

The second part of the weekly digest shows lists apps and flows that haven't been launched in a while. The last launch column shows the last date of use for the app or flow. If an app or flow isn't being used, we recommend that you work with its owner to update or remove it.

The third part of the weekly digest shows the most popular apps and flows in your managed environments in the past month, indicated by the number of sessions and runs. When a user launches and interacts with an application, that's considered a session.

Data Policies

With this feature, admins can easily identify all the data policies that are applied to an environment.

When clicking on "See active data policies for this environment", the data policies page opens in a new tab. The view is filtered to display only the data policies that are applied to the managed environment. The environment filter is exclusively available for managed environments.

Pipelines in Power Platform

Pipelines in Power Platform aim to democratize application lifecycle management (ALM) for Power Platform and Dynamics 365 customers by bringing ALM automation and continuous integration and continuous delivery (CI/CD) capabilities into the service in a manner that's more approachable for all makers, admins, and developers. All target environments used in a pipeline must be enabled as Managed Environments.

Enable maker welcome content

Admins can provide customized welcome content to help their makers get started with Power Apps. When you add your own help content, it replaces the default Power Apps first-time help experience for makers.

Here is an example:

Solution checker enforcement

With solution checker enforcement feature, you can perform a rich static analysis check on your solutions against a set of best practice rules and identify problematic patterns.

Setting	Description
None	Turns off the automatic solution validations during solution import. There aren't any experience or behavioral changes to solution authoring, exports, or imports.
Warn	All custom solutions are automatically verified during solution import. When a solution with highly-critical issues is being imported, you are warned about the action but the import itself continues, and if everything else with the import is fine, the solution is imported into the environment. After a successful import, a message stating that the imported solution had validation issues is shown. Additionally, a summary email is sent with details of the solution validation.
Block	All custom solutions are automatically verified during solution import. When a solution has highly-critical issues, the import process is canceled, and a message stating that the imported solution had validation issues is shown. This happens before the actual import, so there aren't any changes to the environment due to the import failure. Additionally, a summary email is sent with details of the solution validation.

Who will receive the emails ?

When the validation mode is set to Warn or Block, a summary email is sent when a solution is imported or blocked. When the solution is imported into an environment, the summary email shows the count of issues by severity in the solution.

The email is sent to all users with the roles of Power Platform administrator and Dynamics 365 service administrator. It is also sent to recipients of the weekly digest emails.

By default, emails are sent for solutions containing medium or higher severities. When the checkbox "Send emails only when a solution is blocked [...]" is selected, emails won't be sent in warn mode. In block mode, emails aren't sent except for critical violations, which block solution import.

Rule exclusions

You have the option to opt out of enforcing certain solution checker rules. For instance, if fixing a specific rule requires considerable time and effort across the solution, but you still want other rules to be enforced, you can exclude that rule from enforcement. Utilize the "Excluded Rules" dropdown menu to choose which rules to exclude from enforcement. As a reminder, only critical severity rules block a solution from being imported.

IP firewall in Power Platform environments

The IP firewall helps to protect your organizational data by limiting user access to Microsoft Dataverse from only allowed IP locations. The IP firewall analyzes the IP address of each request in real time. For example, suppose the IP firewall is turned on in your production Dataverse environment, and allowed IP addresses are in the ranges associated with your office locations and not any external IP location like a coffee shop. If a user tries to access organizational resources from a coffee shop, Dataverse denies access in real time.

Safeguarding Dataverse sessions with IP cookie binding

Prevent session hijacking exploits in Dataverse with IP address-based cookie binding. Let's say that a malicious user copies a valid session cookie from an authorized computer that has cookie IP binding enabled. The user then tries to use the cookie on a different computer to gain unauthorized access to Dataverse. In real time, Dataverse compares the IP address of the cookie's origin against the IP address of the computer making the request. If the two are different, the attempt is blocked, and an error message is shown.

Manage your customer-managed encryption key

Customers have data privacy and compliance requirements to secure their data by encrypting their data at-rest. This secures the data from exposure in an event where a copy of the database is stolen. With data encryption at-rest, the stolen database data is protected from being restored to a different server without the encryption key.

All customer data stored in Power Platform is encrypted at-rest with strong Microsoft-managed encryption keys by default. Microsoft stores and manages the database encryption key for all your data so you don't have to. However, Power Platform provides this customer-managed encryption key (CMK) for your added data protection control where you can self-manage the database encryption key that is associated with your Microsoft Dataverse environment. This allows you to rotate or swap the encryption key on demand, and also allows you to prevent Microsoft's access to your customer data when you revoke the key access to our services at any time.

Securely access customer data using Customer Lockbox in Power Platform and Dynamics 365

Most operations, support, and troubleshooting performed by Microsoft personnel (including subprocessors) don't require access to customer data. With Power Platform Customer Lockbox, we provide an interface for the customers to review and approve (or reject) data access requests in the rare occasion when data access to customer data is needed. It's used in cases where a Microsoft engineer needs to access customer data, whether in response to a customer-initiated support ticket or a problem identified by Microsoft.

Customer Lockbox is available in public clouds and US Government Community Cloud (GCC), GCC High, and Department of Defense (DoD) regions.

Back up and restore environments

For environments that don't have Dynamics 365 applications, the default backup retention period is seven days. Admins who run production Managed Environments of this type can use PowerShell to change the retention period to 7, 14, 21, or 28 days.

A Managed Environment can be restored only to another Managed Environment. A non-Managed Environment can't be restored to a Managed Environment.

Is activating the Managed Environments a risky move?

Apart from the dependence on licenses, to me, the risk associated with activating the feature is minimal, here are the reasons:

This is transparent for the users if no feature are activated
This option is at the environment level (not at tenant level)
- This gives more flexibility and it allows to test the features in dev environment
Activation of a feature does not have retroactive effect
This option can be disabled at any time

On the other hand, admins need to be careful before activating a feature because it can have an impact on users. For example, activating "limit sharing" can block user in their job. It is important to test feature before activating them in production.

When to activate Managed Environments?

A feature requires to have Managed Environments activated
For large organizations with lots of environments, users, apps

Dataverse Managed Environments Deep Dive

Image

/sites/default/files/2024-09/article.png

Power Platform Dataflow Tutorial Deep Dive

Stephane Pelhatre — Mon, 17 Jun 2024 12:35:36 +0000

Power Platform Dataflow Tutorial Deep Dive Stephane Pelhatre Mon, 06/17/2024 - 14:35

Body

Power Platform Dataflow Tutorial Deep Dive

Introduction

Dataflows are a self-service, cloud-based, data preparation technology. Dataflows enable customers to ingest, transform, and load data into Dataverse environments, Power BI workspaces, or an organization's Azure Data Lake Storage account.
Dataflows are authored by using Power Query, a unified data connectivity and preparation experience already featured in many Microsoft products, including Excel and Power BI.
Customers can trigger dataflows to run either on demand or automatically on a schedule.

Dataflows are featured in multiple Microsoft products and don't require a dataflow-specific license to be created or run. They are available in Power Apps, Power BI, and Dynamics 365 Customer Insights.

The previous image shows an overall view of how a dataflow is defined.
A dataflow gets data from different data sources.
Then, based on the transformations configured with the Power Query editor, the dataflow transforms the data by using the dataflow engine.
Finally, data are loaded to the output destination, which can be a Power Platform environment, a Power BI workspace, or the organization's Azure Data Lake Storage account.

Dataflows are cloud-based. A dataflow is stored and runs in the cloud. However, if a data source is on-premises, an on-premises data gateway can be used to extract the data to the cloud.

Power Query is the data transformation engine used in dataflow. This engine supports many transformations. It also uses a graphical user interface called Power Query Editor.

In this article we will study the use of dataflow in the Power Platform through a tutorial.

Dataflow in practice

In this tutorial we will import a CSV file into a Dataverse custom table.

Create a dataflow

To create a dataflow just go to make.powerapps.com on your Power Platform environment and select 'Dataflows' in the left pane.
Then click on '+ New dataflow' on the top.

You will get the following screen:

I named my dataflow 'Import persons'.

If you want to load data to an Azure data lake for analytical purposes check 'Analytical entities only'.
In this tutorial I leave the checkbox unchecked as I want to load data into a Dataverse table.

Data sources

First step is to select a data source.
Around 50 data sources are available as you can see below.

Main types of source:

Files : Excel, Text/CSV, XML/JSON, ...
Databases : SQL Server, Oracle, MySQL, PostgreSQL, ...
Azure : Azure SQL Database, Synapse Analytics, Blobs, Data Lake Storage Gen2, ...
Online services : Sharepoint, Exchange, Google Analytics, ...

In this tutorial I will use a CSV file. You can directly drag&drop your file in the interface.

You get a preview of your file. Then click on 'Transform Data'.

Data filtering

You get the screen of Power Query Editor

At the top we have the formula bar (as in Excel or Power-fx). We will see in this article that we can display the current formula, the full script or hide this formula bar.
Below you can see your data.
And on the right side we have the 'Applied steps' pane with all steps/actions performed. It's a little empty because we've just started, but don't worry it will fill up:

We have several tabs:

Home : functionalities to filter data and some features of other tabs
Transform: data transformations
Add column: add a new column to apply a transformation
View : display settings

In this tutorial I first click on 'Use first column as headers' in the ribbon as the first line of my CSV file contains column names.

The tab 'Home' contains several interesting features: for instance you can filter rows.
To perform that action you first have to select a column and then click on the button 'Filter Rows'.
Another interesting feature is the possibility to remove duplicates.
As previously you first have to select a column and then click on the command 'Remove duplicates' in the menu 'Remove rows'.
In my example I apply this command on the column LastName : we can see in the screenshot below that we have a duplicate in this column (raley - lines 1 and 4)

And we obtain the expected result:

You can also remove blank rows or lines with errors.

Transformations

When you have filtered your data you can now apply some transformations.
Click on 'Transform' tab. You will get a ribbon dedicated to transformation features.

You can perform many data transformations. This is a non-exhaustive list of transformation features:

Transform any column:
- Replace values
- Change type
- Detect data type
- Mark column as key
- Rename column
- Pivot/Unpivot columns
- Fill up/down
- Move column
Transform text column
- Split (by delimiter, number of characters, lower/upper case and more)
- Format (lower/upper case capitalize words, trim, clean and more)
- Extract (length, first/last characters, range and more)
- Statistics (count/distinct values)

As a first example let's remove the characters 'xxx' in the column Firstname (in rickiexxx or xxxryan).
Select column Firstname and then select the command 'Replace values...' in the menu 'Replace values'
In my example I want to remove 'xxx' so I leave 'Replace with' empty.

And we obtain the expected result:

Note that at the top in the formula bar you can see the source code (Power Query M) of the last command :
Table.ReplaceValue(#"Removed duplicates", "xxx", "", Replacer.ReplaceText, {"Firstname"})

Now let's change data type of column Age. It is currently a text column and I will change it to a whole number column.
We can see that in line 3 the column Age contains 'abc' : let's say that it is an error as this column should contain only whole numbers.
So I first select column Age and then in the menu 'Data type' I select the item 'Whole number'.
This is the result:

We get an error in line 3. This makes sense as original data 'abc' is not a number.
To solve this problem I select the column Age and select the command 'Replace errors...' in the menu 'Replace values'.
In my example I set value to 99

And I get the expected result:

The menu 'Format' contains several interesting commands:

We have the classic commands lowercase, uppercase, trim.
But we also have the nice command 'Capitalize Each Word' (first letter of each word converted into an uppercase letter) and the command 'Clean' that removes all non-printable characters.

Now I apply the command 'Capitalize Each Word' on column FirstName and the command UPPERCASE on the column Lastname.
This is the result:

Add new column

Click on 'Add column' tab, you will get a ribbon dedicated to new columns.

With commands in tab 'Transform' you apply the transformation to the original column (in-place) as we have seen previously.
Commands in tab 'Add column' store the result of the transformation in a new column.
The menu 'Format' we used previously in tab 'Transform' is also in tab 'Add column'.
But if you use one the commands (for instance UPPERCASE) you will see that a new column is created.

With the command 'Custom column' you add a new column but you cannot select a built-in command : you have to write your code (formula) in Power Query M language.

As an example, let's create a column Fullname that concatenates columns Firstname and Lastname separated by a comma.
Click on the command 'Custom column' and set the parameters:

New column name : Fullname
Datatype : Text
Custom column formula: I use the Power Query M functionText.Combine() with the 2 columns Firstname and Lastname and comma as separator
You only have to type your function in the editor and click on fields in the section 'Available columns(s)' on the right to add the columns to the formula.

And we obtain the expected result:

Another interesting feature is Conditional column : with this feature you can create new columns whose values are based on one or more conditions applied to other columns.

Let's create a conditional column named 'Is too young' : the result will be set to TRUE is Age < 18 otherwise result will be FALSE.

You just have to click on the command 'Conditional column' and fill the data as below.

In my example I use a static value (18) but it is possible to specify another column as value.

And this is the result:

And now I change the data type of column 'Is too young'. I select the command 'Detect data type' in tab 'Transform': it automatically detects the best data type for the selected column.

As this column contains only strings 'TRUE' or 'FALSE' the best data type is logical true/false (boolean).
And as you can see below it worked : the icon in the header of the column has changed to indicates that the column is now a logical column.

'Applied steps' pane

And what about the 'Applied steps' pane on the right side?
It displays all the steps executed until now.

If you want to view the content of a specific step, simply click on the gear wheel on the right.
To remove a step click on the cross on the left.

If you right-click on a step you access a context menu : rename the step, insert a new step, move the step, ...

At the bottom of the pane you have a menu 'Step'. If you click on it you will have 3 choices: Off, Query script, Step script (default).
This defines what is displayed in the formula bar.

'Off' : hide the formula bar

'Step script' : display in the formula bar the formula (code M) of the selected step.

'Query script' : display in the formula bar the full script (all steps).

Next to the 'Step' button there is 'Diagram view' button. It displays in the formula bar the diagram of all steps.

If you click on the '+' in the diagram a context menu is displayed : you can filter data, add a step, etc...

The 'View' tab contains several display settings including those we have just seen (step script, query script, diagram view),

Importing data into Dataverse

When you have finished applying transformations to you data you can click on button 'Next' at the bottom of the screen and move to next step to import transformed data into a Dataverse table.

You can choose whether you want to load data into a new table or an existing one.
In my example I create a new table Person.
To do that simply name the table and choose which column is your unique primary column.
An automatic mapping is performed.

Then click on 'Publish'.
If the publish is successful you get the following screen:

Finally you can schedule your dataflow : click on the 3 dots '...' and select 'Edit Refresh settings'

You can run your dataflow manually or schedule it based on a specific frequency.

Note that you can get the following message if your refresh frequency exceeds the allowed limit of 48 refreshes per day.

And the result in the Power Platform:

Dataflow refresh

Each time you refresh a dataflow, it fetches records from the source and loads data into Dataverse.
If you run the dataflow more than once you can:

Create new records for each dataflow refresh, even if such records already exist in the destination table. In this case you will create duplicates.
Create new records if they don't already exist in the table, or update existing records if they already exist in the table. This behavior is called upsert.

Using an alternate key column indicates to the dataflow to upsert records into the destination table, while not selecting a key indicates to the dataflow to create new records in the destination table.

For instance if your data source has a column that is different for all rows (a guid or any unique identifier) you can use this column has an alternate key in your Dataverse table.

You can get details here: https://learn.microsoft.com/en-us/power-query/dataflows/get-best-of-standard-dataflows

Power Query M language

As mentioned previously Dataflow is based on Power Query and its related language.
The Power Query editor contains many built-in commands to perform basic operations and transformations.
But you will probably have to use the language to write your own transformations. It is what we call 'writing code M'.
The M stands for data Mash-up, as Power Query is all about connecting to various different data sources and “Mashing” them up.
The Power Query M formula language is optimized for building flexible data mashup queries. It's a functional, case sensitive language similar to F#.
Power Query Formula Language is used in a number of Microsoft products such as Power BI Desktop, Excel, and Analysis Services.

Details about Power Query M language are out of the scope of this article.
Specifications of the language can be found here:
https://download.microsoft.com/download/8/1/A/81A62C9B-04D5-4B6D-B162-D28E4D848552/Power%20Query%20M%20Formula%20Language%20Specification%20(July%202019).pdf

The specification describes the values, expressions, environments and variables, identifiers, and the evaluation model that form the Power Query M language’s basic concepts.

The official reference guide : https://learn.microsoft.com/en-gb/powerquery-m/power-query-m-function-reference

Many categories are available:

Accessing data functions
Binary functions
Combiner functions
Comparer functions
Date functions
DateTime functions
DateTimeZone functions
Duration functions
Error handling
Expression functions
Function values
List functions
Lines functions
Logical functions
Number functions
Record functions
Replacer functions
Splitter functions
Table functions
Text functions
Time functions
Type functions
Uri functions
Value functions

Some basics about the language:

A Power Query M formula language query is composed of formula expression steps that create a mashup query.
A formula expression can be evaluated (computed), yielding a value.
The let expression encapsulates a set of values to be computed, assigned names, and then used in a subsequent expression that follows the in statement.
For example, a let expression could contain a Source variable that equals the value of Text.Proper() and yields a text value in proper case.

let
    Source = Text.Proper("hello world")
in
    Source

In this tutorial we wrote a formula to concatenate first name and last name:

Text.Combine({[Firstname],[Lastname]}, " , ")

Note that function name (Combine) is prefixed by the category name (Text).
For example : Date.AddMonths(), Splitter.SplitTextByDelimiter()

Below the full script of this tutorial:

let
  Source = Csv.Document(Web.Contents("https://crm315857-my.sharepoint.com/personal/admin_crm315857_onmicrosoft_com/Documents/Apps/Microsoft Power Query/Uploaded Files/example1 8.csv"), [Delimiter = ";", Columns = 3, QuoteStyle = QuoteStyle.None]),
  #"Promoted headers" = Table.PromoteHeaders(Source, [PromoteAllScalars = true]),
  #"Removed duplicates" = Table.Distinct(#"Promoted headers", {"Lastname"}),
  #"Replaced value" = Table.ReplaceValue(#"Removed duplicates", "xxx", "", Replacer.ReplaceText, {"Firstname"}),
  #"Changed column type" = Table.TransformColumnTypes(#"Replaced value", {{"Age", Int64.Type}}),
  #"Replaced errors" = Table.ReplaceErrorValues(#"Changed column type", {{"Age", 99}}),
  #"Capitalized each word" = Table.TransformColumns(#"Replaced errors", {{"Firstname", each Text.Proper(_), type nullable text}}),
  #"Uppercased text" = Table.TransformColumns(#"Capitalized each word", {{"Lastname", each Text.Upper(_), type nullable text}}),
  #"Added custom" = Table.TransformColumnTypes(Table.AddColumn(#"Uppercased text", "Fullname", each Text.Combine({[Firstname], [Lastname]}, " , ")), {{"Fullname", type text}}),
  #"Inserted conditional column" = Table.AddColumn(#"Added custom", "Is too young", each if [Age] < 18 then true else false),
  #"Changed column type 1" = Table.TransformColumnTypes(#"Inserted conditional column", {{"Is too young", type logical}})
in
  #"Changed column type 1"

A major drawback of Power Query editor :
There is no intellisense/auto-completion when you type a formula (like in Microsoft Visual Studio or with Power-fx editor).
This technology is very useful when you do not know the exact name of a function.
And don't forget that code M language is case sensitive: so any case error in a function name and your code will not work.

Mass import

In order to evaluate the performance I have imported to Dataverse a CSV file with 100'000 rows.

Format of each row:

Id : incremental number (unique value in order to perform updates)
Firstname : string
Lastname: string
Age : integer

Transformations applied:

Firstname : Capitalize Each Word
Lastname : Uppercase
Add new column : Fullname = Firstname , Lastname

The Dataverse custom table has a column Id as primary column and alternate key to be able to perform updates.

I performed the import first in creation mode : import of transformed data into an empty Dataverse table.
Then I performed an import in update mode : I modified all data in the CSV file (firstname/lastname/age but not Id of course) and imported transformed data in the same Dataverse table.

Creation mode : the 100'000 transformed rows have been imported in 58 minutes.
Update mode : the 100'000 transformed rows have been imported in 52 minutes.

Licenses

To create dataflows in Power Apps a license is required (per-user or per-app).

If you want to create analytical dataflows that store data in your organization's Azure Data Lake Storage Gen2 account, you or your administrator need access to an Azure subscription and an Azure Data Lake Storage Gen2 account.

Limitations

Maximum of 48 runs per day for a dataflow
Only one owner is currently enabled. If another user wants to modify the dataflow you must change the owner
Mapping to polymorphic lookup fields is currently not supported.
Mapping to Status and Status Reason fields is currently not supported.
Mapping data into multi-line text that includes line break characters isn't supported and the line breaks get removed. Instead, you could use the line break tag <br> to load and preserve multi-line text
Mapping to Choice fields configured with the multiple select option enabled is only supported under certain conditions. The dataflow only loads data to Choice fields with the multiple select option enabled, and a comma-separated list of values (integers) of the labels are used.
For example, if the labels are "Choice1, Choice2, Choice3" with corresponding integer values of "1, 2, 3", then the column values should be "1,3" to select the first and last choices.

Power Platform Dataflow Tutorial Deep Dive

Image

/sites/default/files/2024-06/Designer.jpeg

Create a service principal with Power Platform CLI

Stephane Pelhatre — Thu, 28 Mar 2024 13:46:41 +0000

Create a service principal with Power Platform CLI Stephane Pelhatre Thu, 03/28/2024 - 14:46

Body

Create a service principal with Power Platform CLI

Introduction

To perform an integration with Dynamics 365 you typically need to set up a service principal in Azure.
To achieve this goal you must complete several steps:

Create an Azure App Registration
Create a secret for that App Registration
Set up API permissions for Dynamics 365
Create an Application User in the Power Platform Admin Center
Assign permissions to the Application User

A tutorial to perform those actions : https://dynamics-chronicles.com/article/step-step-connect-d365-clientsecret-use-apis

All these manual steps take time. But you can perform them with a Powershell command (pac admin create-service-principal).

Create your service principal

First you have to install Power Platform CLI on your machine.
Power Platform CLI is a command-line interface used to perform various operations in the Power Platform related to environment lifecycle, authentication, and work with Dataverse environments, solution packages, portals, code components.

You can download the MSI file here : https://aka.ms/PowerAppsCLI
Power Platform CLI reference guide : https://learn.microsoft.com/en-us/power-platform/developer/cli/reference/tool

After installing Power Platform CLI open a Powershell command prompt and type the command pac to check that the installation was successful.

Then type the following command to update to the latest version.

 pac install latest

Next step is to connect to your Dataverse environment with an authentication profile.
To get a list of all authentication profiles type the following command :

pac auth list

As you can see I have no authentication profile installed.
To create a profile type the following command:

pac auth create -env <env id>

<env Id> is the environment id of your organisation, which you will find in the Power Platform Admin Center.

You will be asked to provide your credentials. Below the result :

The last step is to use the command below :

pac admin create-service-principal  --environment <env id>

Now you can check the result in your Azure Portal.
As you can see below a new App Registration has been created.

A secret with one year validity has been created for the App Registration.

And correct permissions have also be added.

You can see your new application user in the Power Platform Admin Center.

The application user has the security role 'System administrator'.
It is the default security role when you use the command pac admin create-service-principal.
If you want to associate another security role you have to use the option --role.

pac admin create-service-principal  --environment <env id> --role <role>

Where <role> is the name or ID of security role to be applied to the application user.
Below the command to create a service principal with security role 'Sales Manager' assigned to the application user.

Create a service principal with Power Platform CLI

Power Docu : Easy to document Dataverse Solution

joao.neto — Thu, 14 Mar 2024 13:45:19 +0000

Power Docu : Easy to document Dataverse Solution joao.neto Thu, 03/14/2024 - 14:45

Body

Intro

Want to document a Power Apps Solution?

Power Docu provides a easy way of doing it by documenting Flows, Canvas Apps and other Power Apps solution components in the form of a Word Document or in a markdown format (GitHub or Azure Devops style) by using an self contained Windows Gui application.

All info over this link here: https://github.com/modery/PowerDocu

How it Works

Power Docu support the generation of documentation for Power Apps based on a local solution .zip or on a .msapp file.

The documentation contains information about :

Power Automate Flows
- General information
- Connectors
- Trigger
- Actions
- Flow diagram (simple and detailed)
Canvas Apps
- General information
- Global variables
- Data sources
- Resources
- Controls
- Screens overview
Solution components
- Dataverse Tables
  - Columns
  - Relationships

Security Roles

Solution Dependencies

By the way Model Driven-Apps aren't yet support in the current version 2.0 !

How to

Install Power Docu locally
Run Power Docu

Select the outputs

Select the Canvas App documentation level

Click "Next" and select a solution export file on a .zip or on a .msapp file format

Your Documentation is ready on the same folder as you solution file!

Final thoughts

Power Docu it's a very interesting App to easily generate standard Documentation for you Power Apps solution.

In my perspective just missing the Model-Driven Apps module that I would really use and just noticed that it's on the project Roadmap !

The code is open source so teams can fork and build their own generation model.

Image

/sites/default/files/2024-07/PowerDocu%20-%20Info%20Header.png

PowerApps Model Driven UI Testing with Playwright

zsoltzombik — Thu, 07 Dec 2023 15:16:37 +0000

PowerApps Model Driven UI Testing with Playwright zsoltzombik Thu, 12/07/2023 - 16:16

Body

PowerApps Model Driven UI Testing with Playwright

Introduction

In the ever-evolving landscape of software development, test automation has emerged as a pivotal trend, revolutionizing the way we build and deploy software. For businesses embracing Agile and DevOps methodologies, automated testing has become a cornerstone practice, enabling faster development and deployment cycles. In this article, we embark on a journey to explore the profound benefits of automated testing and why it holds such paramount importance in the context of software development, particularly within Dynamics 365 Model Driven Apps. We'll also touch upon the pivotal role of Playwright in automating UI testing within this environment. So, let’s discover the major benefits of automated testing and why automation in software testing matters:

Accelerated Development and Delivery: UI Test automation significantly reduces testing time, as automated tests can be executed rapidly and repeatedly. This results in shorter software development cycles, more frequent releases, quicker updates, and faster time-to-market delivery. The integration of automation, particularly with Playwright, expedites the testing process within Dynamics 365 Model Driven Apps, enhancing the development speed.
Enhanced Productivity: Automated tests operate without human intervention, enabling testing at any time, even during non-working hours. This autonomy minimizes the time software developers and quality assurance teams spend on testing, allowing them to focus on critical tasks. With automation, engineers can prioritize the creation of new features and improvements, ultimately boosting productivity.
Precision and Accuracy: Automated testing reduces the risk of human errors during the testing process. Unlike human testers who may make mistakes, automated tests execute precisely according to predefined criteria. This precision contributes to more reliable and error-free releases, minimizing the risk of failure.
Superior App Quality and Performance: Automated testing offers extensive test coverage, ensuring high-quality and high-performance applications. It allows for simultaneous testing of thousands of test cases across multiple platforms and devices, a feat difficult to achieve manually. With automation, complex and lengthy test cases can be created quickly, elevating the overall quality of applications.
Immediate Feedback: Automated testing provides instant feedback to developers, enabling quick response to failures. This immediate feedback accelerates the bug-fixing process and ensures a better user experience, leading to higher customer satisfaction. In contrast, manual testing can slow down the development and update process.
Enabling CI/CD and DevOps: Test automation is pivotal for implementing Continuous Integration (CI) and Continuous Delivery (CD) practices. In the CI/CD pipeline, every code commit needs to be tested swiftly and efficiently, a task perfectly suited for automation. Automation, including Playwright for UI testing, streamlines the transition to Continuous Testing and Delivery.

Incorporating test automation, especially within the context of Dynamics 365 Model Driven Apps, is not just a trend; it's a necessity. The benefits of automated testing continue to expand as tools and testing frameworks evolve. Beyond traditional automated testing, new areas like model-based testing, predictive analysis, robotics automation, and API test-case automation are emerging. To stay at the forefront of technological evolution, implementing test automation is imperative. It accelerates development, enhances efficiency, accuracy, and productivity, all while maintaining the highest standards of app quality and performance. Partnering automation with a robust testing solution and integrating it with your CI/CD tools ensures that you harness its full potential efficiently on real devices, propelling your software development to new heights without compromising on quality or performance.

Setting Up Your Environment for Playwright in Dynamics 365

Prerequisites for Playwright Setup

Before diving into using Playwright for UI testing, ensure you have the following prerequisites in place:

Native Installation

Playwright Test for Visual Studio Code: This is available on Visual Studio Marketplace. Make sure you have version 1.19 or newer to leverage the full capabilities of Playwright in Visual Studio Code.

Playwright NPM Package

Cross Platform Support: Playwright is designed for versatility, supporting Windows, Linux, and macOS. It can be used for testing both locally and on Continuous Integration (CI) platforms such as Azure DevOps, GitHub.
Browser Testing Flexibility: It offers extensive testing capabilities, including both headless and headed modes. For mobile testing, Playwright provides native mobile emulation for Google Chrome on Android and Mobile Safari, ensuring comprehensive coverage across devices.

Azure Subscription (Optional)

Enhanced Testing with Microsoft Azure: While not mandatory, an active Microsoft Azure subscription is recommended for a more robust testing framework. It becomes essential if you're planning to conduct automated tests within Azure or integrate load testing into your CI/CD pipelines. Utilizing Azure enhances your testing scope and efficiency, particularly for complex Dynamics 365 environments.

Having these prerequisites in place sets a solid foundation for effective and efficient use of Playwright in your Dynamics 365 UI testing projects.

Installation and Configuration

Before you start, you will need install the following:

NodeJS - https://bit.ly/getnodejs
VSCode - https://bit.ly/downloadvscode

When installing Node, select the LTS version and accept the defaults.

After installation, you should check you have Node installed correctly, at command line type:

npm

You should see the npm command help information displayed.

To check you had the VSCode installed correctly, at the command line type:

Code .

This should open VSCode at the code folder location you are currently in.

UI Test Project folder setup

Playwright UI Test project do not have a project file like C# (.csproj) so you can simply create a new folder with the name of your project. I will use UITest.

At the command line, type:

Mkdir UITest
Cd UITest

Install Playwright Test for Visual Studio Code

Open Visual Studio Code.

Select Extension, then search for Playwright Test for VSCode.

Then click on Install.

Open the command panel (Ctrl + Shift + P), and then enter the following command: Install Playwright.

On the next screen, select the browser(s) you want to run your tests in. You can change the setting later in the playwright.config file.

Finally you created your first Playwright test project.

Get a Test Environment

Next, you need a Dynamics 365 environment that you can run tests in. If you're finalizing an implementation project, you probably have a test environment already. If you don't, you can get a free 30-day trial (for this article, we provisioned a trial Dynamics 365 Customer Service Environment.

Setting up Test Environment

To optimize the test environment for automated testing, especially when using Playwright with a model driven app, follow these steps:

Disable Security Defaults

Adjust Security Defaults: For the purpose of automated testing it's necessary to turn off security defaults. This ensures that the automated tests can run without unnecessary interruptions interruptions or blocks, which are typically in place for security reasons. Please follow this link: https://learn.microsoft.com/en-us/entra/fundamentals/security-defaults

Create and Configure User Accounts

Access Microsoft 365 Admin Center: Utilize the Microsoft 365 admin center to set up the required user account(s) for testing.
Assign Security Roles: Properly assign the necessary security roles to these accounts to ensure they have the appropriate access levels for testing.

By carefully configuring the test environment as described, you create a more controlled and effective setting for conducting automated tests using Playwright in Dynamics 365.

First Playwright Test

Let's create our first test! Playwright provides convenient utilities for capturing your browser interactions and generating test scripts. To accomplish this, simply execute the Playwright Node command with the codegen argument. When you include the URL of your model-driven Power App as a parameter, it initiates a browser session that records the user's actions within the Playwright Inspector.

To inititate the recording a new test, type this command on Visual Studio Code Terminal window:

npx playwright codegen https://<you-crm-org>.crm4.dynamics.com/main.aspx?appid=<app guid>

Playwright open a new browser instance and launch Playwright Inspector:

Enter the credentials.

Then select Service -> Cases.

Click on New Case button.

Fill the form, then click on the Save button.

Finally, take a look at the Playwright inspector window, it generated the code of our test.

After the test script generated, we need to create a new test file under the tests folder such as and copy the code generated by Playwright Inspector.

Select the Test icon on Visual Studio Code.

Find the test we created previously.

Click in Debug Test button.

It kicks off by running tests in debug mode, and eventually, you'll spot the test results right in the terminal window.

Here's a small preview of the upcoming articles on Playwright.

The upcoming article, Writing Effective UI Tests with Playwright in Dynamics 365 will focus on mastering Playwright's testing capabilities, including automated browser testing and managing dynamic content. It will provide a step-by-step guide to developing test scripts specifically tailored for Dynamics 365 UI, complete with example scripts and scenarios, and conclude with strategies for debugging and troubleshooting these tests.
Third article Advanced Playwright Features for Dynamics 365 Testing will cover sophisticated techniques for working with multiple browsers and devices, including cross-browser and responsive testing. It will also delve into Playwright's advanced capabilities like network interception, mocking, and visual regression testing, along with their integration in CI/CD pipelines.
Fourth article titled Best Practices and Optimizing Test Performance focuses on creating maintainable test code with well-organized structure and reusable components. It will discuss strategies to enhance test performance, such as parallel testing and methods to reduce test flakiness, and will conclude with approaches for monitoring and reporting test results.

PowerApps Model Driven UI Testing with Playwright

Image

/sites/default/files/2023-11/1970%27s%20sci%20robot%20testing%20software%2C%20studio%20light%2C%20on%20an%20emerald%20colored%20background.jpg

Enhancing Dynamics 365 Client API Interaction with Xrm-Ex

Ahash — Mon, 30 Oct 2023 16:34:43 +0000

Enhancing Dynamics 365 Client API Interaction with Xrm-Ex Ahash Mon, 10/30/2023 - 17:34

Body

Enhancing Dynamics 365 Client API Interaction with Xrm-Ex

Stepping into software development for Dynamics 365, developers come across various tools and frameworks to make working with its Client API easier. Xrm-Ex stands out as a strong framework designed mainly for JavaScript, even though it has roots in TypeScript. The main goal of Xrm-Ex is to simplify how developers interact with the formContext and the Xrm Object. By doing this, it aims to reduce the amount of code developers have to write, making the codebase easier to manage and less likely to have errors.

Xrm-Ex provides a set of wrappers that work well with the Dynamics 365 Client API, making the developer experience smoother. With Xrm-Ex, developers have a toolkit that can help boost productivity, allowing more focus on creating great applications. This article will explore the Xrm-Ex framework, covering its installation, core features, how it can be used in real-world scenarios, and how developers can contribute to its community. All these aspects make Xrm-Ex a reliable choice for developers working with the Dynamics 365 Client API landscape.

Licensing

Xrm-Ex is licensed under the MIT License, which is a permissive open-source license. This means that it is free to use and you can also modify or redistribute it. The open-source nature of Xrm-Ex encourages collaboration and sharing in the developer community. The full license text is available in the project repository on GitHub.

Understanding Xrm-Ex

Xrm-Ex is a solid framework tailored for Dynamics 365 Client API. Although it's built with TypeScript principles, it's mainly made for JavaScript usage. The key goal of Xrm-Ex is to make working with the formContext and the Xrm Object simpler. By doing this, it aims to cut down the amount of code you need to write, ensuring your codebase remains easy to manage and less likely to have errors.

At its core, Xrm-Ex aims to streamline the interaction between developers and Dynamics 365. It does this by providing a clear structure and set of tools that help manage the different parts and events within Dynamics 365. This makes it easier to work with Dynamics 365's Client API, reducing the learning curve and making the development process more straightforward.

By using Xrm-Ex, developers can focus more on building out their applications' functionality rather than getting bogged down with managing complex interactions with Dynamics 365. This way, Xrm-Ex helps in maintaining a clean and efficient codebase, making the development process smoother and more enjoyable.

Installation and Getting Started

Installing Xrm-Ex is a straightforward process done via npm. You can find the package on npm here. To install, use the following command:

npm install xrm-ex

Documentation

For a comprehensive guide to using XrmEx, please check out the full documentation.

Video: Set up Project

Your browser does not support the video tag.

Video: Deployment

Your browser does not support the video tag.

After installing Xrm-Ex, the next step is to set up your project. The setup involves adding XrmEx.js from your node_modules to your Dynamics 365 form as a library. Here’s a basic template to help you get started with your JavaScript setup:

/// <reference path="node_modules/xrm-ex/src/XrmEx.d.ts" />

var YourNamespace = YourNamespace || {};

YourNamespace.Contact = YourNamespace.Contact || {};

//Only properties assigned to the Self object will be exposed to the global scope

(function (Self) {

    class Fields {

        Firstname = new XrmEx.Class.TextField("firstname");

        Customer = new XrmEx.Class.LookupField("parentcustomerid");

        DoNotEmail = new XrmEx.Class.BooleanField("donotemail");

        Birthday = new XrmEx.Class.DateField("birthdate");

        PreferredContactMethod = new XrmEx.Class.OptionsetField(

            "preferredcontactmethodcode",

            {

                Any: 1,

                Email: 2,

                Phone: 3,

                Fax: 4,

                Mail: 5,

            }

        );

    }

    class Tabs {

        General = new XrmEx.Class.Tab("tab1", {

            Section1: new XrmEx.Class.Section("section1"),

            Section2: new XrmEx.Class.Section("section2"),

        });

        Details = new XrmEx.Class.Tab("tab2", {

            Section1: new XrmEx.Class.Section("section1"),

            Section2: new XrmEx.Class.Section("section2"),

        });

    }

    class Grids {

        ContactSubgrid = new XrmEx.Class.GridControl("Test");

    }

    /**@type {Fields}*/ var fields;

    /**@type {Tabs}*/ var tabs;

    /**@type {Grids}*/ var grids;

    /**

     * @param {Xrm.FormContext | Xrm.Events.EventContext} executionContext 

     */

    Self.OnLoad = async function OnLoad(executionContext) {

        await Init(executionContext); //Ensures XrmEx is only accessed after the OnLoad Event

        try {

            fields.Firstname.Value = "Joe";

            fields.PreferredContactMethod.Value = fields.PreferredContactMethod.Option.Phone;

            fields.Firstname.setVisible(true).setDisabled(true).setRequired(false);

            await XrmEx.openAlertDialog("Success", "Xrm works.");

        } catch (error) {

            console.error(error);

            await XrmEx.openAlertDialog("Error", `Error in ${XrmEx.getFunctionName()}\n` + error.message);

        }

    };

    /**

     * @param {Xrm.FormContext | Xrm.Events.EventContext} executionContext 

     */

    async function Init(executionContext) {

        if (!XrmEx) {

            let errorMessage = "XrmEx is not loaded. Please make sure you have XrmEx.js loaded in your form.";

            console.error(errorMessage);

            await Xrm.Navigation.openAlertDialog({ title: "Error", text: errorMessage, });

            return;

        }

        XrmEx.Form.formContext = executionContext;

        fields = new Fields();

        tabs = new Tabs();

        grids = new Grids();

        parent.window.XrmEx = XrmEx;

    }

})(YourNamespace.Contact);

In the code above, you create a namespace for your code to live in and then wrap your code in a function to keep it organized and prevent global scope pollution.

To deploy, follow the instructions provided in the video: Xrm-Ex Deployment. This is a detailed guide on how to deploy your project.

Now, you'll want to add XrmEx.js from your node_modules to your Dynamics 365 form as a library. Then, execute the method YourNamespace.ContactFunctions.OnLoad in your form and pass the executionContext to that function

And that's it! You've now installed Xrm-Ex, set up your project, and deployed it to Dynamics 365. You're ready to start coding and enjoying a simplified interaction with the formContext and the Xrm Object.

Core Features

Xrm-Ex comes packed with features that make working with Dynamics 365 Client API a lot easier. Here are some of the core features:

Event Handling:
- Xrm-Ex makes it simple to manage events in Dynamics 365.
- Without Xrm-Ex: You would need to write more code to handle events.
- With Xrm-Ex: Event handling becomes straightforward, reducing your code.
Field Changes and Events:
- Tracking and managing field changes and events is easier with Xrm-Ex.
- Without Xrm-Ex: It could be time-consuming to track field changes and events.
- With Xrm-Ex: The process is streamlined, saving you time.
Form Types and Field Requirements:
- Xrm-Ex helps manage form types and field requirements without hassle.
- Without Xrm-Ex: Managing form types and field requirements can be complex.
- With Xrm-Ex: It becomes a simpler task, making your work quicker.
Data Retrieval and Setting:
- Retrieving and setting data in Dynamics 365 is simplified with Xrm-Ex.
- Without Xrm-Ex: These tasks might require more code and time.
- With Xrm-Ex: The process is quicker and requires less code.
Alert Dialogs:
- Managing alert dialogs in Dynamics 365 is straightforward with Xrm-Ex.
- Without Xrm-Ex: It could be challenging to handle alert dialogs.
- With Xrm-Ex: It’s a straightforward task, improving your user interaction.
Advanced Features:
- Lookup Filters: Easier management of lookup filters.
- Advanced Lookup Filter: Supports entire FetchXml including Link-Entity, making it special.
- Execute Bound Action: Simplified bound action execution.
- Retrieve EnvironmentVariableValue: Easier retrieval of environment variable values.

Each of these features aims to reduce the amount of code you need to write, making your interactions with Dynamics 365 Client API more straightforward and less error-prone. For a deeper dive into these features, check out the Xrm-Ex documentation. By providing a clear and simple way to handle common tasks and actions within Dynamics 365, Xrm-Ex helps to speed up the development process and reduce the likelihood of errors, making your project more efficient and reliable.

Real-world Usage

Xrm-Ex proves to be a handy tool in real-world scenarios where making interactions with Dynamics 365 Client API simpler is crucial. Here are a few examples:

Complex Projects:
- In projects with lots of moving parts, where many field changes and events need to be tracked, Xrm-Ex can cut down the code complexity and make things easier to manage.
Tight Deadlines:
- When working on tight deadlines, the ease of setting up and deploying projects with Xrm-Ex can be a big time-saver. It helps get the basics in place quickly so developers can focus on building the needed functionality.
Maintaining Clean Code:
- Xrm-Ex helps in keeping the codebase clean and well-organized. By reducing the amount of code needed for common tasks, it helps prevent bugs and makes the code easier to read and maintain.
Learning Curve:
- For developers new to Dynamics 365, Xrm-Ex can reduce the learning curve. Its straightforward features and easy setup can help newcomers get up to speed quicker.

These examples show how Xrm-Ex can be a practical choice in various real-world scenarios, making the development process smoother and helping to deliver projects on time and with fewer issues.

Community and Contribution

The Xrm-Ex community welcomes contributions from developers. You can find the project on GitHub here and check out the contribution guidelines to see how you can help improve Xrm-Ex:

Contribution Guidelines:
- There are clear guidelines provided for those who want to contribute. Following these guidelines helps ensure that contributions align well with the project’s goals.
Learning and Collaboration:
- Being a part of the Xrm-Ex community gives developers a chance to learn from others, share knowledge, and work together on improving the framework.
Feedback and Improvement:
- Developers can provide feedback on any issues they encounter or suggest improvements. This feedback is valuable for the continuous improvement of Xrm-Ex.
Shared Resources:
- Community members often share resources, like documentation or solutions to common problems, which can be a big help to others working with Xrm-Ex.
Community Support:
- Having a community to turn to for support or questions can be a great benefit, especially when facing challenging issues in a project.

Being a part of the Xrm-Ex community not only allows developers to contribute to a useful framework but also provides a supportive environment for learning and improving one’s skills in working with Dynamics 365. The collective effort and shared knowledge within the community contribute to making Xrm-Ex a reliable and continuously evolving tool for developers.

Conclusion

Xrm-Ex is a solid framework that helps tackle common challenges developers face when working with Dynamics 365 Client API. It's easy to install, has a lot of useful features, and comes with the backing of a supportive community. These elements make it a good choice for developers looking to make their Dynamics 365 projects easier to manage and less prone to errors.

By simplifying interactions with the formContext and the Xrm Object, Xrm-Ex helps reduce the amount of code needed, which in turn makes the codebase easier to handle. This ease of use, combined with the helpful features it offers, allows developers to focus more on building the functionality needed for their projects.

For anyone looking to boost their productivity and the quality of their Dynamics 365 applications, diving into Xrm-Ex and exploring what it has to offer is a step in the right direction. The benefits it provides in streamlining development processes are clear, making it a worthy addition to a developer's toolkit for Dynamics 365 projects.

Enhancing Dynamics 365 Client API Interaction with Xrm-Ex

Image

/sites/default/files/2023-10/2023-10-29%2017_43_25-%E2%97%8F%20demo.js%20-%20XrmExDemo%20-%20Visual%20Studio%20Code%20-%20Insiders.png