Marius Wodtke

Revisited: Managed Identities for Plugin Packages

Sun, 21 Jun 2026 00:00:00 +0000

We already had a first shot at Managed Identities for Plugins 2 years ago, but since then, the feature has left the preview stage and is now generally available. This also brought a new version of the subject identifier to be used for new managed identity records in Dynamics. And I already teased in the previous article that we will need a proper ALM to use this feature in a production environment. So today we kick off a gain with a “Getting Started” to then expand with automation for developers and CI/CD pipelines in the next articles.

There is also an official Microsoft documentation, but I will diverge from that a bit because I’m already thinking about my next steps with multiple developers and pipelines.

The Code

Because this is a new project, we want to use plugin packages of course!

pac plugin init -o ManagedIdentitySample

For the code I really only ran a sample that lets me debug this well, so the Plugin1.cs got some additions, the 3 highlighted lines are what is important for your own adventure. The rest of my code will make sure that the returned JWT will be persisted to logs and the description field of the Account I am triggering on to easily copy it out and for example analyze it further with a tool like jwt.ms.

protected override void ExecuteDataversePlugin(ILocalPluginContext localPluginContext)
{
    if (localPluginContext == null)
    {
        throw new ArgumentNullException(nameof(localPluginContext));
    }

    var context = localPluginContext.PluginExecutionContext;

    var managedIdentity = localPluginContext.ServiceProvider.Get<IManagedIdentityService>();

    localPluginContext.Trace($"Acquiring Token");

    var scope = new List<string> { "https://vault.azure.net/.default" };
    var token = managedIdentity.AcquireToken(scope);

#if DEBUG
    localPluginContext.Trace($"Token: {token}");
#endif

    var updateAccount = new Entity("account")
    {
        Id = context.PrimaryEntityId,
        ["description"] = token
    };
    localPluginContext.PluginUserService.Update(updateAccount);
}

We retrieve the IManagedIdentityService, then build a scope and then request a token for this scope. If everything is correct, AcquireToken will return a JWT, a JSON Web Token, that can be used for authentication/authorization. Of course this only works for services that accept this kind of auth, for example all Azure services. Azure Key Vault is chosen here on purpose because it can securely store other credentials like username and password for services that do not accept JWT. For these, the Managed Identity in combination with the Key Vault still provide a bootstrap for secure communication.

Generating the Certificate

For Managed Identity to work, our plugin package needs to be signed. And it’s not enough to use the Signing Key we are used to from Plugin Assemblies deployed to Dataverse, no the NuGet package needs to be signed after packaging. For that matter we will need a Certificate with a private key.

I’ve put a script below that will automate this mostly, please notice that you should

replace the variables at the top of the file with your own ones
choose a good CommonName as we will need this later for retrieval, it should be unique on everyones computer, so simply your companies name is not enough. But it should also be the same for everyone and the build server, so maybe something like the Assembly name which may already have your Company in there like a “Microsoft.CRM.Plugins.ERPSynchronization” might work well
receive a warning when the script tries to trust the generated certificate, this is optional, but if you don’t you will receive annoying warnings every time you save about the certificate not being trusted.
save the “App Registration Values” that are printed in the end, we will need it later.

Important: The official docs use the Extension ‘2.5.29.37={text}1.3.6.1.5.5.7.3.4’, which in my testing was never deemed valid for signing a package by the NuGet command line tool, instead ‘2.5.29.37={text}1.3.6.1.5.5.7.3.3’ (.3 in the end) is used as the valid extension for code signing.

If you are unsure about the environmentId, you can find it in PPAC on your environment. tenantId is found in the Session Details under the setting cog icon.

$email = 'MariusWodtke@MariusWodtkeMVP.onmicrosoft.com'
$commonName = 'MariusWodtkeMVP'
$tenantId = '738016bf-2f59-46ca-9660-357d1de3b865'
$environmentId = '7efcc31a-c410-e20e-9b95-dd448cedf653'

# Generate Cert
$params = @{
    Type = 'Custom'
    Subject = "E=$email,CN=$commonName"
    TextExtension = @(
        '2.5.29.37={text}1.3.6.1.5.5.7.3.3',
        "2.5.29.17={text}email=$email" )
    KeyAlgorithm = 'RSA'
    KeyLength = 2048
    SmimeCapabilities = $true
    CertStoreLocation = 'Cert:\CurrentUser\My'
}
$cert = New-SelfSignedCertificate @params
Write-Host "New Certificate generated"

# (Optional) Add to trusted certs to suppress warnings while signing
# This will open a dialog if you are sure you want to trust it
$store = New-Object System.Security.Cryptography.X509Certificates.X509Store("Root", "CurrentUser")
$store.Open("ReadWrite")
$store.Add($cert)
$store.Close()
Write-Host "Certificate installed to Trusted Root store"

# Extract hash of cert for the Subject we need for the Federated Credential
$cerFilePath = "$PSScriptRoot\$commonName.cer"
Export-Certificate -Cert $cert -FilePath $cerFilePath
Write-Host "Certificate exported to: $cerFilePath"

$certUtilOutput = CertUtil -hashfile $cerFilePath SHA256
$hash = ($certUtilOutput | Select-Object -Index 1).Trim()
Write-Host "`nSHA256 Hash: $hash"

# Encode the TenantId for the Subject we need for the Federated Credential
$tenantGuid = [System.Guid]::Parse($tenantId)
$tenantHex = $tenantGuid.ToByteArray()
$tenantBase64 = [System.Convert]::ToBase64String($tenantHex)
$encodedTenantId = $tenantBase64.Replace('+', '-').Replace('/', '_').TrimEnd('=')
Write-Host "`nEncoded Tenant ID: $encodedTenantId"

# Print out the final subject
$subject = "/eid1/c/pub/t/$encodedTenantId/a/qzXoWDkuqUa3l6zM5mM0Rw/n/plugin/e/$environmentId/h/$hash"
$issuer = "https://login.microsoftonline.com/$tenantId/v2.0"
Write-Host "`nApp Registration Values:"
Write-Host "`Issuer:"
Write-Host $issuer
Write-Host "`nSubject Value:"
Write-Host $subject
Write-Host "`nName:"
Write-Host $email

Here is a sample output

PS C:\Repos\Kunter-Bunt\...\ManagedIdentitySample> .\GenerateCert.ps1
New Certificate generated
Certificate installed to Trusted Root store


    Directory: C:\Repos\Kunter-Bunt\...\ManagedIdentitySample


Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
-a----         5/13/2026     20:54           1110 MariusWodtkeMVP.cer
Certificate exported to: C:\Repos\Kunter-Bunt\...\ManagedIdentitySample\MariusWodtkeMVP.cer

SHA256 Hash: b7d2145e1e8f76faa41561e47b70eb3bc7ca5b2f337ded7480c21a343c8ac6c3

Encoded Tenant ID: vxaAc1kvykaWYDV9HeO4ZQ

App Registration Values:
Issuer:
https://login.microsoftonline.com/738016bf-2f59-46ca-9660-357d1de3b865/v2.0

Subject Value:
/eid1/c/pub/t/vxaAc1kvykaWYDV9HeO4ZQ/a/qzXoWDkuqUa3l6zM5mM0Rw/n/plugin/e/7efcc31a-c410-e20e-9b95-dd448cedf653/h/b7d2145e1e8f76faa41561e47b70eb3bc7ca5b2f337ded7480c21a343c8ac6c3

Name:
MariusWodtke@MariusWodtkeMVP.onmicrosoft.com

Signing the Package

Now we start do deviate from the official documentation. They use an exported .pfx file with a password to sign their packages, but I want to automate signing as a post build step and don’t want to a password in the project file nor do I want to rely on unprotected .pfx files. Therefore we will search the Certificate by CN (CommonName) from the Certificate Store of Windows. Because it’s already loaded to the store, no password is required. And here you see the reason why I wanted to have a unique but common among developer and build machines name for CN as -CertificateSubjectName 'WhateverYourCNIs' will be hardcoded.

For now I will use the nuget sign command manually, but the plan is to deliver an automation in another article.

PS C:\Repos\Kunter-Bunt\...\ManagedIdentitySample\bin\Debug> 
>> nuget sign .\ManagedIdentitySample.1.0.0.nupkg -CertificateStoreLocation CurrentUser -CertificateStoreName My -CertificateSubjectName 'MariusWodtkeMVP'
WARNING: NU3002: The '-Timestamper' option was not provided. The signed package will not be timestamped. To learn more about this option, please visit https://docs.nuget.org/docs/reference/command-line-reference


Signing package(s) with certificate:
  Subject Name: E=MariusWodtke@MariusWodtkeMVP.onmicrosoft.com, CN=MariusWodtkeMVP
  SHA1 hash: 313D5BD2A5E36DB2B7211DC1B9D99C9836825636
  SHA256 hash: B7D2145E1E8F76FAA41561E47B70EB3BC7CA5B2F337DED7480C21A343C8AC6C3
  Issued by: E=MariusWodtke@MariusWodtkeMVP.onmicrosoft.com, CN=MariusWodtkeMVP
  Valid from: 5/13/2026 20:44:28 to 5/13/2027 21:04:28

Package(s) signed successfully.

Now we can register the package in Dataverse and for testing I also registered an asynchronous step on updating telephone1 of Account.

Creating the App Registration

Now we have a signed package in Dataverse and code inside that tries to authenticate with a Managed Identity, but what identity? We will create an AppRegistration here, no special setting.

Then we create a Federated Credential under Certificates & Secrets. Here you will need the issuer and subject that you saved after executing the script to generate the secret. Subject Value is the Value needed here.

For name I still have the certificates thumbprint in the screenshot, however, developer name (I used email in the script) is a better choice here. It’s easier to associate entries with people when needing to invalidate a leaving member or needing to update your certificate after it reached its validity date.

Creating the Managed Identity

And finally we need to tell Dynamics what App Registration matches our signed Plugin Package. Fortunately David Rivard wrote an XrmToolbox tool for this matter. Really simple, select your Assembly, Link to a New Identity and use the TenantId and ApplicationId (marked that one for you in the screenshot of the AppRegistration overview).

The Result

Now we have everything in place and the “If everything is correct” should be fulfilled now, so if I update my Accounts Main Phone, I can see the token in the Description field. Still, that is not a use case and you don’t want to hand out the tokens to anyone except the receiving application but it clearly shows the feature working.

Summary

Managed Identities provide the bootstrap for external authentication that we were waiting for a long time. These are the first steps towards Plugin Packages that will leverage this feature to enable communication without exposing credentials somewhere.

For this we generate a Certificate with the provided script. This Certificate is used for signing our Plugin Package before registering in Dataverse. Then we create an App Registration & Federated Credential with the values returned from the script. Finally, we associate the Assembly with the App Registration using a Managed Identity record in Dataverse. And now we can use the AcquireToken method of the IManagedIdentityService to obtain a JWT for a given service.

The solution presented here is functional, however, there are ALM parts still missing, check the series with upcoming articles on how to automate signing for development workflows and how a pipeline could work for deployment to get a production ready feature.

[Video] Server Logic with Custom APIs in Practice

Sun, 07 Jun 2026 00:00:00 +0000

This time we put Server Logic into practice to solve a practical problem: My custom Training Event entity offers both public and private events and allowing a Portal User to read all of them could leak information on the private events. Server Logic and Custom APIs will help us to retrieve the right amount of Training Events without assigning excessive privileges to our users.

Check it out here.

Having the right view on data

Sun, 24 May 2026 00:00:00 +0000

No, this is not going to be a political discussion about data interpretation, it’s about which view does what. You will certainly be familiar with the so called Public Views, these are the ones the Model Driven App displays when you select a table in the navigation, but what’s a Quick Find View and a Advanced Find View? Let’s find out!

Public View

This is the only view type that you can create for an existing table! You will not be able to choose a type when creating a new view, it will always be a Public View.

But that means, in contrast to the other view types, that you will have to choose a default view for a table. This view will be used when the table is selected in the navigation of an app (at least if the view is part of the app) and as well in customization when adding a subgrid to a form.

Two public views are created for you when create a table X, “Active Xs” and “Inactive Xs”. This may not make sense for your table, you can change, rename, add and remove public views at will, only the default view cannot be removed, which also ensures there is always at least one public view present.

No matter if you chose to add a new view or change an existing one, the editor offers options, to add/remove columns and change their width. You can also manipulate sorting and filters.

If you are changing filters, make sure to reflect that on the name, ending up with “Active Xs” that actually shows all Xs will confuse everyone!

And finally, don’t forget to Save and Publish.

Lookup View

Now we have customizing out of the way, we can focus on the special views. Since you can’t create new ones, you will edit the existing view if required.

This view used by default for Lookups. This can be changed on forms, but there are parts where you do not have such a selection! Examples will be the Lookup Objects dialog that is opened when associating records N:N or the Assign dialog where the default Lookup View is fixed.

The first two columns will be shown to the user in the dialog, by default, those are the primary field (usually Name) and Created On. In my experience Created On is rarely helpful for the user, but fortunately we can change that. You can also go beyond those two columns, they will not directly be shown but can be unfolded per record with the chevron icon, so make sure to put the two most distinguishing columns up first.
All columns shown can also be searched, but they are search with a “begins with”, which should also be considered. For example with alphanumeric key with a prefix, e.g “TST-4234”, here you won’t find the record by typing “4234”!

2 more notes regarding the column order: If say the third column is matched by a search it will move up to the spot of the second column, overwriting the set column sorting. This makes it more transparent to the user why this record is shown for their search.
And if the second column is empty, the third column will also move up. This also makes sense, but can be a bit confusing if the second column is empty for some records creating a mix of columns being shown in the results.

If you choose not to use the primary field (usually Name) as first column or at all, be aware that it will still be taken as the value shown in the Lookup after selecting a record.

Quick Find View

The quick find as such has actually vanished on my apps. This view was shown when you used the search bar on the top right of a view. Instead the Copilot search bar is available to “Ask about data in this table”.

But that does not make this view useless! While the columns configured on the left pane are not relevant anymore as the Copilot search will keep the columns of the selected view (so for example “Active Xs”), the Find By columns in the right pane are still important. This section is only found on the Quick Find View and determines what fields the user can search for. They are also relevant for the Dataverse Search, but that’s something for a separate article.

Now that we have configured the Owning Business Unit (my BU is called “mariuswodtke-mvp”), we can search for it. Even though the column is not present in the view! But sadly, this is not a “contains” search, but a “begins with”, making the second query not find the record although it would fit with a contains search.

For me right now, the “Advanced Filters” do not display the added filter, making me unable to produce a screenshot, but here is the filter from the downloaded FetchXml:

<filter type="or" isquickfindfields="1">
    <condition attribute="mwo_name" operator="like" value="mariuswodtke%" />
    <condition attribute="owningbusinessunitname" operator="like" value="mariuswodtke%" />
</filter>
<filter type="and">
    <condition attribute="statecode" operator="eq" value="0" />
</filter>

Associated View

This view is shown by default whenever you select a Relationship in the Related navigation of a form. The user can switch to other views in the app, but of course they would prefer you to configure meaningful columns for this view so that they may save the extra clicks. And think about the filter as well, the default one for active records is not always the right way to go.

Advanced Find View

Now this one is really obsolete by now, I wouldn’t worry about. Advanced Find is still a thing, you can use to for example explore tables that are in your app, but not in the navigation, but this will show the default Public View.

The Advanced Find View is still accessible with detours:

Summary

For every situation the right view. Public Views are the only ones creatable by you and are usually the ones you can select manually in several customization spaces like Form- and App-Designer. But sometimes those options are not given, then the other views become important.

The Lookup View is used by default for any lookups to the given table, in the Form Designer you can usually adapt this, but some dialogs and for example Business Process Flows do not have an option to change away from that view.

The Quick Find View has special options for Find by, these are used by the search bar and Dataverse search. Just keep in mind that these work with a “begins with” filter.

The Associated View is used for the Related navigation in a form, the user can switch here to other views, but that requires extra clicks every time they open the related subgrid.

The Advanced Find View became irrelevant with the move to the modern UI as it is only used in the classic advanced find accessible trough the Power Platform Environment Settings app.

[Video] Calling Unbound Custom APIs with Power Pages Server Logic

Sun, 10 May 2026 00:00:00 +0000

Microsoft has just made Server Logic generally available and it now includes a function to call unbound custom APIs.

With Flows and my solution https://github.com/Kunter-Bunt/PowerPagesActions this is our third option for custom APIs.

Check it out here.

Virtual Tables: Implementing custom RetrieveMultiple

Sun, 26 Apr 2026 00:00:00 +0000

A while back we took a look at virtual tables with the wizard for connecting to SQL Databases. Today we will again connect an SQL Database, but this time “on foot” with implementing the data layer on our own.

There is of course maintenance to be considered when implementing ourselves, but it also offers the possibility to do some custom transformations like if your source DB does not provide a guid column or you want to do some row level access (virtual tables are always organization owned).

For this matter, MS provides quite a good sample, however, for RetrieveMultiple they simply return everything without applying a single bit of filtering, sorting or selecting columns. This will be our focus for today, the article will mainly be code snippets of the different options from fetch.

SELECT

To help me with all of these functions, I’ve first created a dictionary for mapping between columns of the DB and Dataverse. If you want to be generic, need to manage many tables or expect frequent changes to the schema, this can be constructed from Metadata with the External Name. But I expect custom requirements here and have constructed a nice primary field from first and lastname that was not present in source.

private class FieldMapping
{
    public string ColumnName { get; set; }
    public Type ColumnType { get; set; }
    public bool IsComputed { get; set; } = false;
    public bool IsIdentity { get; set; } = false;
    public string ComputedColumnAlias { get; set; }
}

private static readonly Dictionary<string, FieldMapping> FieldMappings = new Dictionary<string, FieldMapping>
{
    { "mwo_personid", new FieldMapping { ColumnName = "Id", ColumnType = typeof(Guid), IsIdentity = true } },
    { "mwo_firstname", new FieldMapping { ColumnName = "Firstname", ColumnType = typeof(string) } },
    { "mwo_lastname", new FieldMapping { ColumnName = "Lastname", ColumnType = typeof(string) } },
    //...
    { "mwo_name", new FieldMapping { ColumnName = "(ISNULL(Firstname, '') + ' ' + ISNULL(Lastname, ''))", ColumnType = typeof(string), IsComputed = true, ComputedColumnAlias = "Name" } }
};

And now we simply iterate the columns in the given QueryExpression, map them from the given Dataverse column to the DB column and join them with a comma. The method is a little longer than this description as we need to consider all columns being retrieved, my computed column and the Dataverse behavior that the ID is returned even if it is not requested.

public static EntityCollection RetrieveMultiple(QueryExpression query)
{
    // ...
    string selectClause = BuildSelectClause();
    var sqlQuery = new StringBuilder("SELECT " + selectClause + " FROM dbo.Persons");
    // ...
}

private static string BuildSelectClause(ColumnSet columnSet)
{
    var selectColumns = new List<string>();
    var columnsToInclude = new List<string>();

    if (columnSet.AllColumns)
    {
        columnsToInclude.AddRange(FieldMappings.Keys);
    }
    else
    {
        columnsToInclude.AddRange(columnSet.Columns.ToArray());
    }

    foreach (var columnToInclude in columnsToInclude)
    {
        if (FieldMappings.TryGetValue(columnToInclude, out var mapping))
        {
            if (mapping.IsComputed)
            {
                selectColumns.Add(mapping.ColumnName + " AS " + mapping.ComputedColumnAlias);
            }
            else
            {
                selectColumns.Add(mapping.ColumnName);
            }
        }
    }

    if (!selectColumns.Contains("Id"))
    {
        selectColumns.Add("Id");
    }

    return string.Join(", ", selectColumns);
}

And finally, how do we get a QueryExpression as input for the function? Easy, we can just construct it with a RetrieveMultipleRequest. This works no matter if the InputParameters contain a QueryExpression in the first place or a FetchXml string.

var context = serviceProvider.Get<IPluginExecutionContext>();
var request = new RetrieveMultipleRequest { Parameters = context.InputParameters };
var query = (QueryExpression)request.Query;

WHERE

For mapping the WHERE, we need to consider that filters may contain filters. So BuildWhereClause may call itself recursively and needs to capture with brackets that nested filters may use different operators (&&, ||).

public static EntityCollection RetrieveMultiple(QueryExpression query)
{
    //...
    if (query.Criteria != null && (query.Criteria.Conditions.Count > 0 || query.Criteria.Filters.Count > 0))
    {
        sqlQuery.Append(" WHERE ");
        string whereClause = BuildWhereClause(query.Criteria, command);
        sqlQuery.Append(whereClause);
    }
    //...
}

private static string BuildWhereClause(FilterExpression filter, SqlCommand command)
{
    var clauses = new List<string>();

    foreach (var condition in filter.Conditions)
    {
        string clause = BuildConditionClause(condition, command);
        if (!string.IsNullOrEmpty(clause))
        {
            clauses.Add(clause);
        }
    }

    foreach (var childFilter in filter.Filters)
    {
        string childClause = BuildWhereClause(childFilter, command);
        if (!string.IsNullOrEmpty(childClause))
        {
            clauses.Add("(" + childClause + ")");
        }
    }

    if (clauses.Count == 0)
    {
        return string.Empty;
    }

    string logicalOperator = filter.FilterOperator == LogicalOperator.And ? " AND " : " OR ";
    return string.Join(logicalOperator, clauses);
}

For the next section I’ll happily admit that I’m also lazy and use GitHub Copilot for this stuff. Some notes: The params get a randomized postfix to ensure uniqueness should one column be filtered with multiple values, e.g. mwo_firstname eq “Marius” or mwo_firstname eq “Ambesh”. In operators have more than one value so we have to iterate them. And finally my switch is quite long but still missing some operators, for example the long list of Date operators, I suggest leveraging the AI again here to implement them as this is a typical time thief.

private static string BuildConditionClause(ConditionExpression condition, SqlCommand command)
{
    string columnName = GetColumnName(condition.AttributeName);
    string paramName = "@" + condition.AttributeName + "_" + Guid.NewGuid().ToString("N").Substring(0, 8);

    switch (condition.Operator)
    {
        case ConditionOperator.Equal:
            command.Parameters.AddWithValue(paramName, condition.Values[0] ?? DBNull.Value);
            return columnName + " = " + paramName;
        case ConditionOperator.NotEqual:
            command.Parameters.AddWithValue(paramName, condition.Values[0] ?? DBNull.Value);
            return columnName + " <> " + paramName;
        case ConditionOperator.Like:
            command.Parameters.AddWithValue(paramName, condition.Values[0] ?? DBNull.Value);
            return columnName + " LIKE " + paramName;
        case ConditionOperator.Null:
            return columnName + " IS NULL";
        case ConditionOperator.NotNull:
            return columnName + " IS NOT NULL";
        case ConditionOperator.GreaterThan:
            command.Parameters.AddWithValue(paramName, condition.Values[0] ?? DBNull.Value);
            return columnName + " > " + paramName;
        case ConditionOperator.GreaterEqual:
            command.Parameters.AddWithValue(paramName, condition.Values[0] ?? DBNull.Value);
            return columnName + " >= " + paramName;
        case ConditionOperator.LessThan:
            command.Parameters.AddWithValue(paramName, condition.Values[0] ?? DBNull.Value);
            return columnName + " < " + paramName;
        case ConditionOperator.LessEqual:
            command.Parameters.AddWithValue(paramName, condition.Values[0] ?? DBNull.Value);
            return columnName + " <= " + paramName;
        case ConditionOperator.In:
            if (condition.Values.Count == 0)
            {
                return "1 = 0";
            }
            var inParams = new List<string>();
            for (int i = 0; i < condition.Values.Count; i++)
            {
                string inParamName = paramName + "_" + i;
                command.Parameters.AddWithValue(inParamName, condition.Values[i] ?? DBNull.Value);
                inParams.Add(inParamName);
            }
            return columnName + " IN (" + string.Join(", ", inParams) + ")";
        case ConditionOperator.NotIn:
            if (condition.Values.Count == 0)
            {
                return "1 = 1";
            }
            var notInParams = new List<string>();
            for (int i = 0; i < condition.Values.Count; i++)
            {
                string notInParamName = paramName + "_" + i;
                command.Parameters.AddWithValue(notInParamName, condition.Values[i] ?? DBNull.Value);
                notInParams.Add(notInParamName);
            }
            return columnName + " NOT IN (" + string.Join(", ", notInParams) + ")";
        default:
            command.Parameters.AddWithValue(paramName, condition.Values[0] ?? DBNull.Value);
            return columnName + " = " + paramName;
    }
}

private static string GetColumnName(string attributeName)
{
    if (FieldMappings.TryGetValue(attributeName.ToLower(), out FieldMapping mapping))
    {
        return mapping.ColumnName;
    }
    return attributeName;
}

ORDER BY

Ordering is much simpler again, we can just concatenate the mapped column names with comma, the only thing to consider is wether the order is ascending or descending.

public static EntityCollection RetrieveMultiple(QueryExpression query)
{
    //...
    if (query.Orders != null && query.Orders.Count > 0)
    {
        sqlQuery.Append(" ORDER BY ");
        var orderClauses = new List<string>();
        foreach (var order in query.Orders)
        {
            string columnName = GetColumnName(order.AttributeName);
            string direction = order.OrderType == OrderType.Descending ? "DESC" : "ASC";
            orderClauses.Add(columnName + " " + direction);
        }
        sqlQuery.Append(string.Join(", ", orderClauses));
    }
    //...
}

TOP

For top or count as it is often called in Dataverse contexts, we have a small problem: It needs to be inserted after the SELECT and before the names of the columns. You may have a different opinion of where to put the code, the pragmatic approach here was to just use the Insert method to put it right behind the SELECT.

public static EntityCollection RetrieveMultiple(QueryExpression query)
{
    //...
    if (query.TopCount != null && query.TopCount > 0)
    {
        sqlQuery.Insert(6, " TOP " + query.TopCount);
    }
    //...
}

Reading the Output

And finally we need to read the output, again, we can use our initial dictionary to map the DB columns back to an entity.

public static EntityCollection RetrieveMultiple(QueryExpression query)
{
    var entityCollection = new EntityCollection();
    SqlConnection connection = GetConnection();
    using (SqlCommand command = connection.CreateCommand())
    {
        //...
        command.CommandText = sqlQuery.ToString();
        connection.Open();
        try
        {
            using (SqlDataReader reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    Entity entity = ReadEntityFromReader(reader, query.EntityName);
                    entityCollection.Entities.Add(entity);
                }
            }
        }
        finally
        {
            connection.Close();
        }
    }
    return entityCollection;
}

private static Entity ReadEntityFromReader(SqlDataReader reader, string entityName)
{
    var id = reader.GetGuid(reader.GetOrdinal("Id"));
    Entity entity = new Entity(entityName, id);

    foreach (var mapping in FieldMappings)
    {
        string columnName = mapping.Value.IsComputed ? mapping.Value.ComputedColumnAlias : mapping.Value.ColumnName;

        if (!reader.IsDBNull(reader.GetOrdinal(columnName)))
        {
            if (mapping.Value.ColumnType == typeof(Guid))
            {
                entity[mapping.Key] = reader.GetGuid(reader.GetOrdinal(columnName));
            }
            else if (mapping.Value.ColumnType == typeof(string))
            {
                var value = reader.GetString(reader.GetOrdinal(columnName));
                if (!string.IsNullOrEmpty(value))
                {
                    entity[mapping.Key] = value;
                }
            }
        }
    }

    return entity;
}

Summary

Hopefully this saves you some painful experimentation. It is also clear now why MS skipped this, as you will see in the full reference code below, implementing all of this already is more than 200 lines of code, which would have blown up their sample. And as discussed, we are still missing condition operators for Date attributes.

I am totally aware that your requirements for the Data Provider will be different and especially your DB might be different but if you feed this article into something like GitHub Copilot or Claude Code with some existing code for your DB, it certainly will do a decent job of translating the code shown here to your technology/table names/column names/…

Consolidated reference code:

using Microsoft.Xrm.Sdk;
using Microsoft.Xrm.Sdk.Query;
using System;
using System.Data.SqlClient;
using System.Text;
using System.Collections.Generic;

// ... Code as found in the MS sample, adapted to my table dbo.Persons

private static readonly Dictionary<string, FieldMapping> FieldMappings = new Dictionary<string, FieldMapping>
{
    { "mwo_personid", new FieldMapping { ColumnName = "Id", ColumnType = typeof(Guid), IsComputed = false, IsIdentity = true } },
    { "mwo_firstname", new FieldMapping { ColumnName = "Firstname", ColumnType = typeof(string), IsComputed = false } },
    { "mwo_lastname", new FieldMapping { ColumnName = "Lastname", ColumnType = typeof(string), IsComputed = false } },
    { "mwo_email", new FieldMapping { ColumnName = "Email", ColumnType = typeof(string), IsComputed = false } },
    { "mwo_phone", new FieldMapping { ColumnName = "Phone", ColumnType = typeof(string), IsComputed = false } },
    { "mwo_name", new FieldMapping { ColumnName = "(ISNULL(Firstname, '') + ' ' + ISNULL(Lastname, ''))", ColumnType = typeof(string), IsComputed = true, ComputedColumnAlias = "Name" } }
};

private class FieldMapping
{
    public string ColumnName { get; set; }
    public Type ColumnType { get; set; }
    public bool IsComputed { get; set; }
    public bool IsIdentity { get; set; }
    public string ComputedColumnAlias { get; set; }
}

public static EntityCollection RetrieveMultiple(QueryExpression query)
{
    var entityCollection = new EntityCollection();
    SqlConnection connection = GetConnection();
    using (SqlCommand command = connection.CreateCommand())
    {
        string selectClause = BuildSelectClause(query.ColumnSet);
        var sqlQuery = new StringBuilder("SELECT " + selectClause + " FROM dbo.Persons");

        if (query.Criteria != null && (query.Criteria.Conditions.Count > 0 || query.Criteria.Filters.Count > 0))
        {
            sqlQuery.Append(" WHERE ");
            string whereClause = BuildWhereClause(query.Criteria, command);
            sqlQuery.Append(whereClause);
        }

        if (query.Orders != null && query.Orders.Count > 0)
        {
            sqlQuery.Append(" ORDER BY ");
            var orderClauses = new List<string>();
            foreach (var order in query.Orders)
            {
                string columnName = GetColumnName(order.AttributeName);
                string direction = order.OrderType == OrderType.Descending ? "DESC" : "ASC";
                orderClauses.Add(columnName + " " + direction);
            }
            sqlQuery.Append(string.Join(", ", orderClauses));
        }

        if (query.TopCount != null && query.TopCount > 0)
        {
            sqlQuery.Insert(6, " TOP " + query.TopCount);
        }

        command.CommandText = sqlQuery.ToString();
        connection.Open();
        try
        {
            using (SqlDataReader reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    Entity entity = ReadEntityFromReader(reader, query.EntityName);
                    entityCollection.Entities.Add(entity);
                }
            }
        }
        finally
        {
            connection.Close();
        }
    }
    return entityCollection;
}

private static string BuildWhereClause(FilterExpression filter, SqlCommand command)
{
    var clauses = new List<string>();

    foreach (var condition in filter.Conditions)
    {
        string clause = BuildConditionClause(condition, command);
        if (!string.IsNullOrEmpty(clause))
        {
            clauses.Add(clause);
        }
    }

    foreach (var childFilter in filter.Filters)
    {
        string childClause = BuildWhereClause(childFilter, command);
        if (!string.IsNullOrEmpty(childClause))
        {
            clauses.Add("(" + childClause + ")");
        }
    }

    if (clauses.Count == 0)
    {
        return string.Empty;
    }

    string logicalOperator = filter.FilterOperator == LogicalOperator.And ? " AND " : " OR ";
    return string.Join(logicalOperator, clauses);
}

private static string BuildConditionClause(ConditionExpression condition, SqlCommand command)
{
    string columnName = GetColumnName(condition.AttributeName);
    string paramName = "@" + condition.AttributeName + "_" + Guid.NewGuid().ToString("N").Substring(0, 8);

    switch (condition.Operator)
    {
        case ConditionOperator.Equal:
            command.Parameters.AddWithValue(paramName, condition.Values[0] ?? DBNull.Value);
            return columnName + " = " + paramName;
        case ConditionOperator.NotEqual:
            command.Parameters.AddWithValue(paramName, condition.Values[0] ?? DBNull.Value);
            return columnName + " <> " + paramName;
        case ConditionOperator.Like:
            command.Parameters.AddWithValue(paramName, condition.Values[0] ?? DBNull.Value);
            return columnName + " LIKE " + paramName;
        case ConditionOperator.Null:
            return columnName + " IS NULL";
        case ConditionOperator.NotNull:
            return columnName + " IS NOT NULL";
        case ConditionOperator.GreaterThan:
            command.Parameters.AddWithValue(paramName, condition.Values[0] ?? DBNull.Value);
            return columnName + " > " + paramName;
        case ConditionOperator.GreaterEqual:
            command.Parameters.AddWithValue(paramName, condition.Values[0] ?? DBNull.Value);
            return columnName + " >= " + paramName;
        case ConditionOperator.LessThan:
            command.Parameters.AddWithValue(paramName, condition.Values[0] ?? DBNull.Value);
            return columnName + " < " + paramName;
        case ConditionOperator.LessEqual:
            command.Parameters.AddWithValue(paramName, condition.Values[0] ?? DBNull.Value);
            return columnName + " <= " + paramName;
        case ConditionOperator.In:
            if (condition.Values.Count == 0)
            {
                return "1 = 0";
            }
            var inParams = new List<string>();
            for (int i = 0; i < condition.Values.Count; i++)
            {
                string inParamName = paramName + "_" + i;
                command.Parameters.AddWithValue(inParamName, condition.Values[i] ?? DBNull.Value);
                inParams.Add(inParamName);
            }
            return columnName + " IN (" + string.Join(", ", inParams) + ")";
        case ConditionOperator.NotIn:
            if (condition.Values.Count == 0)
            {
                return "1 = 1";
            }
            var notInParams = new List<string>();
            for (int i = 0; i < condition.Values.Count; i++)
            {
                string notInParamName = paramName + "_" + i;
                command.Parameters.AddWithValue(notInParamName, condition.Values[i] ?? DBNull.Value);
                notInParams.Add(notInParamName);
            }
            return columnName + " NOT IN (" + string.Join(", ", notInParams) + ")";
        default:
            command.Parameters.AddWithValue(paramName, condition.Values[0] ?? DBNull.Value);
            return columnName + " = " + paramName;
    }
}

private static Entity ReadEntityFromReader(SqlDataReader reader, string entityName)
{
    var id = reader.GetGuid(reader.GetOrdinal("Id"));
    Entity entity = new Entity(entityName, id);

    foreach (var mapping in FieldMappings)
    {
        string columnName = mapping.Value.IsComputed ? mapping.Value.ComputedColumnAlias : mapping.Value.ColumnName;

        if (!reader.IsDBNull(reader.GetOrdinal(columnName)))
        {
            if (mapping.Value.ColumnType == typeof(Guid))
            {
                entity[mapping.Key] = reader.GetGuid(reader.GetOrdinal(columnName));
            }
            else if (mapping.Value.ColumnType == typeof(string))
            {
                var value = reader.GetString(reader.GetOrdinal(columnName));
                if (!string.IsNullOrEmpty(value))
                {
                    entity[mapping.Key] = value;
                }
            }
        }
    }

    return entity;
}

private static string BuildSelectClause(ColumnSet columnSet)
{
    var selectColumns = new List<string>();
    var columnsToInclude = new List<string>();

    if (columnSet.AllColumns)
    {
        columnsToInclude.AddRange(FieldMappings.Keys);
    }
    else
    {
        columnsToInclude.AddRange(columnSet.Columns.ToArray());
    }

    foreach (var columnToInclude in columnsToInclude)
    {
        if (FieldMappings.TryGetValue(columnToInclude, out var mapping))
        {
            if (mapping.IsComputed)
            {
                selectColumns.Add(mapping.ColumnName + " AS " + mapping.ComputedColumnAlias);
            }
            else
            {
                selectColumns.Add(mapping.ColumnName);
            }
        }
    }

    if (!selectColumns.Contains("Id"))
    {
        selectColumns.Add("Id");
    }

    return string.Join(", ", selectColumns);
}

private static string GetColumnName(string attributeName)
{
    if (FieldMappings.TryGetValue(attributeName.ToLower(), out FieldMapping mapping))
    {
        return mapping.ColumnName;
    }
    return attributeName;
}

Copilot for Sales: Working with forms

Sun, 12 Apr 2026 00:00:00 +0000

In the Copilot for Sales series we already covered the settings and OOTB experience for the Email sidepane. But we did not cover yet how changing the form settings will affect the user experience. In this article we will enable the Lead table for Outlook and play around with the different switches to determine the effects.

Enabling the table

When we select the Add a new record type button, the Lead will be found because it does have a relationshipt to Account, Contact or Opportuntity - in fact to all of them. This is what we get presented when selecting the relationships which will be relevant for the displayed cards in the sidepane.

The next step is actually in make.powerapps.com where I create a new view for the Lead with all the fields I want to have on the form. I’ve named this one “Outlook” to associate it accordingly but this is preference. Note that this view will also be shown in your Dynamics Model Driven App if you chose to display all views, as soon as you start using Copilot for Sales I think it’s time to think about what views you want in your app and select accordingly. In terms of fields you want to divert from other views, on Lead views usually show the combined “Name” field which is not editable, so it won’t be in Outlook either… And I applied no filter and instead show the status reason field, allowing users to find also qualified or disqualified leads.

Don’t forget to hit Publish now!

If you enabled both create options, the user has to go trough an extra step before they arrive at the form, you might want to enable only one method.

Require field

In this case it makes sense to require the firstname and emailaddress as well, since we can assume that the user can extract this from the current email. Remember that you cannot turn of required fields that are already required by Dynamics/your customization, but we can require additional ones.

This works as expected. There is apparently no smart prefilling of the Email Address. A few more observations here:

A nice touch that I didn’t notice before: The empty Parent Account for lead field is hidden in the card, which makes it more readable if you happen to have many optional fields.
If I edit the lead again and remove the First Name, we can see it still being required on the edit form.

Disable editing for fields

I already moaned about the status reason field which I want for the Key Fields but editing can lead to problems. Let’s disable it!

That’s a great success!

Disable editing at all

Also pretty straight forward. If you disable editing, the edit button vanishes from the Lead card. However, important note: Although you cannot edit the required fields anymore after you disable editing, they still apply, so First Name and Email are still required on the creation now. This is probably an oversight/bug, but you can work around it by temporarily enabling editing to manipulate those required fields and then disable it again.

Disable creation

We have kind of seen this one already, since it is OOTB disabled for Account and Opportunity; and for Contact, creating in Dynamics is disabled, giving us a simple create button instead of a dropdown. So one more thing to test: What happens if we only allow creation in Dynamics?

And thats a really nice outcome! The button now is essentially a link to the Dynamics with the parameters &forceUCI=1&pagetype=entityrecord&etn=lead. If you have problems with the Outlook forms, like my concerns with the Status Reason field (which we solved differently here!), you can still supply the users with a quick link in Outlook so they don’t have to navigate through the MDA, this might be a good time saver for them.

Key Fields

Until now I have searched this lead multiple times, but since I haven’t configured any Key Fields (there is a maximum of 2) only the primary field Name was shown. I have selected Status Reason and Topic here and then first tested with the Lead we’ve previously used. Since I then noticed both fields are in the same row I changed the values to rather long ones to see what happens. The learning is simple: put the shorter field first, otherwise the user may only see the first one. Also notice that I don’t have an option to unfold, but there is a tooltip if the record is hovered.

Summary

To add a new table to the forms in Copilot for Sales, the table needs to have a relationship to Account, Contact or Opportunity. If this relationship is indirect, you first need to add the intermediary table (you may disable create/edit on this one). You determine what fields are on the form with the selected view, where the filters matter for the search and the fields matter for the form.

Fields will be required on both create/edit forms. If editing is disabled for a field, it will vanish from the create form. This may be interesting if you don’t want to allow a field to be set but still want to display it in the search. This can be achieved with the Key Fields, but using a field as a Key Fields also means it needs to be present on the form.

Finally you want to decide wether creation and editing is allowed with those very simple forms available in Outlook. If you have reasons to disable creation in Outlook, you can still display a quick link to jump to the Dynamics creation form with all it’s Business Rules, JS, PCFs, … But you should decide between the methods as leaving both enabled requires an extra click from the user.

[Video] Calling Bound Custom APIs with Power Pages Server Logic

Sun, 29 Mar 2026 00:00:00 +0000

Microsoft has a new preview feature called Server Logic and it already includes a function to call bound custom APIs.

With Flows and my solution https://github.com/Kunter-Bunt/PowerPagesActions this is our third option for custom APIs.

Check it out here.

Copilot for Sales: Email sidepane actions

Sun, 15 Mar 2026 00:00:00 +0000

In the first article of this series we’ve deployed the “Sales” app to our Outlook users and explored the settings a bit. However, to understand the settings for the features better we certainly should understand what the app looks like to our users because that allows us to understand the consequences of our administrative actions.

Opening the app

Once the app was deployed, it should be visible to the users after a few minutes; or up to 48 hours per the documentation, but usually they set absurdly high numbers here to avoid support cases that resolve themselves an hour later.

Then, the app is accessible in both toolbars of the email itself and the general one at the top. You may also use the apps button to find it. The apps button in the left toolbar also offers the Sales app, however, this button does not open the sidebar with actions for the email but the fullscreen app that offers learning paths and the environment switcher.

Saving the email

For this one simply click the save button and select a regarding object. This can be the contact, but with the search box I can also find an opportunity that I’ve created for this matter.

After saving is done new sections will open with more insights, as this is the first email for this opportunity there is not much to be gained here at the moment.

Creating a new Contact

With the plus in the top right corner the user can also create records. By the OOTB form settings, this is currently only enabled for Contacts. If you remember back to the initial article about the settings you will recognize the required fields here. Also notice that all fields are editable in this view. The email field will not be editable when later editing the record, however the forms don’t make this well visible, a lock symbol or gray background is not present!

Searching an existing Record

Records with configured forms can also be searched, viewed and edited. This will direct you to a screen that looks really similar to the create form above, but some fields may not be editable depending on your settings.

Connected Records

The connected records at the bottom behave a little different! They will also show the cards and in the three dots you will find the edit, that will behave the same, but for Opportunity we get an additional AI summary that looks a lot like the ones inside Dynamics. And for the Contact we get up to 10 other emails in our mailbox (they don’t need to be saved to Dynamics) plus a notes field that is apparently not saved to Dynamics and there lends itself to private notes. For everything else you might want to include the description field to the form.

AI Insights

Sorry, but this one needs a revisit once I have my Teams back up… Reassuring that these are enabled in the Access Settings and saving 5 more emails to the Opportunity yields no summary in these.

For the email below it would have been nice to be informed about the the 5 licenses running out end of november, that is mentioned in the initial email because this specific email has a totally different focus.
But at least we can see one change here: The summary got the fact that this email is linked to an opportunity now and gives me a quick glance about it.

Summary

Without any additional configuration the Copilot for Sales app allows the user to save emails to Dynamics and connect them to other objects like Opportunities, those connections can later be changed. If creation is configured even new records can be created, OOTB this is the case for Contacts. If emails included attachments those will also be saved, this is controllable by the user.
A lot of these behaviors like available tables and fields are changeable by administrators in the settings and we will explore these changes further in this series.

Although not all AI features worked for me in this exploration, Copilot for Sales summarizes emails helping the seller to quicker understand longer email chains.

[VIDEO] Microsoft Power Pages Client APIs (preview)

Sun, 01 Mar 2026 00:00:00 +0000

Microsoft published its own idea of a client API for Power Pages, let’s take a look!

Microsoft documentation: https://learn.microsoft.com/en-us/power-pages/configure/client-api

Repository Link: https://github.com/Kunter-Bunt/PowerPagesClientAPI

Check it out here.

Copilot for Sales: Admin Settings

Sun, 15 Feb 2026 00:00:00 +0000

I’m not a big fan of AI for everything, but that’s a story of it’s own. Even the earliest versions of GPT already did a great job summarizing texts and thus having such a feature in Outlook to get the hang of long conversations that you didn’t follow until someone posted a question to you is a great thing.

MS thought so too and thus we now have the Copilot for Sales now. The obviously diverted all development efforts from the established App for Outlook and has the disadvantage that depending on your existing licensing it will cost extra.
But of course there is also additional value that might outweigh the cost quickly and especially if it is included in your existing licenses, why shouldn’t we prefer this over the App for Outlook?

To skill myself up in this new way of offering Dynamics connectivity to Sellers in Outlook I will explore this tool in this series and as always I will document my experience in here, hoping that you may find some information that the official docs were missing.

The first pitfall

And here goes the first one: The docs say simply go to M365 admin center -> Settings -> Integrated apps -> Get apps. Now search for “Sales” and chose get it now. And this is correct! However, the big screenshot right below still has the search term “copilot for sales” and a matching “Copilot for Sales” card shown… Yeah, they’ve renamed it to Sales, so search for “Sales”! Here is also a direct link to the App.

Sadly, I did not screenshot the installation wizard, but the only setting I could make was for which users it is available to. This is also available in the app details afterwards should you want to change it. Note here that for larger organizations you would choose to restrict the app to a group to only deploy it to users with the respective license.

Also note the Teams integrated app needs extra deployment from the Teams admin center

Accessing the Admin Settings

Let’s first check the app is available, this may take a couple minutes; or up to 48 hours per the documentation, but usually they set absurdly high numbers here to avoid support cases that resolve themselves an hour later.

As we can see OOTB the button appears in an email, it connected me to an environment automatically on first open (likely my last used environment on this user) and offers to work with Contacts or saving the Email to Dynamics. So far so similar to the App for Outlook, but “Key sales info” provides a summary of the email as the copilot part. In this sample not really helpful, by the time I’ve read the summary I’ve also read the Email, plus, I need to double check because “ai-generated content may be incorrect”, but of course we all know those emails/email-chains that are much worse and the summary is a blessing.

Most importantly for regular users, the full-screen app contains an environment switcher should the automatic association be incorrect and the user dismissed the initial info box. If you have the System Administrator Role in the environment you will also see the settings tab.

From here on out this article will be a collection of commented screenshots. I hope this helps you as much as it helps when I have to respond to client requests without having an environment and licensed Outlook at hand.

Tenant Settings

Environment Settings

Features

Summary

Once you find the app, deployment is straight forward. Think about whom you want to give access and if all of these users should receive all AI features. You can limit access to many features with fine granularity in the Settings of the Copilot for Sales app. And by the way, I will keep calling it Copilot for Sales instead of “Sales”, because I think this is confusing in a global context. It might be fine within the Outlook AppSource, but in the Power Platform space or even googling stuff it’s way to generic.

This series will continue. For once we will take a general look at the users side of things, but we’ve also opened up room to investigate settings like required fields on create forms, Teams capabilities, daily digest, default views for contacts, enabling forms for custom tables, classifications, AI summary synchronization and the lead research agent. See you soon!

Teams Integration: Enable custom tables

Sun, 15 Feb 2026 00:00:00 +0000

In previous articles we already covered the basic and enhanced teams collaboration experience. For this article I assume that you have followed at least the setup for the basic collaboration, as otherwise you won’t have a Teams integration to work from!
However, enabling this feature only enables the experience on a set of OOTB and Microsoft first party tables. At the time of writing the documentation lists 35 tables.

However, the docs also refers to an msdyn_SetTeamsDocumentStatus action that we may use to enable other tables, including custom tables, for Teams.

Using Postman

It is unfortunate here that MS does not provide a UI to manipulate the status of this integration for individual tables. As the provided action is called with a body and the POST method, we cannot use a simple browser to call it (at least not without some extensions or Console JS).

Spoiler: In the next section I will introduce you to an XrmToolbox tool that makes it effortless, but here I also want to introduce you to the way you can do such things with Postman if you come across a similar functionality that no one has written a tool for yet.

Fortunately, I don’t have to start a full tutorial for setting up Postman for talking to Dynamics here, fellow MVP Sanjaya (Softchief) has already covered this well!
From here we simply want to append the the name of the unbound action msdyn_SetTeamsDocumentStatus and push the documented body, e.g. the following one to activate Teams Collaboration on the entity with the logical name mwo_test.

{
    "Enable": true,
    "LogicalEntityNames": "[\"mwo_test\"]"
}

Check Sanjayas tutorial linked above to see how webapiurl is constructed, it is the base url of your environments OData API (e.g. https://XXX.crmY.dynamics.com/api/data/v9.2/). Also notice that the double quotes inside the value of LogicalEntityNames need to be escaped in order to ensure this parameter forms a valid list of strings.

An one last note here: For me this action always returns a success as long as the table exists, no matter if the table is valid for activating teams. A prime example where this is never going to work is the activityparty which is completely uncustomizable. You can check if the operation was successful in the entity metadata with the attribute IsMSTeamsIntegrationEnabled.

Using the Teams Integration Enabler

As promised, here comes an easy tool to achieve this. As this is also my first tool for the XrmToolbox, bare with me, Tanguy already had to, because I didn’t have the workflows down yet…

As we have a graphical tool, we’ll have a graphical tutorial here as well.

Please note that the table metadata is sometimes slower than we are clicking refresh tables. Should your table still be reported “red”, try the Load Tables button two or three more times, likely it will turn “green” soon ;)

Should you receive an error like this, you probably have not followed the steps in “Enabling Teams” of the Basic Collaboration article. More specifically, a solution msdynce_OfficeProductivity is required which seems to be bundled with the Dynamics standard apps of Customer Service and Customer Experience (Sales & Marketing). On a Dev-Environment, which does not have Dynamics apps by design, this error can be triggered reliably.

Result & Summary

No matter if you chose to do this with the XrmToolbox tool or Postman, the final result should look something like this. The enabled table now has the Collaborate button, which will open the dialog to connect the record with a teams channel. From here of course the experience will change depending on wether you did configure the basic or enhanced teams collaboration experience.

At the time of writing I am not aware of limitations for the custom tables, you can activate the integration for any table that allows customizations, also for OOTB and other first party or ISV tables. You can also deactivate the integration on the 35 preenabled tables if you for example would wish to only activate collaboration on opportunities but not on accounts.

The enabled status is stored in the table property IsMSTeamsIntegrationEnabled. This status will also be transferred with a solution, should you have selected the option to Include Table Metadata at the table in question.

You can find the tool as well as links to the source here.

[VIDEO] Xrm.Navigation in Power Pages

Sun, 01 Feb 2026 00:00:00 +0000

To achieve Power Pages code that is portable from your Model Driven App forms to Power Pages it would be nice to have the MDA Client API available in Power Pages. But sadly it is not there yet, but we will try to make it happen!

In this video we will explore Xrm.Navigation with openWebResource and openUrl as well as diving a bit into how bootstrap may help us with the openConfirmDialog method.

Repository Link: https://github.com/Kunter-Bunt/PowerPagesClientAPI

Check it out here.

Save an Email as EML with Powerautomate

Sun, 18 Jan 2026 00:00:00 +0000

Let me use this article to give you a head start if you ever come across a similar requirement, this one was formulated as “Whenever an Email is related to an Opportunity, store it in our document management solution”. I will adapt this here a bit since I don’t see a good reason to communicate with a DMS in this article since yours will probably be different; instead we will store the result into a file column of the email.

This might seem to have the benefit of allowing an easy download via clicking the file in the form, however, there is a Download button in the ribbon already, which can achieve this OOTB. This button uses an unbound action _Downloademailasattachment, one of those actions where I was unable to find documentation, rendering this option probably unsupported for our custom backend use case.

The EML format

The well supported options for the Outlook client are .msg and .eml formats, for this article we are using EML. To get sample file simply use Save as (New Outlook)/Download (Web) on a single email.

These samples usually contain A LOT OF headers, so we will take the final result of this article as it is much simpler to understand

Subject: Fw: Test
From: mariuswodtke@mariuswodtkemvp.onmicrosoft.com
To: mariuswodtke@mariuswodtkemvp.onmicrosoft.com;
Content-Type: multipart/mixed; boundary="mwo_MainBoundary"

--mwo_MainBoundary
Content-Type: multipart/related; boundary="mwo_SecondaryBoundary"

--mwo_SecondaryBoundary
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: 8bit

<html><head>
... html ...
</head><body dir="ltr">
... html ...
<img size="82516" height="237" width="421" id="x_image_0" data-outlook-trace="F:2|T:2" src="cid:f64c0b69-6aaf-4691-87dc-69b19df912cd" style="width:421px; height:237px; max-width:1249px" data-attachment-id="1d7ea49e-1b90-4529-9f70-19cd3899c5d4" >
... html ...
</body></html>

--mwo_SecondaryBoundary
Content-Type: image/jpeg; name="Logo.jpg"
Content-Description: Logo.jpg
Content-Disposition: inline; filename="Logo.jpg"; size="82277"
Content-ID: <f64c0b69-6aaf-4691-87dc-69b19df912cd>
Content-Transfer-Encoding: base64

/9j/4AAQSkZJRgABAQEAYABgAAD/ ... a lot more base64 stuff
--mwo_SecondaryBoundary--

--mwo_MainBoundary
Content-Type: application/pdf; name="MVP-Award-Certificate-25.pdf"
Content-Description: MVP-Award-Certificate-25.pdf
Content-Disposition: attachment; filename="MVP-Award-Certificate-25.pdf"; size="580208"
Content-Transfer-Encoding: base64

JVBERi0xLjcKJanNxNIKMiAwIG9 ... a lot more base64 stuff
--mwo_MainBoundary--

Main observations:

We have headers with {key}: {value} notation
Content-Type specifies a boundary, this is usually a randomized string, I’ve used a descriptive one here, prefixed with my publisher prefix to avoid collision (mwo_MainBoundary). This is used as --mwo_MainBoundary and --mwo_MainBoundary-- to start and end the “body”
Inside this body another boundary is defined (mwo_SecondaryBoundary) which is used to split the html from the inline attachments (--mwo_SecondaryBoundary). “Real” attachments are split by the --mwo_MainBoundary.
Inline images are using an src attribute which is matched to the a header Content-ID in other parts of the multipart content. This header encloses the id in <> (Content-ID: <f64c0b69-6aaf-4691-87dc-69b19df912cd>)

Note here, that I certainly don’t have all the information for headers in the sample, you might also be interested in Date: Fri, 26 Dec 2025 03:19:03 +0000. Just download an email that has the information you desire to find the header you are looking for!

The Flow

I think here pictures say more than words, the main elements are a variable EML Content which is filled slowly with content. The attachments of the email are listed and then iterated, images are added as inline attachments, everything else is added as normal attachment. Finally, the closing boundaries are added and the EML Content is stored as a file. Some more notes:

Inline attachments should be added first, because of the boundaries. This is why we are leveraging the 2 helper variables. If you want to append directly to the EML Content, use 2 queries with “mimetype starts with image/” and “mimetype does not start with image/” and iterate each of them instead of using the condition.
When creating test cases, be aware that dynamics will not generate an inline attachment for images, instead it will push it as base64 directly into the image tag. To test the secondary boundary, generate an email with something like the outlook client and synchronize it into Dynamics.

The Result

And here you see that Outlook is indeed able to visualize this email. Since I did not include the Date header, we don’t see it in the rendered result, showing the flexibility of the EML format.

My version of this flow has a total of 9 actions, so I conclude that exporting Dynamics Email to EML files for automated processing is doable with reasonable effort.
Please keep in mind that this is not needed for user interaction use cases. The frontend of Outlook as well as Dynamics already offer a Download option for usage in not automated scenarios. However, the flow shown may help you to transfer emails in an automated fashion.

Power Platform Advent Calendar: Fully Automated AI Approvals in Power Platform | Streamline Business Processes with AI

Tue, 23 Dec 2025 00:00:00 +0000

Are you ready to unleash the power of Power Platform? Join us for a festive and fun video series that will show you how to create amazing apps, govern your tenant, introduce AI in Power Platform and learn something about Power Pages. Each day, you will get a new tip from our experts that will help you learn something new, solve a problem, or improve your skills. Whether you are a beginner or a pro, you will find something useful and interesting in this advent calendar. Don’t miss this opportunity to power up your productivity and creativity with Power Platform!

Check it out here.

Power Platform Advent Calendar: Power CAT Business Approval Kit Tutorial | Complete Setup & Workflow Guide

Sun, 21 Dec 2025 00:00:00 +0000

Check it out here.

Power Platform Advent Calendar: Streamline Approvals in Dataverse with Power Automate | Step-by-Step Tutorial

Fri, 19 Dec 2025 00:00:00 +0000

Check it out here.

[VIDEO] Power Platform Learners: Fix Unresolved Recipients in Dynamics 365 with Power Automate | Step-by-Step Guide

Sun, 30 Nov 2025 00:00:00 +0000

The concept of the Power Collab group is easy: Everyone shares and everyone learns! With people from different parts of the Power Platform, we can all learn something new for aspects we may not be using every day. Join us in this recording and learn as well!

Check it out here.

[VIDEO] formcontext.ui in Power Pages

Sun, 23 Nov 2025 00:00:00 +0000

In this video we will explore formcontext.ui with getFormType and setFormNotification.

Repository Link: https://github.com/Kunter-Bunt/PowerPagesClientAPI

Check it out here.

[VIDEO] Power Platform Learners: Power Automate Debugging Made Easy – Upcoming Feature and Current Workaround

Wed, 12 Nov 2025 00:00:00 +0000

Check it out here.

Patterns: Creating an Import View

Sun, 09 Nov 2025 00:00:00 +0000

An Import View? Why would I need that? Yes, of course it is not per say necessary, but as you will learn here it is very helpful for steering the user!

This pattern is helpful when users are somewhat regularly are importing data into a table. For the screenshots I took the Account, but if you think this is unrealistic because you have a tight master data concept for accounts, think about this instead: “When my sales people come back from a trade show, they will import their new leads via Excel, because they won’t find the time to record them to the system immediately.”

The situation

In theory this is pretty easy, select a view of the table with the appropriate fields. If there are fields missing, add them to the view and optionally save as a personal view if you need this regularly. Now use “Export to Excel (static worksheet)” to get a good template to enter your data. Remove all existing data to have a clean field to enter data and prevent any unwanted changes to the existing data.

Enter your data, save and use “Import from Excel”. Because our headers were generated by “Export to Excel”, the data map will already be very good, maybe some lookup matching will need refinement.

The data is now importing and then you will notice a BIG problem: You have just overwritten your existing records. That’s because the Excel contained 3 hidden columns on the left (notice in the screenshots above that the columns start with D) and one of the is the Guid column, which will beat any other key in matching.

If you are finding this article because you already made this mistake, there are possibilities. Of course you can roll back to a backup, but this will reset all other tables as well. You can also restore a backup to a new environment, then use “Export to Excel” there and import it to your regular environment. However, the imported Excel needs to loose the hidden columns for Modified On and Row Checksum, otherwise Dynamics will complain that this data won’t match the data in the environment. If it needs to be more selective, you can also export another Excel from the target environment and match up the rows, e.g. via the Guid.

To not run into this problem, we either need to keep all existing records in the Excel and only append to the end OR we also delete the content in the hidden columns. You may keep an empty Excel as a template in an accessible location like a SharePoint library, however, the reality says these are forgotten…

And believe it or not, I have seen this mistake happen from people that are totally capable of handling Dynamics, Administrators, Power Users, Consultants. Every human being is prone to this error, because the Excel looks okay since the columns are hidden. And they are hidden for good reason as well because tampering with these columns can lead to serious problems with the import, including fully duplicating all data contained. And I just suggested you to tamper with these columns to fix our problem, both before it occurs as well as fixing it afterwards…

The solution

Obviously, we need something better! And that’s where our Import View comes in. First of all, we can easily fix the need to add columns to have all necessary fields in the view, just talk to your users and gather a list! It does not matter here if there are to many columns here for being displayed well in a Model Drive App, it’s only important that the exported Excel is usable.
But more importantly, we can fix our big problem by simply ensuring that the View is always empty!

By pushing impossible conditions to the filters, we make sure that the view is empty and therefore the Excel is empty and can be safely filled with data by the users. Compared to a pre-exported template, this is easily accessible from Dynamics itself and also adding needed columns “correctly” is very easy for the user. Correctly here meaning that it will be recognized automatically by the data maps, especially important for non-text fields, like Optionsets.

Now you only need to ensure the view is shown in your app and we are ready to tell our users about the 4 easy steps of select the Import View, “Export to Excel”, add data, “Import from Excel”.

Summary

Prevent a data disaster by supplying your user with an Import view! This is a view that contains all necessary columns that users will need to do a successful import and contains conflicting filters in such a way that it will always be empty. This ensures that users won’t accidentally overwrite existing data by missing the fact that there are 3 hidden columns in any exported Excel from Dynamics. This pattern only applies to tables where “Import from Excel” is used on a regular basis.

[VIDEO] Power Platform Learners: How to use File Manager PCF control in Power Pages?

Fri, 07 Nov 2025 00:00:00 +0000

The File Manager PCF for Power Pages is a tool to allow users to easily upload one or more files. In contrast to the OOTB control, this will upload the data to an Azure Storage, rather than burdening your Dataverse storage. Want to learn more?

Check it out here.

[VIDEO] Power Platform Learners: Dataverse Functions Preview – The Future of Low-Code Logic | Live Demo and Explanation

Tue, 04 Nov 2025 00:00:00 +0000

Check it out here.

[VIDEO] formcontext.data in Power Pages

Sun, 26 Oct 2025 00:00:00 +0000

In this video we will explore formcontext.data with getIsDirty, refresh and save.

Repository Link: https://github.com/Kunter-Bunt/PowerPagesClientAPI

Check it out here.

[VIDEO] Power Platform Learners: No Secrets, No Stress: Use Managed Identity in Dynamics 365 Plugins | Full Tutorial

Fri, 24 Oct 2025 00:00:00 +0000

Check it out here.

[VIDEO] Power Platform Learners: How to use FetchXml with Liquid in Power Pages?

Sun, 19 Oct 2025 00:00:00 +0000

Did you know you could directly query Dataverse from Liquid? This enables you to display data in a unique ways the OOTB methods wouldn’t allow. Want to learn more?

Check it out here.

Timeline Custom Connectors 4: Configuration

Sun, 12 Oct 2025 00:00:00 +0000

Timeline Custom Connectors allow you to display any form of data in the Dynamics/Model Drive Apps timeline. This generally available feature is however hard to implement and lacks official documentation, apart from the single, transpiled(!) sample with incomplete interfaces, there is almost nothing to support you. This is where this blog tries to improve the situation, also check out the rest of the series for inspiration!
BTW, if anyone from MS is reading this and is bothered by the tone: Give us some proper docs and ping me, I will happily refine these articles and commend you for fixing the situation!

In this sample we will explore the option of passing an additional configuration to our custom connector. This configuration is specified in a separate WebResource which contains a JSON. This is immediately helpful if you want to use a timeline component differently at different forms/tables because you can reference different files, e.g. ContactConfiguration.js and AccountConfiguration.js.
Should you want to change values between environments to for example change a URL needed for retrieving data, this is less ideal. You can still make it work by leveraging the layering system by stacking another (un)managed layer over the original configuration file. But I would suggest using the Environment Variables for this and either hardcode their schema name or reference their names via the configuration file.

The repository

In general this series consists of programming samples since I expect you to have very specific requirements that can not be solved with standard methods. If they can be bent to fit something like a subgrid, do it! And depending on the pickiness of your stakeholders regarding styling, it might even be worth implementing a PCF instead because you have more control over the content. However, there are certainly situations where the UX of the timeline is preferred.

You can find the full samples in the TimelineCustomConnector repository. It has a branch for each sample, for this article, navigate to Configuration. As you will find in the repository, the samples are built with TypeScript and are then transpiled to JavaScript as I would consider using this feature a “real high-code development”. It is not done with few lines of code and the ability to debug transpiled MS code should be in your box of tools, this is nothing you can achieve with a bit of vibe-coding like you can sometimes with smaller form script use cases. As GitHub Copilot evolves quickly I feel I must add this: As soon as it is able to attach to the browser console, debug the problems and redeploy autonomously I might change my opinion regarding the last sentence.

The configuration

For the sample I introduced a new interface called IConfiguration.

export interface IConfiguration extends JSON {
    footerField: string;
    bodyField: string;
    headerField: string;
    sortField: string;
    entityName: string;
    selectFields: string;
    filterField: string;
    idField: string;
}

This interface defines all the properties I expect to be present. I’ve used all string here but you may use other simple as well as complex types, so you could also define something like myField: ISubConfiguration that is another Interface with more properties inside.

Crucially, this interface extends JSON, this allows an easy conversion in MyRecordSource.ts where the input to the init method must be JSON to comply with the interface (at least in TypeScript).

export class MyRecordSource implements IRecordSource {
    private context?: IControlData<IRecordSourceParams>;
    private config!: IConfiguration;
    private records!: IRecordData[];
    private data!: Data;

    constructor() {
    }

    async init(context: IControlData<IRecordSourceParams>, config?: JSON): Promise<void> {
        this.context = context;
        this.config = config as IConfiguration ?? {};
        this.data = new Data(context, this.config);
    };

    // ...

Be careful! This feature is not very fault tolerant, putting an invalid JSON into your configuration file will break the whole component, you will simply not hit any breakpoint from the init method forward and will not receive any feedback in the console or similar either. If you can hit a breakpoint in the first line of init without a configuration and can’t hit it with a configuration, be sure to check the contents with a JSON validator as the OOTB timeline will run JSON.parse for you before passing the configuration.

Oh and another thing you might stumble into: While you specify the code file (Resource path) for the timeline custom connector starting with the publisher prefix, the configuration file (Configuration path) needs a /WebResources/ because unlike the code file, this is not automatically prepended and you will find a 404 call for the configuration in the Network tab of your Developer tools otherwise. So configuration should look a little something like this:

TBH I think this might be a bug, but fixing it would be a breaking change, so keep an eye out to the Network tab of the Developer tools to validate the behavior.

Using configuration

Once you have the configuration file was loaded successfully and you were able to verify the JSON arriving correctly at your breakpoint in init, we can start using it. Fortunately we have control from here, so no weird things should happen from now on. You should only be aware that although I can specify properties to be mandatory, I can’t enforce this on the configuration file as it is independent, so we can run into null ref exceptions should the configuration not fully specify all properties.

{
    "footerField": "createdon",
    "bodyField": "lastname",
    "headerField": "firstname",
    "sortField": "createdon",
    "entityName": "contact",
    "selectFields": "contactid,createdon,firstname,lastname",
    "filterField": "_parentcustomerid_value",
    "idField": "contactid"
}

This is a sample configuration rendering the contacts of an account, remember you can take a look at the full code in the branch Configuration. The configuration is passed to the Data class in the init method and is there used build the Dataverse query.

export class Data {
    private context: IControlData<IRecordSourceParams>;
    private config: IConfiguration;

    constructor(context: IControlData<IRecordSourceParams>, config: IConfiguration) {
        this.context = context;
        this.config = config;
    }

    // ...

    private async getData(): Promise<any[]> {
        let id = this.context.page.entityId;
        let filter = `$filter=${this.config.filterField} eq ${id}`
        let select = `$select=${this.config.selectFields}`;
        let contacts = await this.context.webAPI.retrieveMultipleRecords(this.config.entityName, `?${filter}&${select}`);
        return contacts.entities;
    }

    // ...

And of course we can now use the configuration everywhere we might need it, for example when “rendering” the timeline record in getRecordUX:

    createBody(recordId: string, data: any) {
        return this.context?.factory.createElement(
            "Label",
            { key: `${this.getRecordSourceInfo().name}_${recordId}_body` },
            `Body: ${data[this.config.bodyField]}`
        ) ?? [];
    }

And in this case I again have to emphasize that this is a coding sample, the code presented here is very unsafe considering the person crafting the configuration has to match all those separate fields together, ensuring that the bodyField is also found in the selectFields and that the selectFields are actually present in the table specified in entityName. A production ready component would need much more error handling!

But we have a result!

Task problems

I also tried this with the Task table, the configuration looks like this:

{
    "footerField": "prioritycode@OData.Community.Display.V1.FormattedValue",
    "bodyField": "description",
    "headerField": "subject",
    "sortField": "createdon",
    "entityName": "task",
    "selectFields": "activityid,createdon,description,subject,prioritycode,activitytypecode",
    "filterField": "_regardingobjectid_value",
    "idField": "activityid"
}

But this lead to problems!

With debugging into this error I found that a property dataMap (object) was missing which should specify an activitytypecode, however setting it in my code did not help as it was rebuilt as an empty object by the timeline. Comparing with the contact sample revealed that completely wrong turns were taken as the contact had a different derivative of the class where the activitytypecode was hardcoded as “customtest”, which also sounds odd.
From here on I discovered that my custom task record was pooled with the OOTB task record, which had the dataMap built correctly. I can only assume what happens here, something like the same entity name leading to this bug? Nevertheless, the fix was to simply disabling Activities, the original task not being rendered lead my record to the correct classes again.

You will also notice that my footer did not render here, but my nerves were already tested enough at this point, I will postpone this problem to another article.

Summary

Timeline Custom Connectors is a tricky to implement feature due to missing documentation and bad error handling. But you can do a lot of cool stuff with it and with configuration it gets even cooler!

You need to put a (valid) JSON into a WebResource and reference it in the timeline configuration alongside the code file. Note that you will need to prepend a /WebResources/ for the configuration file as it is not automatically done.

The content will be passed to the init method in an already parsed state and from there to change the behavior of your component. I advise to define an interface for the configuration as it will ease tracking all necessary properties.

On a side note, if you are trying to render activities that would usually also appear in the timeline anyway and run into issues with “Record failed to load”, try deactivating Activities in the timeline configuration as there might be a mixup between the OOTB functionality and your Timeline Custom Connector.

[VIDEO] Subgrids in Power Pages

Sun, 28 Sep 2025 00:00:00 +0000

In this video we will manipulate the display of cells in a Subgrid.

Repository Link: https://github.com/Kunter-Bunt/PowerPagesClientAPI

Check it out here.

D365NameCombiner: New Samples

Sun, 14 Sep 2025 00:00:00 +0000

Back when I started this blog, I wrote a series of articles about Plugin Self Registration and it featured a specific use case for this technique in form of the D365NameCombiner which was introduced in “Putting it into practice”.

In this post I want to revisit this tool as I still think it’s very relevant and just lacks some advertisement and samples.

The Basics

The D365NameCombiner is installed as a managed solution that comes with the app Name Combiner Administration where you create Name Combinations. These specify and table, a target column and a formula(/format) for this column. This format is then applied synchronously whenever one of the fields below change.

To have a very basic example, lets take a combined address format that is commonly used in german speaking countries.

Street Streetnumber
Zip City
Country

To combine this into a single field the following Name Combination is created.

A main advantage here is that this is applied synchronously. A flow doing the same thing would introduce a delay, which could be detrimental if someone tries to print the address right after changing it. They would now persist the old address in the generated document.

This whole sample is really for illustration only. For once address1_composite does have a very similar format already (it just swaps zip and city) and for example a Word Template for a letter could combine the address from the separate columns anyways. So in the next sections we will dive into some more practical scenarios.

The Request

In this sample a bank employee shall log the type of a customer request, for example Balance or Remaining Debt, in a custom entity. As any entity, this needs a primary column of type string that is shown for example in Lookups. However, the natural things for the employee to enter are an Optionset value (Request Type), a Lookup (Customer) and potentially a Date (Request Date). If we now combine a name in a Flow, the form will still show “New Customer Request” in the header after the request is saved until the flow has ran and the user refreshed the form, not ideal. So let’s try this scenario with the D365NameCombiner.

This time, we will use additional formatters within the formula. These are behind the double-colon “:” and specify additional information for the logic. We have

{0:fullname} for the Lookup, where fullname specifies the column of the entity behind the lookup.
{1:LCID=1033} for the Optionset, where LICD=1033 specifies that the english displayname of the selected option shall be used.
{2:yyyy-MM-dd} for the datetime field, which specifies that only the date part shall be printed (in ISO format) because it has the Date Only subtype, making the time part unnecessary.

The Loan Application

Continuing with our bank employee, they record loan applications by customers. Because much more data is entered here, giving the application a name would be feasible, but in practice, the names are all over the place. Therefore the organization wants to combine a name from some required fields.

Compared to The Request we have 2 additional formatters

{0:0.00} for the money field, formatting the amount to loan with 2 decimal places.
{2:LCID=1033;Separator=&} for the Multi-Select-Optionset, specifying a separator in case the user selected multiple options.

This time the outcome is a more lengthy, but well formatted sentence.

Summary

Generating names synchronously does not require a programmer! With the D365NameCombiner solution everyone with maker knowledge can fulfill requirements for synchronous text field generation, even if methods like a formula column are not available because it is about the primary column.

Additional formatters after a column allow for well formatted results. For example navigating to columns behind a lookup and printing the labels of optionsets.

[VIDEO] Using the WebApi with the Power Pages Client API

Sun, 31 Aug 2025 00:00:00 +0000

In this video we will manipulate data with scripting via the Power Pages WebApi.

Repository Link: https://github.com/Kunter-Bunt/PowerPagesClientAPI

Check it out here.

CIJ Form Scripting: Working with Lookups

Sun, 17 Aug 2025 00:00:00 +0000

I recently was tasked to prefill Marketing Forms based on query parameters and while this is relatively straight forward for normal field, as always, lookups are kind of special.

And to make matters worse, I was absolutely unable to find anything about this online, so here we go.

To have something visual for this article, the requirement may sound something like this “When someone clicks the Contact Us button on the Toys page, the category of the request should be prefilled with Toys, they should not have to select it manually again”. This can be solved with copying the form and setting a default value, however, this won’t scale well if you have many categories and maybe even combinations, for example for different countries.

What happens in Lookup fields?

To start the investigation I tried to find out what happens when I use the lookup as a user. Because when you first inspect the HTML, the lookup has no elements, but when I click on it, it certainly has! And yes, as soon as I click on the field, the Chrome Dev Tools (F12) will show a request for given lookup and the response is 10 records, if I scroll down, the next 10 are retrieved.

Also the input element in the HTML now has children! While the name should be pretty clear, the data-value is not. Applying a Base64 decode at least reveals, some guid, but it’s not the guid of the record and seems to be the same for all elements in the list. Decoding with a BinaryFormatter deemed it to be an illegal format, at least without further preprocessing.
Fortunately for my case: The name was unique anyways and therefore was sufficient for selecting the correct record. I would assume this is the most common case for the readers as well, because if there are duplicate names, how would the user of the form know which one to select? When the user now selects a record, the data-value of the selected option is copied into the data-value of the input element.

data-value="mwo_leadcategory,IAAAAGRkMzJkODBmZjdiZTQ5YzI5ZTc0Mjk0YmFlZDQ1YmE5AAEAABAAAAA7mbQrnmv6ja2+ms04dQwDbcuW8msTK5TscxdandO3pUkN8rwBlgf4RyISNJIq4iHhBdGRaXYNatvBTj7Bvy9tcEwpCkIf7vTZBxVfgShYGB94+huu11BZEBen2Gxm0vRkFCoUnN05ncrpV87dap63PIFoBApJKYYMArmpIcIZ+hp350g3t72tTiMJXDpOr0u4/RgbpQ69YGyWfx3vlbd2dv0E+w+I06uNAiYP9j9Prd5egHBqK5HfI2048AzvylcB7v6p7qsifJm5/nQBMMXPiesj1JdrbzeF56hXM5MEBKwkM/lTyzugZKb4nbJO7gZPDpud5DcgZy7NZXVcWk3e3Rq43jsaBANrtY971yNIoqeX2sLhSfA8LsJAt6uBl+V+hr5BsJZANVMFymzDf11qZ2Q5o+rCvrCrWSCtM/V/gA==";

recorid="98954879-9a47-f011-877a-0022488278a7";

// Base64 of the value after the comma
decoded=`
���dd32d80ff7be49c29e74294baed45ba9������;+k8um˖k+sZӷI
G"4*!ёiv
jN>/mpL)
B_(XxPYlfd*9Wj<h
I)!wH7N#	\:NK`lvvӫ&?O^pj+#m8W"|t0ω#ԗko7W3$3S;dNO7 g.eu\ZM;k{#HI<.@~A@5Sl]jgd9¾Y 3
`;

Setting a Lookup

So, given a name, we can find the record in the list of options, then navigate one element up to get the data-value and copy it over into input element. Sounds doable, but there is still a problem: If the user has not interacted with the lookup yet, no options will be loaded. First idea is to fake a click, but due to the limit of 25 records retrieved even faking a scroll will soon get to its limit, especially if you have something like 1000+ options. Instead we can fake the user typing a search word to get the list down to less then 25 elements - well if names are unique, it will be 1 element - and then select from the resulting list. So with that, code would start to look like this:

function setMyLookup(newVal) {
    var lookupField = document.querySelector('input[name=mwo_category]');

    lookupField.value = value;
    lookupField.dispatchEvent(new Event('keyup')); 

    // ...
}

The keyup event signals to the MS form logic that there was something entered to the input, meaning someone searched for a value and thus it will fire the search request to the server.

But now we still face the problem, that we don’t know when the request is finished and the MS form logic has populated the lookup with the options. We will solve this with an MutationObserver. This is something that will observe an HTML element for changes and once observed, will call a function. On the inside we can check whether the observed mutation indeed included the option we wanted to select.

function setMyLookup(newVal) {
    var lookupField = document.querySelector('input[name=mwo_category]');

    lookupField.value = newVal;
    lookupField.dispatchEvent(new Event('keyup')); 

    const lookupContainer = lookupField.closest('div.lookupFormFieldBlock');

    const observer = new MutationObserver(() => {
        if (trySetMyLookupValue(lookupContainer, lookupField, newVal))
            observer.disconnect();
    });

    observer.observe(lookupContainer, { childList: true, subtree: true });

    if (trySetMyLookupValue(lookupContainer, lookupField, newVal))
        observer.disconnect();
}

We are creating the MutationObserver and register it to observe the enclosing div here, with its childList and subtree to also capture changes to the options. Whenever one of those objects changes, we want to execute trySetMyLookupValue (which we will discuss soon) and if it is successful, we want to disconnect the observer to avoid hogging browser resources. Not disconnecting could also lead to some problems with the user setting a value manually etc. Finally we are checking manually once, just in case the options were already loaded, e.g. because the user already interacted or the new search value is the same as the old one.

function trySetMyLookupValue(lookupContainer, lookupField, newVal) {
    const ul = lookupContainer.querySelector('ul');
    if (!ul) 
        return false;

    const matchingLi = Array.from(ul.querySelectorAll('li')).find(li => {
        const optionDiv = li.querySelector('.ui-menu-item-wrapper');
        return optionDiv && optionDiv.textContent?.trim() === newVal;
    });
    if (matchingLi) {
        const dataValue = matchingLi.getAttribute('data-value');
        if (dataValue) {
            lookupField.setAttribute('data-value', dataValue);
        }
        return true;
    }
    return false;
};

In trySetMyLookupValue we are first checking if the list (ul) is present at all, if not, there are no items loaded yet. Next we are checking the divs (identified by the class .ui-menu-item-wrapper) inside the list items (li) for one that matches our option. Remember that this code matches by name here.
If a match is found, the data-value is copied from the option to the lookups input field to ensure that the submission of the form will include the selected option. Only if an option was found, this function will return true and thus disconnects the observer.

Reading the selected option

This one is much easier! Of course based on the previous knowledge we would need to compare the data-value to the options to find the selected option and then navigate to the div with the name.
But there is a much easier way for this: You can simply read the value of the input field. It contains the name of the selected option as well and you can react to changes simply by using an onChange handler.

function checkMyLookupChanged(matchedVal) {
    var lookupField = document.querySelector('input[name=mwo_category]');

    if (lookupField.value === matchedVal) {
        // ... the logic
    }
}

document.querySelector('input[name=mwo_category]').addEventListener('change', () => checkMyLookupChanged('Toys'))

Summary

As always, lookups are a little more tricky.
To work with lookups in frontend scripting you first need to understand that the selectable values are not preloaded with the form. Instead they are retrieved on the fly as the user uses the field by clicking (first 10), scrolling (next 10) or typing (up to 10 matching the text fragment).

To set a value, you can fake the user searching by setting the input field value to the desired name and then dispatching the keyup event. Now observe the changes to containing div element to be notified once the list has finished loading. Finally, find the value in the list of options and copy over the data-value property.

To read a value, you can simply read the value property. When the user selects an option, this will also trigger a change event which you can listen to.

[VIDEO] Installing the Power Pages Client API

Sun, 03 Aug 2025 00:00:00 +0000

In this video we will set up the Power Pages Client API for your own projects in 2 different ways, both for when you are using JavaScript and for when you are using TypeScript with a bundler.

Repository Link: https://github.com/Kunter-Bunt/PowerPagesClientAPI

Check it out here.

Help your users!

Sun, 20 Jul 2025 00:00:00 +0000

You probably have documentation for your users, right? Something describing processes, tips on how to use Dynamics and so on. Good news is: There is an easy way to link your users to this guidance!

There is this little question mark symbol in the Command Bar right next to your user profile picture. It usually links to the Microsoft documentation, but we can make it link to our own pages as well.

Enabling Custom Help in the Admin Center (Configuration)

To change the link, go to the Power Platform Admin Center (PPAC) -> Manage -> Environments. Select you Environment and go to Settings -> Product -> Features. Here you will look for a section called Help Features and switch on Custom help for customizable entities which will allow you to to set the Global custom help URL where you enter the home page of your documentation site.

Now don’t forget to hit save at the bottom to save your changes!

The changes will become active almost immediately, however, as these elements are cached, make sure to perform a “Clear Cache Refresh” when trying out the effects.

I’ve simply linked to my blog here and no matter where I click the help button in this environment now, it will link me to the home page of this blog.

Context Parameters

Below the Global custom help URL you will also find a checkbox Append parameters to URL.

If we check this and save, Dynamics will append following query-parameters to the given URL:

userlcid (e.g. userlcid=1033)
The language of the logged in user
typename (e.g. typename=contact)
The logicalname of the table if at a grid or form
entrypoint (e.g. entrypoint=form)
Not appended for grids or dashboards, the only place I found it is when clicking help from a form
formid (e.g. formid=1fed44d1-ae68-4a41-bd2b-f13acac4acfa)
Only appended on forms, contains the guid of the system form

Sample URLs reach from
https://www.marius-wodtke.de/?userlcid=1033
when opened from a Dashboard to
https://www.marius-wodtke.de/?userlcid=1033&typename=contact&entrypoint=form&formid=1fed44d1-ae68-4a41-bd2b-f13acac4acfa
when opened from a specific form.

One link per table (Customization)

However, likely your documentation is already present and did not plan for these parameters. Or your documentation platform is simply not configurable to support these. You would have the option now to link to a proxy service that rewrites the url. For example you enter my-proxy.com in the PPAC and it translates the userlcid and typename parameters to route parameters instead. Calling my-proxy.com?userlcid=1033&typename=contact would then forward to my-docs.com/en-US/contact.

However, if a) the proxy needs a dictionary because the routes do not match (e.g. typename=mwo_article needs to become /Articles/) and b) automatically resolving the language parameter is not that important, there might be an easier solution.

Navigate to your solution and select a table. Now click on Properties -> Advanced options -> For this table and enable Provide custom help. Then enter the documentation for this specific table in Help URL and save.

Now clicking the help button in the context of the table, no matter if you are on the grid or a form, the button will link to the link you entered for this table. If you have Append parameters to URL configured, they will still be appended!

Also note, that the properties of a table are only transported with the solution if Include table metadata is enabled in the Table segmentation properties (you can find this under Advanced at the table ribbon). If you fail to enable this, deploying the solution will not deploy the custom help link.

This option also works if custom help is not enabled for the environment in PPAC! That can be helpful for ISVs as they can link their tables to their own documentation, after all, the user won’t find anything helpful in the MS docs.

Summary

Linking your own documentation might be more helpful to the user than the official docs of MS. We can manipulate the help button (? in the top-right ribbon) to link to any url.

For once there is a configuration option in Power Platform Admin Center which is valid for the whole environment. This will link to a single URL and has the option to append query-parameters, most importantly containing the users language and table they are currently on.

However, many systems won’t be able to interpret these parameters and thus the customization option in Make might be used. Here a URL is entered per table, which will overrule the PPAC configuration for these tables.

Most organizations will therefore run a combination of both methods, the PPAC configuration to catch all instances that are not in the context of a table, plus links for each table that have a documentation available. If the OOTB parameters are planned from the beginning, the effort of entering the specific URL for each table may be saved, in this case no further customization is necessary.

If you do not have control over the environment because you just deliver the solution, use the customization option to pack your help links with the solution.

[VIDEO] Attribute.addOnChange in Power Pages

Sun, 06 Jul 2025 00:00:00 +0000

In this video we will extend with the common method of addOnChange to allow reacting to user input!

Repository Link: https://github.com/Kunter-Bunt/PowerPagesClientAPI

Check it out here.

Patterns: What are the correct Table Segmentation Properties?

Sun, 22 Jun 2025 00:00:00 +0000

“Table Segmentation Properties” or “Root Component Behavior” is an important concept that everyone working with solutions should understand thoroughly! The terms describe how much of a table is in the solution and will affect deployment of it.

When to use which behavior

When exporting a solution and looking at the solution.xml file you will find a section about root components like this:

<RootComponents>
    <RootComponent type="1" schemaName="account" behavior="1" />
    <RootComponent type="1" schemaName="contact" behavior="2" />
    <RootComponent type="1" schemaName="mwo_test" behavior="0" />
    <RootComponent type="80" schemaName="msdynce_saleshub" behavior="0" />
</RootComponents>

As you can see, there 3 tables inside, account, contact and mwo_test, which is a custom table created within the solution. They all have a different value in the behavior property.

Behavior “2” contains the least and should be your default for any table that you do not create yourself. If I only add a column to the contact table and create/modify a form for it, this behavior is the perfect choice, it fully complies with the rule of thumb “Include only what is necessary to a solution to minimize export/import times and avoid conflicts with Managed Solution updates”. It does not really have a name, but I will call it “Only include selected subcomponents”

Switching to behavior “1”, which is called “Include Table Metadata” is necessary as soon as you start to change the Properties of a table. These are things like the Display Name, Enable Audit, Track Changes etc. This a bit tricky, because you can set these properties also in a solution containing the table as “Only include selected subcomponents” and they will take affect on the source environment, however they will not be exported and thus not transported to the target environment. You will learn how to check which behavior is active in the next section, however this is easy to overlook and it would be nice if Make would at least warn you about the currently selected behavior. Environment Variables for example have a much better UX in terms of what is included to the solution.

Behavior “0” is sometimes necessary but should be used with caution. It was preselected for me by Dynamics when I created the Test table in the solution and that is because the first time a new table is introduced to a target system via solution import, it needs to be with behavior “0”. It’s called “Include all objects”. The only other situation where you would choose this behavior is when you have created a custom entity in another solution but now want to transfer it to the current one for deployment as you are not going to deploy the other solution first. This is because “Include all objects” will be needed for successful creation of the table in the target environment. If you would choose a different behavior your solution would have a dependency on the table being present in the target environment. However, you cannot misuse this to fully include a table from a managed solution into your solution as the solution will still report the dependency on the managed solution containing the entity. Furthermore, you will run into bigger deployment issues when doing this to frequently used OOTB tables like account or contact. Including all objects means you will create dependencies to all managed solutions defining a component in these tables and this virtually means that your target environment has to have exactly the same setup as your source. To make this more visual: Someone started a PoC for Field Service on the dev environment, great, now you can’t deploy to production anymore since the solution has around 20 dependencies to various Field Service solutions. You now have the option to install Field Service to production or remove the account table from the solution and readd it with only the components needed. By the way, the last option is of course the correct option, but what are the needed components? And you better not make a mistake when adding them because failing to add a custom column will delete it from production and thus loose its data! To summarize: Never use “Include all objects” (behavior “0”) on OOTB entities. But this option is almost always the right choice for your custom entities.

How to set the behavior

As explained in the previous section, when creating a table in a solution the behavior is automatically set to “Include all objects”. When adding an existing table you can choose the behavior via 2 checkmarks.

But what if I already included the table? It will not appear in the Add Existing -> Table dialog and when selecting Add Existing at the respective table, the dialog will already be advanced to selecting subcomponents. The behavior can be checked and modified at the table under Advanced -> Table Segmentation Properties. Here we find the same checkmarks to set.

Note that you are able to select the checkmarks and you are also able to deselect “Include table metadata” again after it was selected. However, once you selected and saved “Include all objects”, you will not be able to deselect it again. And as illustrated above: Following the suggestion to remove and readd the component is the correct fix, but you really want to avoid getting into this situation in the first place. So just be careful with the “Include all objects” behavior.

Also note that if “Include all objects” is chosen this also means that table metadata is included as well.

Summary

For OOTB/Managed tables, leave the checkmarks “Include table metadata” and “Include all objects” unselected by default. If you start changing properties (e.g. Display Name or Audit) of a table, check the Table Segmentation Properties under Advanced and make sure “Include table metadata” is enabled. There is virtually no situation where you would want to turn on “Include all objects” for an OOTB/Managed table and it can be tricky/risky to resolve the issue if the option was selected.

For custom tables use “Include all objects” by default. This makes sure the table can be created in the target environment and ensures that all dependencies within the table are fulfilled. This will be preselected for you if you create the table within the solution.

If you hear someone refer to Root Component Behavior this is because the Table Segmentation Properties are reflected as a property called behavior when exporting the solution.

[VIDEO] Hiding Sections in Power Pages

Sun, 08 Jun 2025 00:00:00 +0000

In this video we will extend with the common methods of setVisible and getVisible for Sections in forms!

Repository Link: https://github.com/Kunter-Bunt/PowerPagesClientAPI

Check it out here.

Implementing efficiently with Earlybound Interfaces

Sun, 25 May 2025 00:00:00 +0000

Avoid duplication, that’s one of the principles of clean code. But sometimes this collides with our wish to work with Earlybounds, which also has the argument of Fail early on its side.

So, lets consider the following requirement “We would like to alleviate the user from entering the country when entering the address of an Account. It should be approximated from Line1, City and PostalCode”. How this works is not relevant for my sample, but if it happens in a PreOperation-Plugin, the code would look something like this.

private void AutocompleteCountry(ILocalPluginContext localPluginContext, Account account)
{
    if (!string.IsNullOrEmpty(account.Address1_Country))
        return;

    var guessedCountry = GuessCountry(account);
    if (string.IsNullOrEmpty(guessedCountry))
        return;

    account.Address1_Country = guessedCountry;
}

What’s the crux now? If this works well, the next request will be “Make it happen on Contact, Lead and MyCustomAddress as well”.

Applying interfaces

The problem now is, that we can’t simply pass a Contact to the function. Even though it would have the necessary Address1_ fields, Account and Contact are two different objects for the compiler. It would work with Latebound entities, however that would loose our Fail Early advantage.

The solution is interfaces. Let’s define one:

public interface IAddress
{
    string Address1_Line1 { get; set; }
    string Address1_City { get; set; }
    string Address1_PostalCode { get; set; }
    string Address1_Country { get; set; }
    Guid Id { get; set; }
}

And now we only need to apply this to the given entities. Fortunately, if you are using popular tools like the Earlybound Generator (v2) from the XrmToolbox, they will define the entities as partial, allowing us to define additional properties. Just make sure that you are working in the same namespace as the generated class, in my sample this is the default namespace DataverseModel.

namespace DataverseModel
{
    public partial class Account : IAddress
    {
    }

    public partial class Contact : IAddress
    {
    }

    public partial class Lead : IAddress
    {
    }
}

And that’s it for Contact and Lead. You will now understand why I chose this specific address sample, the entities simply comply to the interface and we can go on to adapt our country logic.

private void AutocompleteCountry(ILocalPluginContext localPluginContext, IAddress address)
{
    if (!string.IsNullOrEmpty(address.Address1_Country))
        return;

    var guessedCountry = GuessCountry(address);
    if (string.IsNullOrEmpty(guessedCountry))
        return;

    address.Address1_Country = guessedCountry;
}

This worked without any weird passing of Func for getters and Action for setters, splitting out the parameters for GuessCountry and so on. No, simply the input was changed to IAddress and since the Account is and IAddress, we can pass it.

Making entities comply

But if we try the same for the MyCustomAddress, problems appear.

The only way to make it comply would be to name the logical names as close to the Address1_ fields as possible and somehow get rid of the inevitable publisher prefix in the generated class. That sounds like more effort than duplication and might be completely unreasonable if there is already data in the table.

Fortunately there is a better solution!

namespace DataverseModel
{
    public partial class MwO_MyCustomAddress : IAddress
    {
        public string Address1_Line1
        {
            get => MwO_Line1;
            set => MwO_Line1 = value;
        }
        public string Address1_City
        {
            get => MwO_City;
            set => MwO_City = value;
        }
        public string Address1_PostalCode
        {
            get => MwO_PostalCode;
            set => MwO_PostalCode = value;
        }
        public string Address1_Country
        {
            get => MwO_Country;
            set => MwO_Country = value;
        }
    }
}

As you can see, I can simply rewire the Properties to write the desired fields. When the logic reads Address1_City, it will redirect to MwO_City which (in the generated code) returns this.GetAttributeValue<string>("mwo_city").
When the logic sets Address1_Country it will redirect to MwO_Countrywhich (in the generated code) calls this.SetAttributeValue("mwo_city", value). The fields can be used interchangeably.

Simple to read and without any further problems we can pass our custom address table into the function. This is the method you will use in many scenarios where the entities won’t line up as nice as the Address1_ fields do. If it is really a one time edge case where logic is applied to fields that are not close or don’t have a natural naming, you can even consider inventing a separate prefix and route the fields in all entities, e.g. TaxCodes_Country (-> to not confuse with an address country here).

Summary

When logic should be applied the same way to multiple tables, applying interfaces to the given Earlybound entities is a great way of achieving reusable code that avoids duplication. This is possible because Earlybound entities are usually marked as partial and thus can be extended.

You first define an interface with properties. Then you create another definition of an entity in a separate file - not in the Earlybounds folder - with the same namespace as the original Earlybound definition. Apply the interface to the new (partial) class.

If your table does not and maybe cannot fit the property names in the interface, you can simply rewire the getter and setter to the property you would like to work with. Once all entities are prepared with the interface, you simply swap the concrete entity with the interface in your logic and can now pass all relevant tables to the code.

Below you will find a short writeup of all the syntax we’ve used. Everything that is enclosed in _ (underscore) should be replaced with your own variable names.

namespace _InterfaceNameSpace_ 
{
    public interface _MyInterface_
    {
        string _MyCommonProperty_ { get; set; }
        string _MyPropertyWrittenDifferently_ { get; set; }
    }
}


namespace _EarlyboundNameSpace_
{
    public partial class _MyEntity_ : _MyInterface_
    {
        string _MyPropertyWrittenDifferently_ 
        { 
            get => _MyActualProperty_; 
            set => _MyActualProperty_ = value; 
        }
    }
}

namespace _LogicNameSpace_
{
    public class _MyLogic_ {
        public void _MyFunction_(_MyInterface_ record) {
            // Do stuff with multiple tables!
        }
    }
}

[VIDEO] Hiding Tabs in Power Pages

Sun, 18 May 2025 00:00:00 +0000

In this video we will extend with the common methods of setVisible and getVisible for Tabs in forms!

Repository Link: https://github.com/Kunter-Bunt/PowerPagesClientAPI

Check it out here.

[VIDEO] Power Platform Learners: Easy Guide to Mask Sensitive Columns | Step-by-Step Tutorial (No Coding)

Wed, 07 May 2025 00:00:00 +0000

In the April edition of the Power Platform Learners Group, I demoed a feature that reached GA with the current wave: Masking data in fields with column security.

Check it out here.

[VIDEO] Power Platform Learners: How to use Environment Variables for Site Settings in Power Pages?

Tue, 29 Apr 2025 00:00:00 +0000

Welcome to the Episode 25th of the Power Pages Quick Tips Series. In this episode, we are going to talk about How to use Environment Variables for Site Settings in Power Pages?

Environment variables are the variable that holds configuration values specific to an environment that the application or features can reference.

When working with environment variables for site settings? , it’s important to follow best practices to ensure efficient and effective management. Use environment variables to define site settings values across various environments with the enhanced data model. While the standard data model relies on deployment profiles, the enhanced model allows for dynamic configuration of environment-specific settings using environment variables.

Check it out here.

Patterns: Functionality by Role

Sun, 27 Apr 2025 00:00:00 +0000

Have you heard of the requirement “When X visits (a record of) Table Y, they should not see Z”, whereX is a role and Z is a button, control, section or tab? Although Dynamics works with privileges, stakeholders usually think in roles and therefore produce concepts which may only work with roles and not with privileges. And the other issue may be, that the request needs frontend scripting with JavaScript anyways and nitpicking about privileges vs roles is no value.
If Z is a button, the discussion might be worth it! That is because there is an out of the box display rule (EntityPrivilegeRule) that can check for the presence of a privilege, that could skip a custom implementation fully. If there is no natural privilege, it may be an option to create an dummy entity for this purpose (but document this well!).

I specifically write this article because I recently came across a situation where someone implemented this hush-hush with Copilot and it used the “old” style of querying role names. And although you will find the “new” style of implementing at probably half dozen other articles, there apparently need to be more so that chances rise that humans and AI find the better way of comparing roles.

To have something concrete for our samples, lets consider this: “Only the european users have access to the the Power BI report of the (european) customer in the ‘Report’ Tab on the Account form. We may roll out this report for other regions soon. However, the others should not see it for now to avoid confusion and support requests regarding the missing permissions error”.
This can be solved with pure customizing by creating a copy of the form, adding the Tab, restricting it to a Role “Report User” and adding the form to the app. However, this is often unpopular with stakeholders and users when they are not used to switching forms. Therefore the scripting solution is preferred.

Basics and the old way

Like any other record in Dataverse, Roles have Guids. However, the same role exists for every Business Unit in the environment! So if we have a Role Report User and the Business Units Root, Europe and Asia, Report User will be present 3 times with different Guids. If you assign Report User to User1 (Europe) and User2 (Asia) they will physically have different roles although conceptually they have “the same permissions”. The quotation marks are necessary here because we have this concept on Business Units, because of their different assignments the two users will have different permissions depending on the Owning Business Unit of records.

Traditionally there was the property Xrm.Utility.getGlobalContext().userSettings.securityRoles to get the roles of the current user. It returned a list of Guids. However, usually you want to check for a roles name, so it needed to be retrieved and code looked something like this:

// DO NOT USE THIS CODE, BETTER ALTERNATIVES BELOW!
function HasRole(roleNameToCheck) {
    var userRoles = Xrm.Utility.getGlobalContext().userSettings.securityRoles;
    var roleNames = [];
    var promises = [];

    userRoles.forEach(function(roleId) {
        var promise = Xrm.WebApi.retrieveRecord("role", roleId, "?$select=name").then(
            function success(result) {
                roleNames.push(result.name);
            },
            function error(error) {
                console.log("Error getting role name: ", error.message);
            }
        );
        promises.push(promise);
    });

    Promise.all(promises).then(function() {
        console.log("Roles of the user: ", roleNames, "; checking against: ", roleNameToCheck);

        return roleNames.includes(roleNameToCheck);
    });
}

Problematic here also, it’s asynchronous, so it gets a bit more tricky in using because it is unknown how long it will take until the names are retrieved. Usually it will be below a second, but it could also be well above, resulting in poor UX.

New an better style

Microsoft extended the Client API with a Xrm.Utility.getGlobalContext().userSettings.roles property some time ago, and it’s much better! Its output is a list of objects and each object has a name and id property. So there is no need anymore to fire a query for every role of the user, instead we can directly use it. Here is a sample output:

[
    { id: "e7dd9bc6-d239-ea11-a813-000d3a35b14a", name: "Report User" },
    { id: "733ea175-0aeb-4442-a634-1972703f9750", name: "Sales Team" }
]

The resulting code is much simpler:

function HasRole(roleNameToCheck) {
    var userRoles = Xrm.Utility.getGlobalContext().userSettings.roles;
    var roleNames = [];
    userRoles.forEach(item=>roleNames.push(item.name));

    console.log("Roles of the user: ", roleNames, "; checking against: ", roleNameToCheck);
    return roleNames.includes(roleNameToCheck);
}

And if you really want it as a single line, here you go var hasRole = Xrm.Utility.getGlobalContext().userSettings.roles.getAll().map(_ => _.name).includes(roleNameToCheck);, but I thinks it’s too long and getAll() is not officially documented.

Next comes a TypeScript class with the same functionality.

export class Roles {
    static readonly ReportUser: string = "Report User";

    static HasRole(roleName: string): boolean {
        const userRoles = Xrm.Utility.getGlobalContext().userSettings.roles
        var roleNames: string[] = [];
        userRoles.forEach(item=>roleNames.push(item.name));

        console.log("Roles of the user: ", roleNames, "; checking against: ", roleNameToCheck);
        return roleNames.includes(roleName);
    }
}

// Usage:
// if (Roles.HasRole(Roles.ReportUser)) { ... }

And this is synchronous, so we can show/hide with minimal delay, making for a better UX than the previous solution.

D365RibbonHelpers

In the intro I already told you: Try to switch ribbon button rules to privileges. But it is virtually the only application where you could use the code from this article in isolation. And sometimes you can’t convince stakeholders to change their requirements, so maybe you need this for hiding/showing a button.

So, we create a custom enable rule, use the file mwo_/Roles.js and the function HasRole. Then we add a string parameter with the name of the role we are looking for. Now the rule is associated to the command of the button and it should work!

If you are wondering what is happening, the console log line might help you, here are outputs with and without the role of the sample:

Summary

The addition of the roles property in Xrm.Utility.getGlobalContext().userSettings was very welcome and makes checking roles in frontend code simpler and more efficient. You can use the code samples in the article for your own implementations or leverage mwo_/Roles.js:HasRole("myRole") from the D365RibbonHelpers solution.

If you are dealing with a button, you may be better of by discussing whether the requirement can also be fulfilled with checking the presence of a privilege as this is supported by standard display rules. If your requirement is already formulated for a privilege and is not regarding a button, you may want to take a closer look at the getSecurityRolePrivilegesInfo method.

[VIDEO] Power Platform Learners: How to Create and Customize a Card Gallery in Power Pages?

Thu, 24 Apr 2025 00:00:00 +0000

Welcome to the Episode 24th of the Power Pages Quick Tips Series. In this episode, we are going to talk about How to Create and Customize a Card Gallery in Power Pages?

A card gallery in Power Pages is a data control that displays information from a table and view in a card format. It allows makers to present data visually, making it easier for users to browse and interact with the information.

Check it out here.

[VIDEO] setVisible & getVisible in Power Pages with ClientAPI

Sun, 13 Apr 2025 00:00:00 +0000

In this video we will extend with the common methods of setVisible and getVisible.

Repository Link: https://github.com/Kunter-Bunt/PowerPagesClientAPI

Check it out here.

My first shot at Managed Identities for Plugin Assemblies

Sun, 06 Apr 2025 00:00:00 +0000

For over a year I have been following the feature “Use managed identities for Dataverse plugins” and after multiple delays it should finally become generally available and I had some time this weekend to implement a first attempt to test it out.

General idea

You create an App Registration/Service Principle in Azure and an identity in Dataverse to represent it. We connect this Dataverse identity with the Plugin Assembly where we would like to use it. In a classical Username/Password situation, this connection would determine the Username used. And then we sign the Plugin Assembly with a Certificate, this would be the Password. Finally the IServiceProvider can resolve an IManagedIdentityService that will create JWTs for accessing resources.

And this is super exiting! While the tokens will only work with services that have OAuth2 authentication and even then might still have problems with cross-tenant situation (or a million other reasons), this opens a significant bootstrap: Azure KeyVault.
In Dataverse we don’t have a really secure storage for secrets, I argue that even things like the Secure Configuration of Plugins is not as secure as the name suggests. But even with a legacy ERP system only supporting Username and Password I can now store these in a KeyVault, enable the App Registration to read them and then retrieve the values in a Plugin to integrate that system without exposing those credentials.

Microsoft already has documentation on this and I suggest also considering it, because such a new feature might receive some changes. In this article we will however have more pictures and some tips for problems not explained in the official version.

The App Registration

In the Azure Portal, navigate to EntraId and select Add -> App Registration at the top. Then enter a better name than I did (your company probably has a convention for AppReg naming) and hit register.

From the Overwiew we will need the AppId and TenantId in the next section, you can copy them now or come back when you need them. We will jump to Certificate & Secrets next.

Here we need a new credential in Federated Credentials. This means someone else (the PowerPlatform) will validate the credentials and can request a token for this AppRegistration.

Now we need a certificate, this can be any certificate. MS suggests against self-signed certificates for production use cases, however I don’t know how this makes it more secure, since only the thumbprint is checked. If you have an explanation, I would be glad if you comment it (there is a switch to enable comments on the bottom left). For creating a self-signed certificate I usually ask Google for “windows create self signed certificate” and then take an article leveraging OpenSSL since I can’t remember the commands by heart. This reminds me, that I should leverage a CoPilot for this question in the future, saving a minute. Whatever way you get it: You need a pfx certificate with the private key included, also generating the public part as cer/crt file is helpful.

Update: The next section on the Subject Identifier is out of date! With the move to GA, this got changed, check the official docs for more info!

For the credential values:

The name may have any value, however it cannot be changed later. I think using the certificate name(/subject) and thumbprint might be a good name, because it both reflects situations like multiple developers having different certificates as well as “the same” certificate (by subject) having 2 credentials because one certificate is nearing expiration.
For the issuer you want to get Environment ID from the Power Platform Admin Center. It is found in the Environment Details. Then we want to remove all hyphens and split off the last two character/numbers by a dot. So “7efcc31a-c410-e20e-9b95-dd448cedf653” becomes “7efcc31ac410e20e9b95dd448cedf6.53”. Now we embed this to the sts-url which is “https://7efcc31ac410e20e9b95dd448cedf6.53.environment.api.powerplatform.com/sts" in this sample.
For the value we will also need the thumbprint of the certificate. You can get it by inspecting the cer/crt files details. Important: Value is case sensitive, in my case the thumbprint needed to be in upper-case! And for this value we also need the environment id in its unmodified version, the final value looks like “component:pluginassembly,thumbprint:C67255AD07AB5E6A0A3F1979DAC2F928A580E6F4,environment:7efcc31a-c410-e20e-9b95-dd448cedf653” where you of course need to replace the values in thumbprint and environment.
The audience is also case-sensitive. In my testing it needed to be all lower-case! So the default value “api://AzureADTokenExchange” becomes “api://azureadtokenexchange”. The error message in this regard was quite good as it specified that the requested audience (api://azureadtokenexchange) was not matched with EntraId.

Plugin Code

Since my goal was to generate a token at all and I did not have a concrete project use case, you will find a very minimal code sample. But this is very nice after the extensive setup, we can get away with 2-3 lines of code to get a valid token.

First we use the IServiceProvider to resolve the IManagedIdentityService.
Then we define a scope with a list of strings. With newer OAuth versions they scrapped the resource, which would be “https://vault.azure.net/", with the scope further detailing the actions you want to take within the resource. If you don’t have that you can usually just append “.default”, however, there might be resources preventing that, requiring you to specify your intents and this is exactly the situation where you would use the list part of this parameter. And lastly we can use the AcquireToken with the given scope(s) to get a token that we would then use to access the resource with something like a HttpClient.

public class Class1 : IPlugin
{
    public void Execute(IServiceProvider serviceProvider)
    {
        var trace = serviceProvider.Get<ITracingService>();
        trace.Trace($"Acquiring Token");

        var managedIdentity = serviceProvider.Get<IManagedIdentityService>();

        var scope = new List<string> { "https://vault.azure.net/.default" };
        var token = managedIdentity.AcquireToken(scope);

#if DEBUG
        trace.Trace($"Token: {token}");
#endif
    }
}

AFTER building and BEFORE uploading the assembly we need to sign it with a certificate. The following command assumes that we have the Developer Powershell in Visual Studio in the bin/Debug (or bin/Release) folder, with the certificate being present in the same folder: signtool sign /f myCertificate.pfx /p myPW /fd SHA256 myProject.dll. Here everything with the my prefix needs your own values.

After that, everything runs like a normal Plugin Assembly.

Managed Identity Association

We have an App Registration in Azure and the signed Plugin Assembly now. Next we need to tell Dataverse how it should connect the two. First we need to create a record in the managedidentity table. For this we will need the AppId and TenantId from the AppRegs Overview page. I’ve used Postman to create the record, but there also seems to be a tool in the XrmToolbox (Plugin Identity Manager).

POST https://mariuswodtke-mvp.crm4.dynamics.com/api/data/v9.2/managedidentities

{
    "applicationid":"a56f4eac-dab5-4920-b005-e84146adaadc",
    "managedidentityid":"a56f4eac-dab5-4920-b005-e84146adaadc",
    "credentialsource":2,
    "subjectscope":1,
    "tenantid":"738016bf-2f59-46ca-9660-357d1de3b865"
}

I’ve set the managedidentityid to the AppId here as well, MS generally does not like it when you assign guids not generated by the platform, but I hope there will never be that many Managed Identity records that it would lead to partitioning inefficiencies.

Next we associate the Managed Identity record with the plugin Assembly by setting the respective lookup. We will need the managedidentityid and the pluginassemblyid for this, the latter I grabbed from the details section of the Plugin Registration Tool.

PATCH https://mariuswodtke-mvp.crm4.dynamics.com/api/data/v9.2/pluginassemblies(478f1797-e33c-4d42-933f-c08107c24614)

{
    "managedidentityid@odata.bind": "/managedidentities(a56f4eac-dab5-4920-b005-e84146adaadc)"
}

And that’s it, we created all necessary credentials and joined them in Dataverse, now we need to run the plugin and check the results.

Resulting Token

As you saw in the code sample above, I printed the token to the tracelogs for debug builds. For production this is of course not ideal, but for the initial tests it helps in identifying issues. Websites like jwt.ms can decode the token, to check values like the audience and appId to clarify 401 errors received from target resources. So here is a sample of a (now expired) token I was able to generate.

{
  "typ": "JWT",
  "alg": "RS256",
  "x5t": "JDNa_4i4r7FgigL3sHIlI3xV-IU",
  "kid": "JDNa_4i4r7FgigL3sHIlI3xV-IU"
}.{
  "aud": "cfa8b339-82a2-471a-a3c9-0fc0be7a4093",
  "iss": "https://sts.windows.net/738016bf-2f59-46ca-9660-357d1de3b865/",
  "iat": 1742668105,
  "nbf": 1742668105,
  "exp": 1742672005,
  "aio": "k7RgYPDft6dY2dl8+ik3puM7L7+sWrrUUrOpWHado3CwUbu83D8A",
  "appid": "a56f4eac-dab5-4920-b005-e84146adaadc",
  "appidacr": "2",
  "idp": "https://sts.windows.net/738016bf-2f59-46ca-9660-357d1de3b865/",
  "idtyp": "app",
  "oid": "8911b4f4-2b4e-46ce-b854-ebeebffe7bc6",
  "rh": "1.AEsAvxaAc1kvykaWYDV9HeO4ZTmzqM-ighpHo8kPwL56QJNGAQBLAA.",
  "sub": "8911b4f4-2b4e-46ce-b854-ebeebffe7bc6",
  "tid": "738016bf-2f59-46ca-9660-357d1de3b865",
  "uti": "43CV3HaJykiHcPnF8XDWAA",
  "ver": "1.0",
  "xms_ftd": "Kflhs7-A9NMBFFQe6G1y0PBjOPke2Jzw3uk-TfA9yOw",
  "xms_idrel": "7 16",
  "xms_rd": "0.42LlYBJi9AYA"
}.[Signature]

Did you notice the Guid in the audience as well? I remember getting back a named audience for KeyVault, but verifying with Postman, I also got the guid. Likely this is the id of the KeyVault Service.

Summary

Finally we have the bootstrap for secrets in Plugins! We got that a while back for Power Automate with the secrets option for Environment Variables, but Low-Code also has it’s limits and whenever we need High-Code, we should have an option now.

The App Registration approach already offers many options for integrating with Azure Resources and APIs that leverage OAuth2. For everything else Azure KeyVault can store the needed credentials and we can securely access them with the Managed Identity.

After a somewhat cumbersome setup (which might be improved through community tools like the “Plugin Identity Manager”), usage in code is remarkably easy and performance was quite good as well. With a warmed up environment the executions took about 100ms, I expected worse.

To make it happen you will need a certificate with a private key (.pfx), an App Registration in EntraId with Federated Credentials pointing to the certificate and Environment. Then you can sign the Plugin Assembly with the certificate and connect it with a record in the managedidentity table, holding a reference to the App Registration. Once all this is set up, you can create a token for an Azure resource like Key Vault with only 2-3 lines of code.

[VIDEO] getValue & setValue in Power Pages with ClientAPI

Sun, 16 Mar 2025 00:00:00 +0000

In this video we will start with the common methods of getValue and setValue.

Repository Link: https://github.com/Kunter-Bunt/PowerPagesClientAPI

Check it out here.

Patterns: Opening a 'dialog' for a record

Sun, 02 Mar 2025 00:00:00 +0000

In the “trigger flow from ribbon” pattern we already took a look at triggering logic from the ribbon. But what if we require additional input from the user?

For this article consider the following requirement as a sample when you might need this pattern: “We need to copy records. When copying, we want to decide how many copies we need and the system should create the according amount.” The discussion in this scenario showed that the maximum number of copies would be 5, so we could still handle this with a flyout or splitbutton that vary input. But of course we can easily imagine inputs that break the “half dozen variants” barrier where separate buttons start to fail.

This pattern relies on the usage of JavaScript, but you can also download the solution from the Ribbon Helpers repository to skip programming. In that case you only need to work with either Ribbon Workbench (XrmToolbox) or

Custom Pages

Back in the days there were the dialogs for this, but they are long deprecated. But we’ve gotten Custom Pages instead, this is essentially a Canvas App for a single screen. And important for the use case: Xrm.Navigation.navigateTo allows us to pass an entityName and recordId to the page and there we can read these values with Param("entityName") and Param("recordId").

So, we start with building a Custom Page, I’ve put a Label and Input for the amount of copies in there and a “Submit” button, which will trigger a flow with the id (or ids, more on that later) and amount of copies to then read the record and create the records in a loop.

Additionally I’ve put up two labels with the entityName and recordId, but this is mainly for debugging purposes, I would advise to hide or even delete those labels before shipping to production. Unless of course your users like this kind of debug information, but experience says that almost no one values it.

Code

This is fortunately very short, we only need to call Xrm.Navigation.navigateTo(input,options) where input and options are relatively simple objects. For options in theory it would be enough to specify wether the page should be opened fullscreen (target: 1) or as overlay (target: 2). For input you need the pageType: "custom" and then the name contains the logical name of the custom page, so for example name: "mwo_dialog_da9e9". And then, for the scenario in this pattern, we also want to pass entityName and recordId.

Below you will find the full function that is part of the Ribbon Helpers repository. It also allows to control the size on screen, where you can pass width and height as “px” or “%” (unit). In the next section we will take a closer look on how to leverage this function from the Ribbon Workbench.

function OpenDialog(pageName, entityName, entityIds, height, width, unit){
    if (!height)
        height = 80;

    if (!width)
        width = 80;

    if (!unit)
        unit = "%";

    if (typeof entityIds === "string")
        entityIds = entityIds.replace("{", "").replace("}","").toLowerCase();

    if (Array.isArray(entityIds))
        entityIds = entityIds.join(",").replace("{", "").replace("}","").toLowerCase();

    var options = {
        target: 2,
        width: {
            value: width,
            unit: unit
        },
        height: {
            value: height,
            unit: unit
        }
    }

    var input = {
        pageType: "custom",
        name: pageName,
        entityName: entityName,
        recordId: entityIds
    }
    
    Xrm.Navigation.navigateTo(input,options).then(
        () => console.log("Dialog opened"), 
        (error) => console.log(error)
    );
}

Single Record Dialog

Now we will start with operating the Ribbon workbench. I will spare you the buttons and so on. The easy sample uses the CRM Parameters “SelectedEntityTypeName” and “FirstSelectedItemId” to get logicalname and id. Additionally a string parameter specifies the logical name of the custom page, that’s it.

For the button to be shown at the right time you should also add a selection count rule, this ensures it is only shown when exactly one record is selected, everything else might lead to unexpected behaviors where the dialog is opened without a record or only with the first one, although multiple were selected.

And the result then looks like

Obviously the default 80% of the screen is way too much for this simple dialog, we will explore the sizing options a bit in the next section, but essentially this is a trial and error for every page for me.

Multi Record Dialog

First of all consider this unsupported. So recordId (and also entityName) does not have a reasonable character limit, this means we can pass more than one record. Technically MS does not specify a limit but their language talks about a “table record”. Of course this does not hinder us from passing more, but we can’t be sure this will be considered as a bug and being fixed without a prior notice.

But well, if you are brave enough and the function is not that business critical, we can can switch “FirstSelectedItemId” to “SelectedControlSelectedItemIds” and adapt the selection count rule to something reasonable, lets say 50 records.

You can also see the usage of the sizing parameters here, which limit the size of the dialog to 500x500 pixels. This is not optimal as well, we would require more width and less height, but for showcasing the feature, it will have to do.

Modern Commanding/PowerFx

Theoretically, CustomPages can also be called with PowerFx from the Modern Commanding ribbon. However, even the official documentation for Navigate prominently links to the JS functions, since you cannot pass the recordId and entityName parameters.

But we can use the same function with the same parameters that we used previously in the Ribbon Workbench. The sample below uses the multi record parameter “SelectedControlSelectedItemIds”, remember that this is kind of unsupported.

We could also fix this by only showing the button when only one record is selected, visibility can be controlled with the function CountRows(Self.Selected.AllItems), compared to the sample below you could specify it to be = 1.

Passing no record

Like I mentioned with PowerFx, you can open a custom page without passing a record, this is also possible with the OpenDialog function pictures above. However, using JS extensions for this use-case seems silly to me; instead, you can simply add the page to the navigation of the Model-Driven App if you do not need a record association. But, to be complete, this is how it would work:

Summary

With custom pages and the possibility to pass in records we got a much better version of dialogs! You can either implement on your own with Xrm.Navigation.navigateTo or install the Ribbon Helpers Solution and then use OpenDialog with Ribbon Workbench or Modern Commanding to open a prepared custom page with the context of a record. The custom page then uses Param("entityName") and Param("recordId") to read these parameters.

Because there is no reasonable character limit on these parameters, also multiple records can be passed as a comma separated list to the page. However, this should be considered unsupported and therefore should be avoided for business critical functionality. Also keep in mind that in this case, the custom page needs to be aware of this behavior and must split the list of ids again.

[VIDEO] Power Platform Learners: How to Enable multiple-language in Power Pages?

Fri, 28 Feb 2025 00:00:00 +0000

The content snippets do not only allow changing texts on standard pages, they also allow us to translate pages. In this video we are exploring how we can enable a new language in Power Pages.

Check it out here.

[VIDEO] Power Platform Learners: How to Leverage Sharepoint in Model Driven Apps?

Wed, 19 Feb 2025 00:00:00 +0000

In the 2024 edition of the Global Power Platform Bootcamp I showed the capabilities of the Sharepoint integration in Model Driven Apps. The recording is now up for everyone to follow along!

Check it out here.

[VIDEO] Power Platform Learners: How to Configure Power Automate cloud flows in Power Pages?

Sat, 15 Feb 2025 00:00:00 +0000

Need some server logic for your Power Page? Power Automate is here to help! With this tip you will easily integrate your Power Pages Website with a Power Automate Flow.

Check it out here.

[VIDEO] Power Platform Learners: PrettifyMyWebApi for Microsoft Dataverse

Fri, 14 Feb 2025 00:00:00 +0000

This time in the Power Platform Learners call I pitched for the Chrome extension PrettifyMyWebApi, a useful tool for Dataverse developers and admins.

Check it out here.

Power Pages Actions: The parser is wrong!

Sun, 09 Feb 2025 00:00:00 +0000

In a recent article I detailed the possible parameters with Power Pages Actions and how the parser will recognize them.

Repository Link: https://github.com/Kunter-Bunt/PowerPagesActions

The problem

However, Harish Karyattu reached out and made me aware of a problem he was facing with this. He had a string input for his Custom API and the parser misinterpreted the inputs for a Guid. The input in question here stemmed from a payment gateway, so changing the input was definitely not an option.

Simple fix you would say: “Just change the parameter to Guid and you are good!” But a) that might have lead to a conflict if you are using the same API from a Dataverse interface where it is stored as string and b), even more challenging, what if it just fits the format but is technically not Guid? You could run into a situation where some inputs are recognized as string because they are unparsable, while others are forwarded as a Guid.

“d4918dfd-4c34-4497-a69b-3d8844ae462c” is a Guid,
“d4918dGd-4c34-4497-a69b-3d8Z44ae462c” is not (notice the G and Z)!

An obvious fix would be for Power Pages Actions to read the type from metadata, however, this would definitely be a performance hit, rendering the solution less useful.

The fix

So we need something to tell the parser a specific type. The version 1.3.0.0 of Power Pages Actions therefore introduces an option to specify the type of simple parameters with an @. So for the problem above we would use @string like this:

var inputs = {
    ["Input@string"]: "00000000-0000-0000-0000-000000000001"
}

This will make sure that that “Input” is passed on to the Custom API as a string, even though it technically fits the Guid scheme. Remember that you will need to change the style of property definition to the array accessor
{Input: "00000000-0000-0000-0000-000000000001"} ->
{["Input@string"]: "00000000-0000-0000-0000-000000000001"}!
Of course the syntax of this gets more verbose, but remember that you will only need to use this option if your inputs might match another type.
I could also imagine this being the case when you have user inputs in a string field that might match number formats.

Other modifiers

The full list of modifies includes all simple parameters but not the complex objects like Entity.

@string
@int
@decimal
@float
@bool
@guid
@datetime
@picklist
@money

@picklist and @money deserve special attention as they might be a less verbose option for your code, because they convert complex parameters to simple ones.

Optionset:

var inputs = {
    PicklistParam: {
        OptionSetValue: 1
    }
}
// can also be written as
var inputs = {
    ["PicklistParam@picklist"]: 1
}

Money:

var inputs = {
    MoneyParam: {
        Money: 7.8
    }
}
// can also be written as
var inputs = {
    ["MoneyParam@money"]: 7.8
}

Summary

First of all, thanks Harish for mentioning this! Feedback is important and you should not be shy to message someone or open an issue on Github for an open source project. While OS solutions might only have few maintainers with a work and private life, obstructing bigger changes, they also do not have to run through big organizations with a Bug/Feature.

With the parser directives it is now possible to fix issues with Power Pages Actions recognizing parameters incorrectly on your own with minimal adaptions. Simply add @<type> to your input property where type is a simple type like string or decimal.
This is only needed in case mismatches are happening or are expected, e.g. due to uncontrollable input.
To finish this article, here is a sample how such a mismatch and its correction will look like in the network tab.

Repository Link: https://github.com/Kunter-Bunt/PowerPagesActions

GoLive Plans with Azure DevOps Wiki and MermaidJS

Sun, 02 Feb 2025 00:00:00 +0000

There is more to a project than just customizing/coding correctly, we all know that. But as I’m a technician, I always look out for things in Azure DevOps that may help me succeed. And one of those things is Mermaid diagrams, which you can use in Azure DevOps Wikis by enclosing them in a code block like this:

::: mermaid
<diagram type>
<diagram content>
:::

They are super useful to for example include flow diagrams in documentation. This has the great benefit that the source of the diagram is directly in the article and can be changed in the article should some details change.
Of course a real tool like MS Visio is more powerful and could export an image to be embedded, but you would also have to link to the SharePoint (or similar) location where the diagram source is stored and you expect everyone to have access there and the necessary tool and so on. My experience says that it is likely people will then not adapt the diagrams and just leave them as they were, over time leading to incorrect documentation.

But I did not want to use this article to argue for the general use of mermaid with Azure DevOps, instead I wanted to discuss a more creative way of using them: A gantt chart can help us to visualize and track the progress towards a GoLive.
Of course there are actual tools for that like MS Project, but who has access to those? Everyone who has a stake, or just the project leads? I my projects the Wiki is much more accessible and therefore a good place to collaborate and make progress visible.

A gantt chart works like this

gantt
    dateFormat YYYY-MM-DD
    excludes weekends

    Sprint 1: s1, 2025-02-03, 10d
    Sprint 2: s2, after s1, 10d
    Sprint 3: s3, after s2, 10d

::: mermaid
gantt
    dateFormat YYYY-MM-DD
    excludes weekends

    Sprint 1: s1, 2025-02-03, 10d
    Sprint 2: s2, after s1, 10d
    Sprint 3: s3, after s2, 10d
:::

So it nicely renders out blocks for the events and obeys the given order (“after s1”). We first give a display name, then a double colon, an id, then the date or an order (which you should definitely prefer!) and a duration.
It will also render a marker for the current date, I will provide that as a picture as it will vanish once we are outside of the date period in the diagrams.

The next thing we are going to introduce are states, these are before the id.

gantt
    dateFormat YYYY-MM-DD
    excludes weekends

    Sprint 1: done, s1, 2025-02-03, 10d
    Feature A complete: done, milestone , fa, after s1, 1d
    Sprint 2: active, s2, after s1, 10d
    Feature B: crit, fb, after s1, 6d
    Sprint 3: s3, after s2, 10d
    Sprints complete: milestone, sc, after s3, 1d

::: mermaid
gantt
    dateFormat YYYY-MM-DD
    excludes weekends

    Sprint 1: done, s1, 2025-02-03, 10d
    Feature A complete: done, milestone, fa, after s1, 1d
    Sprint 2: active, s2, after s1, 10d
    Feature B: crit, fb, after s1, 6d
    Sprint 3: s3, after s2, 10d
    Sprints complete: milestone, sc, after s3, 1d
:::

So we can mark active, completed and tasks in danger. Milestones receive a special symbol and can also be marked completed.

One more concept are sections, these help to differentiate parts of the project. Usually they are “independent”, like a production setup is not directly tied to User Acceptance Testing (UAT), of course if UAT fails, it will have effects on the production timeline, but the setup is likely to have an almost independent timeline.

gantt
    dateFormat YYYY-MM-DD
    excludes weekends

    section Dev
        Sprint 1: s1, 2025-02-03, 10d
        Sprint 2: s2, after s1, 10d
        Sprint 3: s3, after s2, 10d
    
    section UAT
        Create Training Material (2025-03-16): ctm, 2025-02-20, 20d
        Create UAT Environment: cue, after s2, 1d
        Setup Users on UAT Env: sue, after cue, 2d
        Deploy to UAT Env: due, after s3 cue, 2d
        Execute UAT: uat, after due, 3d
        Structure Feedback: feedback, after uat, 3d
        Fix Bugs: bugs, after feedback, 7d

    section Prod
        GoLive Decision - Bernd: milestone, gld, after feedback, 1d
        Create Production Environment: cpe, after gld, 1d
        Setup Users on Prod Env: spe, after cpe, 3d
        Deploy to Prod Env: dpe, after cpe bugs, 2d

::: mermaid
gantt
    dateFormat YYYY-MM-DD
    excludes weekends

    section Dev
        Sprint 1: s1, 2025-02-03, 10d
        Sprint 2: s2, after s1, 10d
        Sprint 3: s3, after s2, 10d
    
    section UAT
        Create Training Material (2025-03-16): ctm, 2025-02-20, 20d
        Create UAT Environment: cue, after s2, 1d
        Setup Users on UAT Env: sue, after cue, 2d
        Deploy to UAT Env: due, after s3 cue, 2d
        Execute UAT: uat, after due, 3d
        Structure Feedback: feedback, after uat, 3d
        Fix Bugs: bugs, after feedback, 7d

    section Prod
        GoLive Decision - Bernd: milestone, gld, after feedback, 1d
        Create Production Environment: cpe, after gld, 1d
        Setup Users on Prod Env: spe, after cpe, 3d
        Deploy to Prod Env: dpe, after cpe bugs, 2d
:::

So, we now have different lanes, where some lanes start before others are finished. Someone from the business might start the user documentation while developers are still developing and the administrator is free to setup a new environment while others are still fixing stuff. Also notice here that some tasks have multiple dependencies, the last one counts!

For all possible elements, check the official documentation.

Now towards some “best practices”:

Give yourself some time, of course a deployment only takes a day, but assigning it 2d produces buffer. Think about these ranges as latest end. And if the predecessors are done, a task that has not reached its earliest start may be completed already!
If you know who will do a task, write it down, e.g. “GoLive Decision - Bernd”
If you need to move a task, write done the original date, e.g. “Create Training Material (2025-03-16)” where the duration was extended beyond that planned end date.
Don’t number IDs. Ok, I’ve used it here for the sprints, but for everything else, it makes it harder to insert new tasks to the middle.

And now we just need to encourage everyone to set their tasks active and done, maybe also crit if they want to raise something in the synchronization meetings.

And here is a bigger table as a final sample, have fun creating your own GoLive plan with Azure DevOps Wikis and Mermaid diagrams.

BTW, I think this looks better in light mode than in dark!

gantt
    title GoLive Timeline
    dateFormat YYYY-MM-DD
    excludes weekends

    section Dev
        Sprint 1: done, s1, 2025-02-03, 10d
        Sprint 2: done, s2, after s1, 10d
        Sprint 3: done, s3, after s2, 10d
        Sprint 4: done, s4, after s3, 10d
        Sprint 5: done, s5, after s4, 10d
        Development complete: done, milestone, dc, after s5, 1d
    
    section UAT
        Create Training Material (2025-04-05) - Hugo: done, crit, ctm, 2025-02-20, 40d
        Create UAT Environment - Nigel: done, cue, after s4, 1d
        Setup Users on UAT Env - Nigel: done, sue, after cue, 2d
        Deploy to UAT Env - Mary: done, due, after s5 cue, 2d
        Execute Manual Steps (See below) - Mary: done, ems, after due, 1d
        Perform Domain Authentication - Nigel: active, pda, after ems, 3d
        Import Sample Data - Claire: active, isd, after due, 2d
        UAT Preparations complete - Bernd: milestone, upc, after ems isd pda, 1d
        Execute UAT - Hugo/Bernd: uat, after upc, 3d
        Structure Feedback - Hugo/Bernd: feedback, after uat, 3d
        Fix Bugs - Mary: bugs, after feedback, 7d
        Deploy final fixes - Mary: dff, after bugs, 1d
        Retest fixes - Hugo/Claire: rf, after dff, 3d

    section Prod
        GoLive Decision - Bernd: milestone, gld, after rf, 1d
        Create Production Environment - Nigel: cpe, after gld, 1d
        Setup Users on Prod Env - Nigel: spe, after cpe, 3d
        Deploy to Prod Env - Mary: dpe, after cpe bugs, 2d
        Execute Manual Steps (See below) - Mary: emsp, after dpe, 1d
        Perform Domain Authentication - Nigel: pdap, after emsp, 3d
        Import OnPremise Data - Claire: iod, after dpe, 4d
        Disable Admin Mode - Nigel: dam, after iod pdap, 1d
        Announce System Availability - Bernd: milestone, asa, after dam, 1d

::: mermaid
gantt
    title GoLive Timeline
    dateFormat YYYY-MM-DD
    excludes weekends

    section Dev
        Sprint 1: done, s1, 2025-02-03, 10d
        Sprint 2: done, s2, after s1, 10d
        Sprint 3: done, s3, after s2, 10d
        Sprint 4: done, s4, after s3, 10d
        Sprint 5: done, s5, after s4, 10d
        Development complete: done, milestone, dc, after s5, 1d
    
    section UAT
        Create Training Material (2025-04-05) - Hugo: done, crit, ctm, 2025-02-20, 40d
        Create UAT Environment - Nigel: done, cue, after s4, 1d
        Setup Users on UAT Env - Nigel: done, sue, after cue, 2d
        Deploy to UAT Env - Mary: done, due, after s5 cue, 2d
        Execute Manual Steps (See below) - Mary: done, ems, after due, 1d
        Perform Domain Authentication - Nigel: active, pda, after ems, 3d
        Import Sample Data - Claire: active, isd, after due, 2d
        UAT Preparations complete - Bernd: milestone, upc, after ems isd pda, 1d
        Execute UAT - Hugo/Bernd: uat, after upc, 3d
        Structure Feedback - Hugo/Bernd: feedback, after uat, 3d
        Fix Bugs - Mary: bugs, after feedback, 7d
        Deploy final fixes - Mary: dff, after bugs, 1d
        Retest fixes - Hugo/Claire: rf, after dff, 3d

    section Prod
        GoLive Decision - Bernd: milestone, gld, after rf, 1d
        Create Production Environment - Nigel: cpe, after gld, 1d
        Setup Users on Prod Env - Nigel: spe, after cpe, 3d
        Deploy to Prod Env - Mary: dpe, after cpe bugs, 2d
        Execute Manual Steps (See below) - Mary: emsp, after dpe, 1d
        Perform Domain Authentication - Nigel: pdap, after emsp, 3d
        Import OnPremise Data - Claire: iod, after dpe, 4d
        Disable Admin Mode - Nigel: dam, after iod pdap, 1d
        Announce System Availability - Bernd: milestone, asa, after dam, 1d
:::

[VIDEO] Handling complex code in Power Pages (with bundling)

Sun, 19 Jan 2025 00:00:00 +0000

With bundling, we can write in as many files as we want and the result will still be only one JavaScript output file. This is great for more complex use cases in Power Pages, where creating webfiles is a hassle and managing dependencies can be tricky.

Find the sample repository here: https://github.com/Kunter-Bunt/PowerPagesTemplate

Deeplink to Scotts course: https://learn.develop1.net/courses/building-javascript-web-resources-using-typescript/dashboard

Check it out here.

Timeline: Are auto-posts annoying you?

Sun, 05 Jan 2025 00:00:00 +0000

Posts in the timeline are certainly a topic for debate. Do you allow users to create them, why shouldn’t they use Notes instead? And of course the question “Do you really need an element describing that the current record was created?”

There are reasons to have it, for example because the date is included you could economize the Created On field from a form with a Timeline and it is kind of a close to the timeline.

But on the other hand, this information is completely redundant and does occupy space in the database! A good reason to forgo auto-posts for organizations with a lot of records that will have auto-posts enabled by default.

Fortunately we can control auto-posts to a certain degree. Microsoft predefined for which events auto-posts may be generated and you can decide to enable or disable this feature for the given events.

And if you are wondering what exactly an auto-post is, it’s these messages within the timeline.

Preconditions

This might only apply to you if you came here to enable auto-posting: It is only available on environments with Dynamics 365 Apps enabled! So for example you won’t be able to test this on a developer environment even though you are able to set up timelines.

The other thing I’d like to mention: Definitely check your active rules. For this post I created a new environment and there were far less active rules than environments created in the past. For example the mentioned rules for the creation of contacts, accounts and leads were not active by default! So apparently Microsoft is adjusting these as well to have less default auto-posting, maybe I should change the title of this post to “Are you missing auto-posts?”

Configuration

So first of all I have to apologize for the looks of these pictures, somehow my environment was created in german and the translation only partly worked. I will try my best to also describe the things seen in english.

So you will find the auto-post rules in the Power Platform Environment Settings app under System, Activity Feed Rules. Here you find a list of the predefined rules of Microsoft, the names are in the base language of the environment. For the sample I took “New Contact” configuration and activated it. After that of course when I create a new Contact it immediately receives the corresponding auto-post you see in the picture above.

How does it work?

When you activate an auto-post rule that creates a plugin step. The name of the plugin is a little off, but we can see from the xml in the Unsecure Configuration that this plugin is configurable and is configured to work for Contact creation.

You can also see that the step is synchronous. This ensures that the timeline post is already there when the form refreshes after the Contact creation, when the timeline loads.

This however has performance implications. If you want to push a lot contacts you might to spare any synchronous step on creation. Also consider this for rules that work on N:N relationships (Associate). Because associate cannot be filtered down to specific relationships or entities, having a synchronous step here will impact all associates happening in the system!

Summary

The performance implications of auto-post rules are a good reason to sit together with IT and Business to decide on what rules offer a benefit and should be used, everything else should be omitted. While I always talk about reducing the amount of active rules, it might also be the case that you find very useful rules that are not active in your environment and I definitely don’t want to discourage you from activating them! I just want to raise awareness that they are executed in a synchronous manner, something you try to usually limit.

To find out what rules are active, head to the Power Platform Environment Settings app, System, Activity Feed Rules. Here you can select rules and (de-)activate them. However, the menu point is only found in environments that had the switch for Dynamics 365 Apps active when they were created.

Power Platform Advent Calendar: Wrap up Advent Calendar series & a BIG thank you

Tue, 24 Dec 2024 00:00:00 +0000

Check it out here.

Power Platform Advent Calendar: Translation with Open AI and Integrate with Dataverse

Sun, 22 Dec 2024 00:00:00 +0000

Check it out here.

Power Platform Advent Calendar: Integrating Translation - Retrieval Augmented Generation

Fri, 13 Dec 2024 00:00:00 +0000

Check it out here.

Power Platform Advent Calendar: How to integrate translation by using AI - Options for the dictionary?

Sat, 07 Dec 2024 00:00:00 +0000

Check it out here.

[VIDEO] Power Pages Actions vs Flow with Power Pages

Sun, 17 Nov 2024 00:00:00 +0000

Custom APIs offer a lot of flexibility, but cannot be called directly from PowerPages. With this video and the accompanying repository/solution, this is going to change! We are going to call custom functionality with an interface that is similar to what you know from the JavaScript of Model-Driven Apps.

However by now there is also the possibility to use a Flow as a proxy to call the API. In this video we will compare some of the differences of both methods.

Repository Link: https://github.com/Kunter-Bunt/PowerPagesActions

Check it out here.

[VIDEO] Power Platform Learners: Copilot agents, Timeline custom connectors, Power Platform catalogs and Gen AI search in Power Pages

Sun, 17 Nov 2024 00:00:00 +0000

While we get closer to the advent calendar season, the group still has new tips for you in store ;)

Check it out here.

[VIDEO] Power Platform Learners: How to set the Page Permissions in Power Pages ?

Fri, 15 Nov 2024 00:00:00 +0000

This time in the Power Pages Quick Tips Series we discuss Page Permissions which allow you to show certain pages to certain user groups by web role.

Check it out here.

What should have been my first Dataset-PCF

Sun, 03 Nov 2024 00:00:00 +0000

I recently wanted to solve a suboptimal experience with a subgrid on the Power Pages Action Configuration entity and thought I would build on my first shot with a React PCF, trying a dataset PCF for the first time.

Unlike “normal” PCF which bind to fields, as the name says, dataset PCFs bind to a dataset. Dataset we could also call list or grid, so in theory this is perfect to customize the experience of my subgrid.

ControlManifest differences

The ControlManifest.Input.xml is where you specify the bindings. A regular PCF will specify one or more property nodes in the control.

<manifest>
    <control namespace="PowerPagesActionsRoleSelector" constructor="PowerPagesActionsRoleSelector" version="0.0.5" display-name-key="PowerPagesActionsRoleSelector" description-key="PowerPagesActionsRoleSelector description" control-type="virtual" >
        <property name="isrestrictedtoauthenticated" display-name-key="Restrict to Authenticated Users" description-key="Boolean wether only authenticated users are allowed" of-type="TwoOptions" usage="bound" required="true" />
        ...
    </control>
</manifest>

The dataset PCF will use a data-set with property-set nodes inside. The data-set also resides in the control

<manifest>
    <control namespace="PowerPagesActionsRoleSelector" constructor="PowerPagesActionsRoleSelector" version="0.0.5" display-name-key="PowerPagesActionsRoleSelector" description-key="PowerPagesActionsRoleSelector description" control-type="virtual" >
        <data-set name="powerpagecomponentdataset" display-name-key="Power_Page_Component_Dataset">
            <property-set name="componentname" display-name-key="componentname_Name" description-key="componentname_Desc" of-type="SingleLine.Text" usage="bound" required="true" />
        </data-set>
        ...
    </control>
</manifest>

You can pregenerate such a manifest by using the --template dataset parameter when using pac pcf init.

When customizing the form, you can select it from the Components Workspace, pull it to the form and will be obliged to select the table and view for the dataset. Next would be to select the bound componentname, you can skip that, the data of the view will be delivered to you anyways, but a property-set might make it easier to implement generic components.

The catch

There is a problem for my subgrid though. You can’t mix a bound property with data-set! But that’s exactly what I was trying to achieve, selecting something in the subgrid should manipulate fields on the form (or vice versa).

But when you try to use both nodes as shown below, the PCF won’t be selectable in a form. Meaning we will need a different solution.

<manifest>
    <control namespace="PowerPagesActionsRoleSelector" constructor="PowerPagesActionsRoleSelector" version="0.0.5" display-name-key="PowerPagesActionsRoleSelector" description-key="PowerPagesActionsRoleSelector description" control-type="virtual" >
        <property name="isrestrictedtoauthenticated" display-name-key="Restrict to Authenticated Users" description-key="Boolean wether only authenticated users are allowed" of-type="TwoOptions" usage="bound" required="true" />
        <data-set name="powerpagecomponentdataset" display-name-key="Power_Page_Component_Dataset" />
        <!-- DOES NOT WORK! -->
        ...
    </control>
</manifest>

A solution

What could we do now? Well we can query data from regular PCFs but do not have a supported way to interact with the form apart from a bound property. Therefore, I will skip the dataset PCF again, do a regular PCF and if I needed to make the dataset configurable I would need to either pass a FetchXML as string or multiple strings for the OData parameters as inputs.

The biggest challenge now is to render a proper grid. Fortunately, Fabric with it’s office-ui-fabric-react library can help us achieve a quite decent look without much styling effort. The react component for a grid with selection looks like this:

<Fabric style={{ width: "100%" }}>
    <MarqueeSelection selection={this.selection} >
        <DetailsList
            items={this.state.data}
            columns={this.columns}
            setKey="set"
            layoutMode={DetailsListLayoutMode.justified}
            selection={this.selection}
            selectionPreservedOnEmptyClick={true}
            ariaLabelForSelectionColumn="Toggle selection"
            ariaLabelForSelectAllCheckbox="Toggle selection for all items"
            checkButtonAriaLabel="Row checkbox"
        />
    </MarqueeSelection>
</Fabric>

As you can see the only styling I needed was to set the width of the Fabric element.

I don’t think it makes too much sense to detail more code here. What you get in data and columns will definitely change, so I will link you to the repository here and only touch a bit on the selection since it took me some time to understand. If you don’t need to act on record selection, you may skip the next section.

Making selections

My idea was to show all available options in the grid and let the user associate via simply selecting the row. This makes associating a single button click. And of course disassociating as well. The approach will of course struggle in scenarios with a large number of selectable records, but with WebRoles, this should be fine.

Both the MarqueeSelection and the DetailsList share the this.selection object.

this.selection = new Selection({
    getKey: (item: IRecord) => item.key,
    onSelectionChanged: () => {
        this.props.selectionChanged(this.selection);
    }
});

The onSelectionChanged passes the event up to a function defined in the props, this is because the associate/disassociate happens in a different class and selectionChanged is the hook that is tied to an instance of it.

But the selection items do not work on their own! You need to explicitly pass the data and what is currently selected. So actually the MarqueeSelection and the DetailsList also implicitly share the data as well.

this.selection.setItems(data, true);
data.forEach((item) => this.selection.setKeySelected(item.key, item.selected, false));

I guess this is clear, we first set the data for the selection and then iterate the data so preselect the items that are already associated(/selected). But the 2 boolean parameters might need explanation.

The second parameter of setItems determines if the data shall just be added or if the collection should first be cleared and then the items are added. This is of course what we want here since we likely retrieved all selectable objects from the database.

The third parameter of setKeySelected determines whether to “anchor” the row. So basically highlighting it as the currently selected one by changing the background color of the row. This is unwanted here, I only want to set the checkmark at the start of the row since this code is executed without the user interacting with the grid, it is just executed after the data is being loaded successfully.

Lastly lets have a quick look at the interface of data.

export interface IRecord extends IObjectWithKey {
  key: string;
  name: string;
  site: string;
  selected: boolean;
}

So we have the key we need for the selection (natural selection here is the guid) and selected to feed the setKeySelected function. Whether a column is selected is determined by it being associated to the current record in my case. name and site are irrelevant for the selection, they are for columns rendered in the DetailsList.

Summary

While dataset PCFs are the primary solution to provide a custom experience for grids and subgrids, they do not work well, when you also need to manipulate the form. As a workaround we can also use a regular PCF and then leverage the React library of Fabric (also found as Microsoft Fluent UI) to render a grid and use bound properties to interact with the form. The result looks pretty similar to a regular grid. Let me link to the full code here again.

If you do not have the need to interact with the form and just want to make a custom grid experience, let me link you to some helpful resources from others:

[VIDEO] Power Platform Learners: How to customize content by using Content Snippets in Power Pages?

Wed, 23 Oct 2024 00:00:00 +0000

This time in the Power Pages Quick Tips Series we discuss the Content Snippets you can use to customize the login and registration pages.

Check it out here.

Content Snippets for Power Pages Login Page

Sun, 20 Oct 2024 00:00:00 +0000

To accompany our recent video over on the Power Platform Learners channel, here is a list of all the content snippet I know for customizing the login and registration pages of Power Pages

Account/SignIn/RememberMeLabel
Account/SignIn/SignInExternalDeprecatedFormHeading
Account/SignIn/SignInExternalFormHeading
Account/SignIn/SignInLocalFormHeading
Account/SignIn/TermsAndConditionsAgreementText
Account/SignIn/TermsAndConditionsButtonText
Account/SignIn/TermsAndConditionsCopy
Account/SignIn/TermsAndConditionsHeading
Account/SignIn/UsernameLabel
Account/SignIn/AccountConversionIdentityUsedErrorHeading
Account/SignIn/AccountConversionIdentityUsedErrorText
Account/SignIn/MinorNotAllowedCopy
Account/SignIn/MinorNotAllowedHeading
Account/SignIn/MinorWithoutParentalConsentNotAllowedCopy
Account/SignIn/MinorWithoutParentalConsentNotAllowedHeading
Account/SignIn/PageCopy
Account/SignIn/PasswordLabel
Account/SignIn/PasswordResetLabel
Account/SignIn/SignInLocalButtonText
Authentication/OpenIdConnect/AzureAD/Caption

Register

Account/Register/ConfirmPasswordLabel
Account/Register/ExternalAuthenticationFailed
Account/Register/PageCopy
Account/Register/PasswordLabel
Account/Register/RegisterExternalFormHeading
Account/Register/RegisterLocalFormHeading
Account/Register/RegistrationDisabledMessage

Redeem (Invitation)

Account/Redeem/RedeemByLoginLabel
Account/RedeemInvitation/PageCopy
Account/Redeem/InvitationCodeFormHeading
Account/Redeem/InvitationCodeLabel

SetPassword

Account/SetPassword/ConfirmPassword
Account/SetPassword/Email
Account/SetPassword/PageCopy
Account/SetPassword/SetPasswordButtonText
Account/SetPassword/Username

PasswordReset

Account/PasswordReset/EmailLabel
Account/PasswordReset/EmailInstructionsText
Account/PasswordReset/ForgotPasswordFormHeading

Account/Nav/Register
Account/Nav/SignIn
Account/Nav/Redeem
Profile/SecurityNav/ChangePassword
Profile/SecurityNav/SetPassword

Special Thanks and References

Pictures

[VIDEO] Translating Power Pages with Content Snippets

Sun, 13 Oct 2024 00:00:00 +0000

In a recent video on the @PowerPlatformLearners channel, we showcased Content Snippets with the login page. But this time we are going to use them for our very own content, showing button labels in german.

Check it out here.

Timeline Custom Connectors 3: Adding Filters

Sun, 29 Sep 2024 00:00:00 +0000

In the last post of this series about Timeline Custom Connectors we added contacts of an account to the timeline. But we have not included them at all in the filters of the timeline, meaning you can’t view the contacts in isolation or filter them out to only show activities.

Prior considerations

You don’t need to implement filtering, you can skip the getFilterDetails at all, it’s optional. And considering my field experiences, there is a considerable amount of user-groups that use the timeline to get a glance at recent activity. Filters are totally irrelevant for them since they are able to identify the relevant records by simply scrolling through.

But of course this is not true for all organizations. The more data is displayed in the timeline, the more users crave for filtering. And us adding more data could be the reason, users finally say “why can’t I only display X”.

When implementing getFilterDetails we can return a partial set of filters that will be merged with the filters returned by the other modules (implemented by MS). We can both extend existing filters as well as introduce custom, new filter categories. For the sample I extended the Module which usually has things like Activities, Posts and Notes with the new value Contacts. Also we are going to introduce a new filter for the gender of contacts. I don’t have a good use case for this as I can’t imagine contacts being a good fit for the timeline, but it will show well that you can have both Checkboxes (MultiSelect) as well as Radiobuttons (SingleSelect).

The reason why I kind of hinted to skip implementing filters if possible is the count property. An option with zero records will not be shown, if a category (FilterGroup) has no option with at least one records, it will be hidden. But you also can’t just put one to all options, if an “invalid” combination of filters is chosen, the timeline will start to misbehave with infinite loads. So the only option for us is implementing the count correctly, which is harder than you might think. ;)

To help you getting started yourself, this article has a branch in the sample repository called Filters. Here you will find the full code of the commented snippets we discuss in the coming sections.

Changes to ContactData

Just for completeness: The data being retrieved from contact in the previous branch DataverseContactData did not include the gender. So I added the gender as a number to the IRecord interface, retrieved it from Dataverse and mapped it to the record. This will allow us to filter on this property.

A new class

Now to the real thing, the ContactFilter class.

In this class I introduced a getFilterDetails that will not only get the IFilterRequest like the method in the official interface, but also the records we retrieved in the ContactData class. And then we can just define a filter like this and return it:

{
    name: FilterGroupName.RecordType,
    type: FilterGroupType.MultiSelect,
    options: [
        {
            value: "Contacts",
            label: "Contacts",
            count: 1,
        }
    ]
}

But remember, we still need to cover the count properly before this is usable, but the “Record Type” filter should now show a new option “Contacts (1)”. Alongside we will see “Activities (x)” from Microsofts Activities module. So extending an existing filter just requires you to match the name, in the FilterGroupName enum you will find more predefined filters.

With our custom filter we can do very similarly, we are just going to define more options and make use of the fact that label and value are two separate properties, allowing us to match the OptionsetValues with the values of the filter options. Also I will introduce variables for the strings here as a best practice since I will need them multiple times.

private readonly gender = "Gender";
private readonly male = "Male";
private readonly maleNumber = "1";
private readonly female = "Female";
private readonly femaleNumber = "2";
...
{
    name: this.gender,
    type: FilterGroupType.SingleSelect,
    options: [
        {
            label: this.male,
            value: this.maleNumber,
            count: 1,
        },
        {
            label: this.female,
            value: this.femaleNumber,
            count: 1,
        }
    ]
}

Now we need the correct count. For this we have the method getFilteredRecords(records: IRecord[], filter?: IFilterRequest, additional?: IAdditionalFilter). It also takes the current records plus the filter and should return all records matching the filters. This is of course necessary to determine what the getRecordsData function from the official interface should return when filters are applied. But the optional additional parameter will represent “what if the user selected this option?”. So the combination of existing filters being passed to us by the pipeline plus an imaginary additional filter will determine the final count.

private readonly filterExecutors: { [key: string]: (record: IRecord, selectedFilter: ISelectedFilter) => boolean } = {
    [FilterGroupName.RecordType]: this.filterModule,
    [this.gender]: this.filterGender
};

getFilteredRecords(records: IRecord[], filter?: IFilterRequest, additional?: IAdditionalFilter): IRecord[] {
    let selectedFilters = this.getSelectedFilters(filter, additional);

    let filteredRecords = records;
    selectedFilters?.forEach(selectedFilter => {
        let filterExecutor = this.filterExecutors[selectedFilter.name]?.bind(this);
        if (filterExecutor)
            filteredRecords = filteredRecords.filter(record => filterExecutor(record, selectedFilter));
    });

    return filteredRecords;
}

private filterModule(record: IRecord, selectedFilter: ISelectedFilter): boolean {
    return selectedFilter.options.some(val => val.value === this.contacts);
}

private filterGender(record: IRecord, selectedFilter: ISelectedFilter): boolean {
    return selectedFilter.options.some(val => val.value === record.gender.toString());
}

What you can see here that the methods filterModule and filterGender are custom for each type of filter since I could imagine an interface that will fit for any situation. Just take the RecordType as a sample: To have something like a matching property .ToString matches the value for the record type, we would need to enrich our IRecord interface with a RecordType that is static for all records.

Instead here the dictionary filterExecutors just stores functions for each FilterGroup and those functions can do all the fancy stuff we need to determine the correct outcome.

For the method getSelectedFilters I will just link you to the sample repository, since it’s a little to long for display. In essence it just extracts all the groups that have at least one option selected, all the others are ignored in filtering. Afterwards, if present, the additional filter either needs to be added, or just the new option needs to be added or in case of SingleSelect, the existing option might need to be replaced.

So last thing to do, apply this new function to the count, here is a sample.

{
    name: FilterGroupName.RecordType,
    type: FilterGroupType.MultiSelect,
    options: [
        {
            value: this.contacts,
            label: this.contacts,
            count: this.getFilteredRecords(records, filter,
                {
                    name: FilterGroupName.RecordType,
                    value: this.contacts,
                    type: FilterGroupType.MultiSelect,
                }).length,
        }
    ]
}

Changes to MyDataSource

Well, a) getFilterDetails needs to call getFilterDetails:

async getFilterDetails(filter?: IFilterRequest | undefined): Promise<IFilterGroup[]> {
    return this.contactFilter?.getFilterDetails(this.records.map(record => JSON.parse(record.data) as IRecord), filter) ?? [];
}

and b) we should also the selected filters to getRecordsData:

async getRecordsData(request: IRecordsDataRequest, filter?: IFilterRequest | undefined): Promise<IRecordsDataResponse> {
    this.records = this.records ?? await this.contactData?.getRecordsData(request);
    let filteredRecords = this.contactFilter?.getFilteredRecords(this.records.map(record => JSON.parse(record.data) as IRecord), filter) ?? []
    
    const response = {
        requestId: request.requestId,
        records: this.records.filter(record => filteredRecords.some(filteredRecord => filteredRecord.id === record.id)),
    }

    return response;
}

The result

Now, what will it look like in the system? Let’s look at some pictures.

We can nicely see how selecting filters affects other groups, even between different modules. We can also see the importance of those “imaginary filters” we added in calculating the count of records.

With the Single Select I noticed that once you selected the filter, you cannot deselect it unless you use the button to clear all filters, which will also clear the other groups. This is not ideal and might be a reason to simply go with Multi Select everywhere to avoid this behavior, even if a Single Select might be a proper choice like our gender use case.

Summary

Implementing filters requires quite some code! But once implemented it has a nice feel and gives the user options to find what they need in crowded timelines.

To implement filters you have the option to extend existing ones by matching their FilterGroupName or adding new groups. Implementing filters is optional, but when you choose to, you will have to make sure the count of remaining records if that option was chosen is calculated correctly. When you use the sample as a template you can do so by just implementing a function for each FilterGroup and then registering it to the filterExecutors. Afterwards you will just have to add the according FilterGroup in the list returned from getFilterDetails. Still: The ContactFilter class is the biggest we had so far in this series and it’s code is much less trivial than the samples before.

[VIDEO] Power Platform Learners: How to Set up the Microsoft Identity provider in Power Pages?

Sat, 21 Sep 2024 00:00:00 +0000

Power Pages has multiple Identity providers for handling Authentication and naturally Microsofts own Entra Id is one of them. Learn here how to set it up to enable login with a Microsoft account to for example allow your employees to login to your Power Page.

Check it out here.

Patterns: Connections vs. N:N Relationship vs. Connection Table

Sun, 15 Sep 2024 00:00:00 +0000

Often we have to design something that connects N records of Table A with M records of Table B. And often it is not that simple as “they are connected”. More information needs to be collected, like in which way are they connected? When were they connected and when disconnected?

When to use N:N relationships

N:N Relationships are perfect whenever there is no additional information or processing required. But I want to stress that you should discuss whether something could be on the horizon. Once we established the relationship it’s hard to change it to one of the other options after it’s established.

Some information might even be retrievable for N:N relationships: If you enabled Auditing for the involved tables, you will see the associations in the Audit History. However, keep in mind that Audit Data is not that easily analyzed!

One more thing to consider is processing: There is no Power Automate Trigger for Associate/Disassociate! And also if you are capable in high code, the Plugin Steps cannot be filtered down to a certain relationship. That means you will trigger on any Associate anywhere in the system and then in code you filter down to your tables. It might not sound like much, but platform operations like loading your assembly are heavy. Especially if it is synchronous logic, it will affect the whole system. Just one more sample: There is such a logic OOTB for Knowledge Article Attachments and it will affect the performance of an Associate between two custom tables.

Long story short: I advise against putting logic to Associate/Disassociate until we have effective measurements to filter on platform level. Even more so if the logic shall be synchronous as this may be a straight path to performance issues with N:N Relationships.

There is also a big advantage to N:N relationships: You can associate multiple records to the one you are currently on at the same time. Users love that feature ;)
You will find such a relationship OOTB at the Opportunity for Competitors.

Another subtle advantage over the other methods is the fact that this is only “one table far”. Some functionality in the platform can only span one table from the current record, for example Word Templates. So lets assume you’d connect the Competitors with a Connection instead of N:N, then you would only be able to print information from the Connection and not from the Competitor itself. You can sometimes get around this limitation by pulling information via calculated fields, but of course this approach does not scale.

When to use Connections

Connections is another predefined concept by Microsoft. It is essentially what we will later look at as a “Connection Table”, but it is ready to use with your Dataverse. All you need to do is activate “Can have Connections” on the table(s) and you will be able to connect that table to any other table that has connections enabled. Here comes the first disadvantage: After being enabled, it cannot be disabled again.

Connections not only have a “left” and “right” but they may also have roles, a description and a start and end date. And maybe important for your use case, it has the regular fields of a table like Owner, Created By, Modified On, etc.

Connections let us capture much more information out of the box and can even be customized! We can add more fields, however you should always keep in mind that Connections are a general concept. If we have 10 different relationships we’d like to manage with this feature and define 1-2 fields for each, the user will simply be overwhelmed by the options presented on the form.

There are some parts in the OOTB experience where MS already customized the experience for the users. The Stakeholders and Sales Team at the Opportunity are such examples. When you select + New Connection at these grids, the Select Records experience will open, you choose the Contact/User and the Connection Role will be auto-selected for you.

When you make a custom subgrid for connections on a form, the + New Connection will open a Create Form. Unfortunately for some reason Quick Create is disabled for this table… And this is problematic for the user experience when users need to associate multiple records to the current one. This is also why other authors shy away from using this feature more.

One more note regarding the roles: These can represent concrete concepts, like we see here with a user being the Account Manager of a customer. We could also define the Technical Sales, Escalation Manager and Service Team Members. In an onsite event scenario we could connect Accounts to the Event as Caterer, Light Tech, Security and so on to capture which of our partners participated in the execution.
And the best thing is that these roles can be added to a solution, so we already have an ALM process for such scenarios.

Here we have not that big of a problem with custom logic. Flows can be triggered on create or update of the Connection table and since we know the Ids of the Connection Roles even after deployment, we can even use the trigger filters.

When to use a custom connection table

We can always build something like the Connection ourselves. Just create an table C and put Lookups to the tables A and B on it, create a form and probably a Quick create form and we are done. And because it is that easy, “complex” relationships are often built like this.

But should we? After all this is a significant customization, the resulting tables are not “standard”. There are good reason why projects use these a lot and a big reason is that they are NOT generalized. So when the user opens the form what he sees has a clear purpose, not to few, not to many fields, the Lookups point exactly to the tables he needs for the current process and not half the systems tables. But when we have competent users that know their ways/are able to learn their ways around Connections, in which situations should we still lean towards a custom Connection Table?

Good identifiers are:

You have multiple or complex logic. A custom table just offers clear separation, especially if you need fields for processing states.
You require non general fields for your process. If you do need fields that are specific to one process they will be shown on all Connection records and their forms. Unless you do JS evaluating the connected record types. But that is a quick road to moving away from the standard and doing heavy coding.
You are building a core business process that justifies a customized experience.

I strongly advise you to enable and create a Quick Create Form as this will speed up the association process a lot for the user. To showcase this I created a Sponsor entity that connects an Event to a Contact but also needs to additional information specific to the process (while Amount could be general, Recurring Sponsor is not) and processing information that might be updated or triggers logic (Transaction Complete).

Summary

I think when you started to read the article you already had an idea when to use what. But it’s a good idea to have some clear rules in your head why you choose one thing over another. This makes prior discussions and documentation afterwards much easier.

You should use N:N relationships when you don’t need to capture any additional information on the relationship, you don’t need logic when such an association happens and will likely not need to in the future. Then you get the advantage that it is light in customization, the interface is very clear and users can associate multiple items at the same time.

You should use Connections when the information you need to capture fits the schema of this OOTB table or the use case requires little customization that is of a more generic nature. Custom logic is possible here, but it might become challenging to separate multiple logics on the same table. Users need to associate records one by one. In a system that leverages Connections a lot users have a lot of flexibility in associating records, this may be a good or bad thing depending on your user base.

When you need special fields on the relationship or heavy logic, that’s a sign for custom relationships. Also complex business processes and lack of training for the users might be reasons to choose a custom table for associating two tables. This gives the customizer the most control and isolation but also requires more customization and maintenance. Users will have to associate records one by one.

[VIDEO] Power Platform Learners: Copilot in Power Platform Admin center, New Grid feature, Virtual network in Power Platform & more

Mon, 09 Sep 2024 00:00:00 +0000

The summer season has come and gone, but we still are able to get together and share some ideas and news around Power Platform in our group and I’m really grateful for that!

Check it out here.

[VIDEO] Power Pages Actions - Authorization Configuration Improvements

Sun, 01 Sep 2024 00:00:00 +0000

This time we are discovering some improvements I made to configuring authorization.

Repository Link: https://github.com/Kunter-Bunt/PowerPagesActions

Check it out here.

[VIDEO] Power Platform Learners: How to leverage Security scan in Power Pages?

Thu, 22 Aug 2024 00:00:00 +0000

Security Scan is a new feature checking your Power Page for known security issues. A great tool in our box of quick and easy checkups!

Check it out here.

Power Pages Actions: Pass any Parameter

Sun, 18 Aug 2024 00:00:00 +0000

Previous videos showed passing a string and an entity reference, but the other parameters are missing an explanation. And while for some types, like integer, this might not be needed, but with complex types, like EntityCollection, it’s not that clear. So here is a reference for all possible inputs for Custom APIs and their respective outputs.

Repository Link: https://github.com/Kunter-Bunt/PowerPagesActions

General concepts

The Actions Adapter needs to guess your input, so you will find, that for complex types, there is something chosen to identify them correctly. For example, both OptionSetValue (Picklist) and Money have a Value property in their definition in C#. But how would the Actions Adapter would decide what { Value: 3 } is?* So instead { OptionSetValue: 3 } and { Money: 3 } make for a clear differentiation.

This concept does not apply to the outputs. They are pretty much left untouched and passed as is. So both an OptionSetValue as well as a Money field might be passed back to you as { Value: 3 } assuming you know by the name of the output what field type is behind this.

*: The adapter could evaluate the Metadata to be sure, but that would have a performance impact with additional queries to Dynamics.

Should the automatic parsing fail to recognize a type due to the value matching multiple types (e.g. “5” can be an integer, but also a string), the correct type can be annotated with an @, see the respective section (“Parser overwrite”) for the correct name and this article for more details. Sample:

// likely to be misinterpreted as Integer
var inputs = {
   String: "5"
}
// Will be passed to the Custom API as String
var inputs2 = {
   ["String@string"]: "5"
}

Field Types

For this article, I created a simple Custom API that returns all inputs to the outputs. For every type, there was an input and output defined named like the type. So both the Custom API Request Parameter and Custom API Response Property for the type String are called String.

The following sections will show an example of an input object passing exactly one Custom API Request Parameter and the construction of an output object with the corresponding Custom API Response Property. Some sections may contain additional explanations.

String

var inputs = {
   String: "Hello"
}

var outputs = {
    String: "Hello"
}

Parser overwrite: @string

StringArray

var inputs = {
   StringArray: ["Hello", "World"],
}

var outputs = {
    StringArray: ["Hello", "World"],
}

Guid

If a string is parsable as Guid, it will be converted accordingly.

var inputs = {
   Guid: "00000000-0000-0000-0000-000000000001"
}

var outputs = {
    Guid: "00000000-0000-0000-0000-000000000001"
}

Parser overwrite: @guid

Integer

var inputs = {
   Integer: 1
}

var outputs = {
    Integer: 1
}

Parser overwrite: @int

Float

var inputs = {
   Float: 5.5
}

var outputs = {
    Float: 5.5
}

Parser overwrite: @float

Decimal

To mark something as a decimal, pass it as a string with an “m” at the end.

var inputs = {
   Decimal: "10.4m"
}

var outputs = {
    Decimal: 10.4
}

Parser overwrite: @decimal

Boolean

var inputs = {
   Boolean: true
}

var outputs = {
    Boolean: true
}

Parser overwrite: @bool

DateTime

var inputs = {
   DateTime: "2024-08-03T15:27:41Z"
}

var outputs = {
    DateTime: "2024-08-03T15:27:41Z"
}

Parser overwrite: @datetime

Picklist

Notice here that the required property for the input is OptionSetValue while in the output it is called Value.

var inputs = {
    Picklist: {
        OptionSetValue: 1
    }
} 
// or
var inputs2 = {
    ["Picklist@picklist"]: 1
}

var outputs = {
    Picklist: {
        Value: 1
    }
}

Parser overwrite: @picklist

Money

Notice here that the required property for the input is Money while in the output it is called Value.

var inputs = {
    Money: {
        Money: 7.8
    }
}
// or
var inputs2 = {
    ["Money@money"]: 7.8
}

var outputs = {
    Money: {
        Value: 7.8
    }
}

Parser overwrite: @money

EntityReference

To be recognized as an EntityReference, the properties LogicalName and Id should be present.

var inputs = {
    EntityReference: { 
        LogicalName: "contact",
        Id: "4121902e-0530-ef11-8409-6045bd9e7366"
    }
}

var outputs = {
    EntityReference: {
        Id: "4121902e-0530-ef11-8409-6045bd9e7366", 
        LogicalName: "contact", 
        Name: null, 
        KeyAttributes: [], 
        RowVersion: null
    }
}

Entity

To be recognized as an Entity, the properties LogicalName and Attributes should be present. Id is optional but is displayed here as a common use case.

var inputs = {
    Entity: { 
            LogicalName: "contact",
            Id: "4121902e-0530-ef11-8409-6045bd9e7366",
            Attributes: {
                firstname: "Marius",
                lastname: "Wodtke"
            }
        }
}

var outputs = {
    Entity: {
        Id: "4121902e-0530-ef11-8409-6045bd9e7366", 
        LogicalName: "contact", 
        Attributes: [
            {           
                Key: "firstname", 
                Value: "Marius"
            },
            {
                Key: "lastname", 
                Value: "Wodtke"
            }
        ], 
        EntityState: null, 
        FormattedValues: [], 
        KeyAttributes: [], 
        RelatedEntities: []
        RowVersion: null
    }
}

EntityCollection

To be recognized as an EntityEntityCollection, the properties EntityName and Entities should be present. Entities then contains Entity objects as seen above.

var inputs = {
    EntityCollection: {
        EntityName: "contact",
        Entities: [
            { 
                LogicalName: "contact",
                Id: userid,
                Attributes: {
                    firstname: "Marius",
                    lastname: "Wodtke"
                }
            }
        ]
    }

}

var outputs = {
    Entities: [
        {
            Id: "4121902e-0530-ef11-8409-6045bd9e7366", 
            LogicalName: "contact", 
            Attributes: [
                {           
                    Key: "firstname", 
                    Value: "Marius"
                },
                {
                    Key: "lastname", 
                    Value: "Wodtke"
                }
            ], 
            EntityState: null, 
            FormattedValues: [], 
            KeyAttributes: [], 
            RelatedEntities: []
            RowVersion: null
        }
    ]
    EntityName: "contact"
    MinActiveRowVersion: null
    MoreRecords: false
    PagingCookie: null
    TotalRecordCount: 0
    TotalRecordCountLimitExceeded: false
}

Summary

The Power Pages Actions solution can handle all possible input types. Some types like Decimal might need special handling and complex parameters like Entity need extra care to ensure that the properties are named correctly.

The solution can hand out all possible output parameters. Here the properties are what you would find in C#.

Repository Link: https://github.com/Kunter-Bunt/PowerPagesActions

[VIDEO] Power Platform Learners: Site visibility in Power Pages

Fri, 09 Aug 2024 00:00:00 +0000

This time in the Power Pages Quick Tips Series we discuss the Site Visibility, what is it and when you should use it. Learn about an important feature for your GoLive in less than 10 minutes.

Check it out here.

Timeline Custom Connectors 2: Retrieving Data

Sun, 04 Aug 2024 00:00:00 +0000

The first post just displayed a dummy record, not actually that useful. This time we will integrate an entity that would usually not be a fit for the timeline. I initially wanted to use the opportunity, as seeing the opportunities of a customer in their timeline might be a valid request from a sales organization. But my Development Environments of course can’t install the Sales module, so instead we will show the contacts of the account. Since it’s on the OOTB account form right beside the timeline anyway we can easily verify our results.

A new class

The template already includes webpack, so we can just create a new file (ContactData.ts) with a class that we will include in our MyDataSource with an import statement.

First, we need to retrieve the contacts from Dataverse. We can use Xrm.WebApi.retrieveMultiple for that or use the context given to us in the init method, it also includes the WebApi interface. I will use the context here to showcase its usage and I assume it’s the preferred option by MS (but this is pure speculation because, at the time of writing, there is no best practice communicated).

private async getData(): Promise<IRecord[]> {
    let accountId = this.context.page.entityId;
    let filter = `$filter=_parentcustomerid_value eq ${accountId}`
    let select = `$select=contactid,fullname,modifiedon,emailaddress1`
    let contacts = await this.context.webAPI.retrieveMultipleRecords("contact", `?${filter}&${select}`);
    return contacts.entities.map(this.mapContact);
}

Next, we want to map the returned contact to our IRecord interface.

// In Record.ts
export interface IRecord {
    id: string;
    name: string;
    email: string;
    date: string;
}

// In ContactData.ts
private mapContact(contact: any): IRecord {
    let record = {
        id: contact.contactid,
        name: contact.fullname,
        email: contact.emailaddress1,
        date: contact.modifiedon
    };

    return record;
}

Of course, you could name the properties more similar to the original fields of contact and if you are using earlybounds, you may skip IRecord, since you will have a generated type that you can use. However, in the next code snippet, the data property is a string that we will fill with JSON.stringify. We will need to deserialize this JSON again in other parts of the code, so it’s a good idea to agree on a common ground on what is in the data property and that’s exactly what IRecord achieves.

async getRecordsData(request: IRecordsDataRequest): Promise<IRecordData[]> {
    let data = await this.getData();

    return data.map(this.mapRecord);
}

private mapRecord(record: IRecord): IRecordData {
    let recordData = {
        data: JSON.stringify(record),
        id: record.id,
        sortDateValue: record.date
    };

    return recordData;
}

You can find the full class here.

Changes to MyDataSource

In the original class, the getRecordsData method changes, it will now call our new class and return its results. Notice here, how the results are cached in this.records, getRecordsData is called with every filtering and search action as well and it just makes sense to filter in memory as it will be a smoother experience for the user. I also want to mention that I had trouble with reloading data when filtering, however, the issues of just receiving a never-ending loading icon were not reproducible anymore when preparing this article.

import { ContactData } from "./ContactData";

async getRecordsData(request: IRecordsDataRequest, filter?: IFilterRequest | undefined): Promise<IRecordsDataResponse> {
    this.records = this.records ?? await this.contactData?.getRecordsData(request);

    const response = {
        requestId: request.requestId,
        records: this.records
    }

    return response;
}

Some other parts will also change, for example, I changed the icon to the matching IconOption.ContactEntityIcon, the header of the card will show the name and the body will show the email.

createHeader(recordId: string, data: IRecord) {
    return this.context?.factory.createElement(
        "Label",
        { key: `${this.getRecordSourceInfo().name}_${recordId}_header` },
        `${data.name}`
    ) ?? [];
}

createBody(recordId: string, data: IRecord) {
    return this.context?.factory.createElement(
        "Label",
        { key: `${this.getRecordSourceInfo().name}_${recordId}_body` },
        `${data.email}`
    ) ?? [];
}

You can find the full class here.

The result

If we open an account now, with the form selected where our custom connector is configured for the timeline, the timeline now displays the contacts.

As teased in the beginning, we can nicely see that the results are correct by just comparing them to the related contacts grid on the right.

If you want to take a look at the full code of this sample, check out the DataverseContactData branch.

Summary

Since we don’t need to handle any secrets, showing data from Dataverse in the timeline is straightforward. This can enable you to fulfill requirements to show data in the timeline which usually would not be a fit for example because it’s not an activity entity. You should of course question the requirement, is it really needed? Because we need to invest time coding the connector and will have future costs for maintaining a custom component. Right now, this simple sample is already 150 lines of code, and we haven’t handled any filtering yet. However, sometimes there are strong business reasons to not use a standard grid and then we have a great tool in our toolbox.

For showing custom data, add a class/method to the template to retrieve the data using WebApi.retrieveMultiple. Next, map the data to an interface like IRecord and serialize the records to the IRecordData interface. Return these serialized records from the getRecordsData. You will receive them back in getRecordUX where you may deserialize your records again and build a card form showing the data, comprising of header, body and footer.

[VIDEO] Power Platform Learners: How to Set up the Google Identity provider in Power Pages?

Fri, 02 Aug 2024 00:00:00 +0000

Power Pages has multiple Identity providers for handling Authentication and Google accounts can be used as such. Learn here how to set it up to enable login with a Google account to for example allow your customers to login to your Power Page.

Check it out here.

[VIDEO] Power Platform Learners: Highlights from Wave2 2024

Mon, 29 Jul 2024 00:00:00 +0000

New wave, new Power Platform Learners. Everyone picked their favorite feature(s) of the wave update. And because we are so diverse those features are distributed across Sales, Service, Copilot and Power Pages, so a colorful bouquet for you to choose from.

Check it out here.

[VIDEO] Power Platform Learners: Disable anonymous access on Power Page

Thu, 25 Jul 2024 00:00:00 +0000

“Disable anonymous access”, a feature easily misunderstood by reading the title. After you enable this, anonymous users will still be able to access the site, but they won’t be able to read data from Dataverse. Learn more in this Power Pages quick tip.

Check it out here.

Timeline Custom Connectors 1: Basics

Sun, 21 Jul 2024 00:00:00 +0000

Did you know you can bring your own data to the Dynamics timeline component? In general, the timeline is quite powerful with its configuration options in a no-code scenario already. But it’s also limited to the standard entities of the timeline: Notes, Posts and Activities. With these, we can work around, e.g. inserting posts for the creation of another entity or just defining an entity as an activity in the first place.

But sometimes this is not feasible, e.g. due to the security setup with activities or you are working with external data that you prefer to not persist. A good example is news articles. They just have less footprint in the system if they are queried the moment the seller opens the Account and compared to a nightly creation of post records, the news will always be up to date.

The Feature

But getting there will be quite a journey. First of all, I’m talking about a feature Microsoft calls Custom Connectors with the timeline control. This is a high-code extension that you will find in the Advanced section of the Timeline control settings. You enter the unique name of a webresource and the name of the primary class.

This class you are specifying needs to implement a certain interface called IRecordSource which is found in Interfaces.d.ts in the sample linked at the bottom of the article. This requires you to implement 4 (+ 2 optional) methods.

init

This is the first bummer. The sample (at the time of writing) does not include a definition for the given context since the referenced mscrm.d.ts is missing. We will try to fix that later, but you could type it into any here and just save it to a class property/field.

async init(context: any, config?: JSON | undefined): Promise<void> {
    this.context = context;
    this.config = config;
};

The context contains a lot of functions, way too many to list here. But check the template repository linked at the end, the Interfaces.ts contains a partially defined IControlData interface, showing a lot of the capabilities.

Apart from that you have static namespaces like Xrm.WebApi or Xrm.Utility available.

getRecordSourceInfo

This is a very simple function, it just returns an object with a name property, done. No special requirements for the name, but it should correspond to the module aka the connector you are implementing. I’ve used the class name as the default.

getRecordSourceInfo(): IRecordSourceInfo {
    return {
        name: MyRecordSource.name
    };
};

getRecordsData

This function is called onLoad, on refresh and whenever the filters or search is used. It shall return the data based on the filters (if present). Here is the absolute minimal extract.

async getRecordsData(request: IRecordsDataRequest, filter?: IFilterRequest | undefined): Promise<IRecordsDataResponse> {
    this.records = this.records ?? [{
        id: "1",
        data: JSON.stringify({ name: "Record 1" }),
        sortDateValue: new Date()
    }]; 

    const response = {
        requestId: request.requestId,
        records: this.records
    }

    return response;
}

We will cover an actual sample in the next article about displaying data.

getRecordUX

This function is called for every record you return from getRecordsData. Here you transform the data into something displayable in the timeline. Important parts are Header, Body and Footer, composing the information in the card, an icon and the sortDateValue for ordering.

No code sample here, we cover this in the next article about displaying data. But the template contains the necessary parts for this in this class.

Also, you can add commands to each record, which is probably another topic in itself, so expect this series to grow quite a bit.

getFilterDetails

This function gets passed in the filters and shall return the (possibly manipulated) filters. Manipulations might for example be altering an existing filter by adding an option or creating a new filter that fits your extension.

Implementing this is quite complex since you need to consider the existing filters, need to prevent illegal combinations and calculate the count of records matching a filter in combination with all already selected filters. We will have to cover this in a dedicated article, but at least this is one of the optional functions, so we can just ignore it for now.

getRecordCreate

This function controls what is being shown at the + for creating new records. The objects you return contain an onClick function that is executed as soon as the added option is clicked. You only need to implement the buttons you want to add, options available by the regular configuration options of the timeline are shown regardless. So if you do not intend to add a button, you may skip the implementation of this function.

There is no code sample here, we will have another dedicated article for it.

The Template

An obvious problem with this feature (at the time of writing) is the lack of samples. The provided samples are compiled already, the definitions are not complete and the docs article lacks explanations on the required functions. I try to fix this on this blog by providing more context around the functions but we will also have samples.

These samples will be built on a template, which is found in this repository. The plan is that the main branch holds the template for easy cloning/forking/copying and each sample receives a separate branch.

Summary

Timeline Custom Connectors are a high-code extension configurable for the Dynamics timeline, shown on forms. It allows for a custom experience of records being shown in the timeline, with no constraint on what is shown, even custom commands are implementable. However, a considerable amount of code is required to leverage these capabilities!

The template in this repository tries to improve your time to “getting started” and you should check the series for more samples. If certain functionality is still missing on this blog you may be able to reverse engineer them from the MS samples.

[VIDEO] Power Platform Learners: Power Pages Authentication Providers

Wed, 17 Jul 2024 00:00:00 +0000

We need to talk about authentication and before we do so, we need to settle on the basics and the authentication providers enabled by default. In this tip, Ambesh takes us through fundamental terms and options.

Check it out here.

[VIDEO] Power Platform Learners: Create Power Pages content with Copilot

Wed, 10 Jul 2024 00:00:00 +0000

In another tip, the Power Pages quick tips series already covered the creation of a website with copilot. But you can also create and edit pages inside the website.

Check it out here.

Service Bus 6: Processing Events with a Function

Sun, 07 Jul 2024 00:00:00 +0000

We already covered a webjob and a plain console app as processors. This time we will take a closer look at Azure Functions. These are interesting as a consumption-based processing option, apart from that you will recognize many of the patterns applied in a webjob.

General preparations

You can find the full project code here.

Something else often forgotten in this kind of article is the description of the used dependencies (here NuGets):

Azure.Messaging.ServiceBus => Definitions of
Microsoft.Azure.Functions.Worker => Bindings to Service Bus
Microsoft.Extensions.Logging => Used for logging output
Microsoft.PowerPlatform.Dataverse.Client => RemoteExecutionContext class for Deserialization

The project

This time, the setup of the project is a little more involved, we have a wizard. The first stages of the project type Azure Functions are as usual, but then we define your first trigger and here we will select Service Bus Topic Trigger.

Again we get started with 2 classes, Program.cs and Function1.cs, I’ll start with Program.cs.

using Azure.Core;
using Azure.Identity;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.PowerPlatform.Dataverse.Client;
using Microsoft.Xrm.Sdk;

var host = new HostBuilder()
    .ConfigureFunctionsWebApplication()
    .ConfigureServices(services =>
    {
        services.AddApplicationInsightsTelemetryWorkerService();
        services.ConfigureFunctionsApplicationInsights();
        services.AddTransient<IOrganizationService>(_ => {
            IConfiguration configuration = _.GetService<IConfiguration>();
            var dataverseUrl = configuration["DataverseUrl"];
            return new ServiceClient(
                new Uri(dataverseUrl),
                async _ =>
                {
#if DEBUG
                    var cred = new VisualStudioCredential(); // DefaultAzureCredential is painfully slow in local debugging.
#else
                    var cred = new DefaultAzureCredential();
#endif
                    var token = await cred.GetTokenAsync(new TokenRequestContext([$"{dataverseUrl}/.default"]), CancellationToken.None);
                    return token.Token;
                });
            });
        })
    .Build();

host.Run();

Notice here how I’ve sneaked an authentication for a managed identity, read more about that here. Apart from adding the IOrganizationService the class stayed as it was set up by the project template.

Next up is Function1.cs.

using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Logging;
using Microsoft.Xrm.Sdk;

namespace DataverseEventProcessorFunction
{
    public class Function1
    {
        private readonly ILogger<Function1> _logger;

        public Function1(ILogger<Function1> logger)
        {
            _logger = logger;
        }

        [Function(nameof(Function1))]
        public async Task Run(
            [ServiceBusTrigger("dataverse", "account-export", Connection = "AzureServiceBus")]
            RemoteExecutionContext message)
        {
            _logger.LogInformation(message.MessageName);
        }
    }
}

This looks pretty similar to what we had with the webjob, the ServiceBusTrigger attribute is registered on startup and connects the function to the service bus. Of course, you may rename the function!

Don’t forget to check the authentication setup for the service bus, it is identical to the webjob. All the other configurations may also be taken from that post, but be aware, that Functions do not support nested configurations, this means we will need to specify our service bus configuration like this "AzureServiceBus__fullyQualifiedNamespace": "mariuswodtke-dev.servicebus.windows.net" in the local.settings.json.

Setting up the Function App

Much easier in this case with the Azure Portal, but surely we will follow up someday with a bicep automation. A special thing here is that the wizard will auto-create 3 more resources, an Application Insights, Storage Account and App Service Plan. The latter might surprise, given that we will host on a consumption basis, but inspecting the App Service Plan reveals, that its SKU Y1 is for consumption purposes. I encourage the consumption here unless there are special requirements because scaling happens based on the number of events, which is perfect for such a service bus use case, where the Function will scale based on the messages ready to process.

Deploying

This works pretty much like the webjob, so I will just run with the pictures for some guidance here.

Result

You can look at the logs via the Overview page of the Function. Besides your function, there is a button Invocations and More, which will take you to the most recent executions. Keep in mind that these are provided through the Application Insights, which means they will be lagging by a few seconds to minutes.

But right now we should not see anything here, even if there are already messages in the service bus. This is because we first need to configure the environment variables.

And from here on out, we will see the same output as the webjob.

Summary

Azure Functions are a great choice for our service bus message processor due to the free quotas, event-based scaling and the good Visual Studio template, which allows for a really short time-to-deployed-prototype. If you are already familiar webjobs, the triggers in functions will be very familiar to you and also setup and deployment is very similar. The big disadvantage historically was that functions only supported .Net Core. But with the general availability of Microsoft.PowerPlatform.Dataverse.Client, that is no longer a problem!

[VIDEO] Power Platform Learners: Using Power Fx in Power Pages

Thu, 04 Jul 2024 00:00:00 +0000

Today Ambesh shows us how to use Power Fx in Power Pages, showing dynamic content on a page.

Check it out here.

[VIDEO] Calling Bound APIs with the Power Pages Actions

Sun, 30 Jun 2024 00:00:00 +0000

This time we are covering how to call bound APIs.

Repository Link: https://github.com/Kunter-Bunt/PowerPagesActions

Check it out here.

[VIDEO] Power Platform Learners: Copilot, Copilot Studio and C# 13 latest updates

Tue, 25 Jun 2024 00:00:00 +0000

The May edition of the Power Platform Learners Group brings some of our favorite features and announcements from MS Build. Lots of it was of course dedicated to Copilot and building our Copilots with Copilot Studio, but for example, I grabbed some of the new features in C# to show and Jörgen had something from Canvas Apps.

Check it out here.

Patterns: Triggering a Flow from the Ribbon (multiple records)

Sun, 23 Jun 2024 00:00:00 +0000

Of course, we can easily boost the productivity of users by letting them apply logic to multiple records at once! Think about the requirement “I need to confirm close to 100 orders per day, it is sufficient to check plausibility in the View, I don’t want to navigate every single order confirming them on the form!”
This sounds like a good fit for our pattern here, the user clicks a button and the Flow connected to it then executes the logic, like firing a FulfillOrderRequest (confused here? Check the previous article). Just that the user would still need to confirm the records one by one from the grid…

Button Visibility

Before we go further with the button functionality I first want to take a little side step that I should have already explained in the last article. You can control when a button is shown based on the amount of records being selected in a grid. This makes sense for the Home Grid button that we implemented last time to just show it if exactly one record is selected. For this article of course we will require at least one selected record. This can be enforced by the Enable Rule SelectionCountRule.

Multiple Selected Records

For selecting multiple records, we first need to make a little change to our JS. It is now possible that the records to update is an array and we need to update for each. I will simply paste the full code here because quite some changes revolve about the handling of the success message, which will only be given once per execution, while errors will be handled one by one.

function TriggerFlow(entityName, entityIds, fieldLogicalName, successMessageForUser, displayDuration, workingMessageForUser) {
    if (!successMessageForUser)
        successMessageForUser = "Operation successfully started!";

    if (!workingMessageForUser)
        workingMessageForUser = "Starting Operation ...";

    if (!displayDuration)
        displayDuration = 5000;

    Xrm.Utility.showProgressIndicator(workingMessageForUser);

    var promises = [];
    if (Array.isArray(entityIds)) {
        entityIds.forEach((entityId) => promises.push(UpdateRecord(entityName, entityId, fieldLogicalName, displayDuration)));
    }
    else
        promises.push(UpdateRecord(entityName, entityIds, fieldLogicalName, displayDuration));

    Promise.all(promises)
        .then(() => {
            Xrm.Utility.closeProgressIndicator();
            GlobalNotification(1, successMessageForUser, displayDuration)
        })
        .catch(() => {
            Xrm.Utility.closeProgressIndicator();
            // No output here, it is done per error
        });
}

function UpdateRecord(entityName, entityId, fieldLogicalName, displayDuration) {
    var updateEntity = {};
    updateEntity[fieldLogicalName] = new Date();

    return Xrm.WebApi.updateRecord(entityName, entityId, updateEntity).then(
        (result) => {
            // No output here, it is done in total
        },
        (error) => {
            GlobalNotification(2, error.message, displayDuration);
        }
    );
}

Also, we have a new optional parameter for the message being displayed in the progress indicator (aka loading spinner), considering that the user might select quite a lot of records, which could lead to a wait time until the success message is visible.

In the Command in Ribbon Workbench, instead of passing FirstSelectedItemId, we can now simply pass SelectedControlSelectedItemIds, the rest can stay identical to the values in the first article.

All (Visible) Records

We can also use the parameter SelectedControlAllItemIds to get all records shown. Notice that in this situation we would configure the button visibility to have a selection of 0 records.

This is of limited use in my opinion because it has rather limited use for the user. He cannot easily exclude records and on the other hand it will also only include the records on the current page. He could achieve the same by using the “Select All” checkbox at the grid and then using the button with SelectedControlSelectedItemIds.

In testing, I’ve noticed that the “New Look” ignores the Records Per Page setting and dynamically renders 50 new records as you scroll down. SelectedControlAllItemIds then returns the first 50 items no matter the Records Per Page setting until you start scrolling, again a very uncontrolled scenario.

All Records

So, let’s discuss a real “All Records” option.

For this, we will leverage the getFetchXml function from the grid client API. We will then have to iterate through all pages and update all records found.

Some more changes:
The optional parameters were consolidated into a single JSON, we just need too many parameters at this point.
This is partly because I also added a confirmation dialog. This is because this potentially enables the user to trigger a Flow on millions of records in a single click, which will likely lead to the flow hitting service limits and starting to throttle, significantly slowing the functionality for all other users as well. “With great power comes great responsibility”. The confirmation shall prevent accidentally missed filters and similar mistakes. And lastly, the retrieveAllRecords is grabbed from MS here.

function TriggerFlowQuery(gridContext, fieldLogicalName, optionsString) {
    var options = JSON.parse(optionsString ?? "{}");

    if (!options.successMessage)
        options.successMessage = "Operation successfully started!";

    if (!options.workingMessage)
        options.workingMessage = "Starting Operation ...";

    if (!options.confirmMessage)
        options.confirmMessage = "Do you want to start the Operation on {count} records?";

    if (!options.confirmTitle)
        options.confirmTitle = "Continue?";

    if (!options.displayDuration)
        options.displayDuration = 5000;

    var entityName = gridContext.getEntityName();
    var fetchXml = gridContext.getFetchXml();

    ProcessAllRecords(entityName, fetchXml, fieldLogicalName, options);
}

function ProcessAllRecords(entityName, fetchXml, fieldLogicalName, options) {
    Xrm.Utility.showProgressIndicator(options.workingMessage);
    retrieveAllRecords(entityName, fetchXml, null, 5000, null).then(
        function success(entities) {
            Xrm.Utility.closeProgressIndicator();

            var confirmStrings = {
                text: options.confirmMessage.replace("{count}", entities.length),
                title: options.confirmTitle,
            };

            Xrm.Navigation.openConfirmDialog(confirmStrings).then(
                function confirmed(success) {
                    if (!success.confirmed)
                        return;

                    Xrm.Utility.showProgressIndicator(options.workingMessage);

                    var promises = [];
                    entities.forEach((entity) => promises.push(UpdateRecord(entityName, entity[entityName + "id"], fieldLogicalName, options.displayDuration)));

                    Promise.all(promises)
                        .then(() => {
                            Xrm.Utility.closeProgressIndicator();
                            GlobalNotification(1, options.successMessage, options.displayDuration)
                        })
                        .catch(() => {
                            Xrm.Utility.closeProgressIndicator();
                            // No output here, it is done per error
                        });
                });
        }).catch(() => {
            Xrm.Utility.closeProgressIndicator();
            // No output here, it is done per error
        });
}

And now the last thing left is to define the command, where we will define SelectedControl this time to provide the grid context.

PowerFX

Can you do something like this with PowerFX as well? At least partly, yes!

So first let’s control the button visibility with

!IsEmpty(Self.Selected.AllItems)

and then we can Patch the selected records with

ForAll(
    Self.Selected.AllItems, 
    Patch('Test Table 2S', ThisRecord, { 'Trigger Field': Now() })
);
Notify("Operation successfully started!", NotificationType.Success, 5000);

Of course, do not forget to replace the entity (‘Test Table 2S’) and field (‘Trigger Field’) with your values.

This only works with the selected records, getting all records or the query of “Self” is not possible to my knowledge.

Summary

From a few to thousands of records, the pattern can scale with some adaptions. Remember that you can use the helper solution to not have to fiddle with code! So the power of this pattern is just one solution installation away. After that, you can start configuring your ribbon command from the Ribbon Workbench.

This pattern can also be used from Modern Commanding, but as usual, this is sadly more limited than the Workbench. Yet still, there are good chances the options of Modern Commanding might be a fit for your requirements.

[VIDEO] Power Platform Learners: How to create Power Pages website using Copilot?

Sat, 22 Jun 2024 00:00:00 +0000

Sweta and Ambesh show you some of the new capabilities of Copilot for Power Pages, creating a starter website with the chat.

Check it out here.

[VIDEO] Power Platform Learners: How to Customize appearances of AI-driven chatbot in the Power Pages?

Mon, 17 Jun 2024 00:00:00 +0000

In this one Ambesh shows the integration of a chatbot from Copilot Studio and how you can change its looks.

Check it out here.

[VIDEO] Using Control Styles in Power Pages

Sun, 09 Jun 2024 00:00:00 +0000

Control Styles can alter the behavior of form fields in Power Pages. Some of them are tailored to gathering customer feedback, but others have a wide range of use cases like “Render Lookup as Dropdown” or “Code Component”.

Check it out here.

Teams Integration: Avoid the Creation Limit

Sun, 02 Jun 2024 00:00:00 +0000

It might be you are here because your users are reporting that they cannot create any new Teams anymore or you followed the post about creating connected Teams with Power Automate and your technical user for the Connection Reference went on strike. Anyhow, here is the solution if there are reports about “AadGroupCreationLimitExceeded”.

Symptom

The Teams integration worked fine, but from one moment to the next, it stopped working, no matter the constellation of data, the user can’t make it work anymore. It even extends to creating a team in Teams itself.

The error messages will contain some reference to “AadGroupCreationLimitExceeded”, for a flow, it might look like this:

{
  "error": {
    "code": "BadRequest",
    "message": "Failed to execute Templates backend request CreateTeamFromTemplateRequest. Request Url: https://teams.microsoft.com/fabric/emea/templates/api/team, Request Method: POST, Response Status Code: BadRequest, ErrorMessage : {\"errors\":[{\"message\":\"Error when calling Middle Tier. Message: ''. Error code: 'AadGroupCreationLimitExceeded'. Status code: BadRequest.\",\"errorCode\":\"Unknown\"}],\"operationId\":\"abcd\"}",
    "innerError": {
      "code": "BadRequest",
      "message": "Failed to execute Templates backend request CreateTeamFromTemplateRequest. Request Url: https://teams.microsoft.com/fabric/emea/templates/api/team, Request Method: POST, Response Status Code: BadRequest, ErrorMessage : {\"errors\":[{\"message\":\"Error when calling Middle Tier. Message: ''. Error code: 'AadGroupCreationLimitExceeded'. Status code: BadRequest.\",\"errorCode\":\"Unknown\"}],\"operationId\":\"abcd\"}",
      "details": [
        {
          "message": "Error when calling Middle Tier. Message: ''. Error code: 'AadGroupCreationLimitExceeded'. Status code: BadRequest.",
          "target": "Templates"
        }
      ],
      "date": "2024-05-14TXX:XX:XX",
      "request-id": "00000000-0000-0000-0000-000000000000",
      "client-request-id": "00000000-0000-0000-0000-000000000000"
    }
  }
}

Cause

There is a limit of 250 Entra Id objects that can be created by a single user. Every Teams Team creates a group in Entra, which is counted as an object. So as soon as you create 250 (or less if you also created other objects) Teams, you cannot create any more.

Resolution

You could get off this limit by deleting some Teams, but since they are soft deleted, they are still counted to your quota until they are finally gone after 30 days. Quite some time to wait if you hit the limit…

And especially with a technical user for a Power Automate Flow, deletion will simply not be possible, since there might be more than 250 Teams needed, so we need something different.
One option could be the Teams Service Administrator role that you could assign to the technical user as [described here](https://medium.com/365uc/non-admin-users-cannot-create-more-than-250-teams-8ce20f0d9bb2#:~:text=new%20roles%2C%20the-,Teams%20Service%20Administrator%20role,-includes%20(amongst%20other).

If this is too many privileges for an enterprise scenario there is also a specific privilege for this 250 objects limit. Microsoft describes this for users hitting this limit with creating AppRegistrations, so I won’t reiterate the process here. You will just need to replace the mentioned privilege (microsoft.directory/applications/create) with the microsoft.directory/groups.unified/create privilege.
This custom role is also more suited if regular users hit this limit in their daily jobs, as the Teams Service Administrator is overkill in this situation.

Summary

Depending on how many Teams you create, some users or a technical user might be hitting a limit once they created 250 Teams. This is not a Teams limitation but an Entra Id limitation for non-administrative users and shows by the error “AadGroupCreationLimitExceeded”. It can be resolved with administrative privileges, e.g. Teams Service Administrator or with a custom role containing the privilege microsoft.directory/groups.unified/create.

I hope this helped you, but before you go, just think about one more thing, there are more limits! In total Entra Id has a limit of 300.000 objects (if you have a domain), will you hit that once you remove the create limitation on the users? Likely not, but it’s not a bad idea to reason and make some estimates to avoid this greater limit. Maybe you need to think about a deletion strategy.

Sharepoint Integration (Standard) 5: Viewing Parents Documents

Sun, 26 May 2024 00:00:00 +0000

This article might sound like a very particular requirement, but I’ve heard it for the second time now: “The user should not need to navigate to the parent to work with its documents”.

There are usually more questions involved like “Should this work like a hierarchy?” or “What does he need to do? Does he need to see the same documents at the parent?” but if it’s really the flat and the same documents, there is an easy solution.

Options

The obvious choice might be a Quick View form. If you were not aware: Quick View forms can show Subgrids! So we can include a Subgrid to the Sharepoint Documents table and define this as the only component of a “Files Quick View” form that we will include in the child records form.

But here we have the problem that the New and Upload Buttons are missing as with other Subgrids included in a Quick View form.

The better option here is the Form Control Component which is a PCF by Microsoft that works similarly to a Quick View but allows editing the record shown.

There is also a disadvantage: The form shown needs to be a Main Form and it needs to be part of the app and be available to the user by security. This means our “Files” form will be selectable in the form picker of the parent table.

This way we can have the full experience of files, with upload and document location actions etc. Great!

One More Trick

Have you noticed that the screenshots of the result included the folder breadcrumbs? That’s a little trick I’ve found by looking at what Microsoft does with the “Files” Tab for example at the Lead. I was not able to recreate the same experience on a custom entity and found that they used the Document Associated View. Up above you see that this view can not be selected for a Subgrid, but apparently, some of the integration experience is implemented into that view.

To fix this for our custom forms and entities we can manipulate the XML.

Put the form with your Files Subgrid to a new solution.
Export the solution.
Unzip the solution to a local folder.
In the Customization.xml, find the place where the Subgrid is defined.
Replace the ViewId with 0016f9f3-41cc-4276-9d11-04308d15858d (or determine it with the screenshot seen below)
Save the file.
Rezip the (3) files inside the local folder.
Import the resulting zipped solution.

Summary

While you can certainly use the knowledge from the inner workings article to replicate document locations to child records, sometimes it’s just easier to directly display the documents of the parent.

To use this, first create a main form on the parent table that only shows a grid to the Sharepoint Documents. Then you bring a second lookup to the parent to your child tables form and use the Form Control Component Custom Control on the field. Next, we publish and are ready to even upload documents from the child entity using the subgrid on the form.

[VIDEO] Authorization with the Power Pages Actions Solution

Sun, 19 May 2024 00:00:00 +0000

This time we are covering authorization.

Repository Link: https://github.com/Kunter-Bunt/PowerPagesActions

Check it out here.

[VIDEO] Power Platform Learners: Powerpages Omnichannel

Mon, 13 May 2024 00:00:00 +0000

This time it’s Sweta, bringing in a demo for Omnichannel integration with Power Pages.

Check it out here.

Patterns: Triggering a Flow from the Ribbon (single record)

Sun, 12 May 2024 00:00:00 +0000

Just like the first pattern we discovered, the core of this pattern includes a Flow that is triggered by a DateTime field being set. The requirement sounds like this “When the user clicks the button X, logic Y should run” and Y here is a logic that either requires the Server due to privileges etc. or is just complex enough that you wouldn’t want to implement it in the frontend, e.g. as PowerFX directly to the button. Considering the debuggability of PowerFX in the ribbon (aka Command Bar), that point for me is reached quite quickly. I might then resort to JS, but in the low code era, it might be much easier to do it in a Flow.

To have a concrete sample you would implement like that: “After adding the necessary information, the user needs to send the record for approval”. The Power Automate Approvals are best used from Power Automate, so we would like to trigger our flow from a ribbon button “Send to Approval”.

Backend Setup

For that, we first create a DateTime field, user local, on our table. Then we define a Flow with the Dataverse trigger, (Added or) Modified targeting the table and choosing the newly created field in the Select Columns option.

Anything aside the trigger is now tuned to your logic X.

Why DateTime?

For the trigger field, we are using a DateTime because it is the most logical for a generalization:

Boolean will be set to yes on the first execution, and on the second? Even if you force another Update to yes, this will not show up in Audit History.
Choices have a similar problem.
Lookups are harder to set, and there is no natural value to generalize, only in certain cases this might make sense, but still has the problem of the second execution.
String fields work better with changing strings since this will at least show up in Audit, but for generalization, only random strings would make a good fit.
Numbers are more interesting since you can simply count how often the button was clicked! And this makes sense if you need that reporting and don’t want to use the Audit History to count manually. They are just a little more complicated to implement because you first need to retrieve the current value of the field, coalesce it with a 0 and then set it. If the field is not on the form, we will even need nested deferreds for that.
DateTimes provides a timing of the last execution even without Audit History and there is a natural way of setting it via the native functions of JS (new Date()) or PowerFX (Now()).

Frontend Setup

Here we have 3 possibilities. And cover each one of them with a short code sample.

We can bring the field to the form and the button sets it and optionally directly saves the record (we could also leave this up to the user, but that could lead to confusion).

function TriggerFlowFormOnly(formContext, fieldLogicalName, messageForUser, displayDuration) {
    if (!messageForUser)
        messageForUser = "Operation successfully started!";
    
    if (!displayDuration)
        displayDuration = 5000;
        
    formContext.getAttribute(fieldLogicalName).setValue(new Date());
    
    formContext.data.save().then(
        (result) => {
            GlobalNotification(1, messageForUser, displayDuration);
        },
        (error) => {
            GlobalNotification(2, error.message, displayDuration);
        }
    );
}

function GlobalNotification(level, messageForUser, displayDuration) {
    var notification = {
        level: level,
        message: messageForUser,
        showCloseButton: true,
        type: 2
    };

    Xrm.App.addGlobalNotification(notification).then(
        (id) => {
            window.setTimeout(ClearGlobalNotification.bind(this, id), displayDuration);
        }, 
        (error) => { console.log(error); });
}

function ClearGlobalNotification(id) {
    Xrm.App.clearGlobalNotification(id)
}

To call this, pass the CRM Parameters for the formContext (primaryControl), the fields logical name and optionally parameters for the message text and display duration. The values in the screenshot are taken as default if you skip them.

We can also update the field through the OData Web API. This does not require the field to be on the form and it’s also possible to use on a View! However, since it needs an Id to update the record, it will only work after the first save of the record!

function TriggerFlow(entityName, entityId, fieldLogicalName, messageForUser, displayDuration) {
    var updateEntity = {};
    updateEntity[fieldLogicalName] = new Date();
    
    if (!messageForUser)
        messageForUser = "Operation successfully started!"
    
    if (!displayDuration)
        displayDuration = 5000
        
    Xrm.WebApi.updateRecord(entityName, entityId, updateEntity).then(
        (result) => {
            GlobalNotification(1, messageForUser, displayDuration);
        },
        (error) => {
            GlobalNotification(2, error.message, displayDuration);
        }
    );
}

// Find the GlobalNotification function in the code block above

This time we will need to pass the logical name and record id. The other parameters for the field logical name and the optional message and duration stay the same.

And the third way is of course leveraging the modern commanding with PowerFX. This will internally work very similarly to Xrm.WebApi.updateRecord, meaning it works from views and on forms without the field present.

Patch(Demos, Self.Selected.Item, { 'Trigger Field': Now() });
Notify("Operation successfully started!", NotificationType.Success, 5000);

Helper Solution

And of course, we can also trigger the JS functions from the modern commanding as well since it can simply call WebResource functions. And this is where the helper solution for this article comes in! With this, you can call a flow from the ribbon without writing a single line of code (be that JS or PowerFX) and without leveraging third-party tools like RibbonWorkbench. Simply install the solution, edit the command bar of your table, set the button’s action as shown below, publish and you are ready to go.

Summary

Users like ribbon functionality and low code developers like Power Automate Flows. To bring both together we will filter our flow trigger to a DateTime field and then define a ribbon button that has exactly one purpose: Setting that field.

With the help of the RibbonHelpers solution, this can be done without writing a single line of code. Or you could also do it with one to two lines of PowerFX!

The low complexity and wide possibilities in Power Automate are why this has become my favorite way of implementing ribbon functionality.

Patterns: Deferring Flows with the Trigger

Sun, 05 May 2024 00:00:00 +0000

Have you tried the Delay Until option of the Dataverse trigger in Power Automate? If not, I will show you some useful knowledge about that field, variations of usage and a workaround.

For the story: We want to send out a notification when the Due Date (scheduledend) of a task approaches. Hitting the correct timing is possible in many ways, but Delay Until can be very elegant!

Using Delay Until Trigger

If you just have a simple field that marks the execution time, it’s simple, just enter the logical name. If it’s more complicated, you are out of luck at first, since you cannot use any outputs of the trigger for calculating the delay in an expression. We will try to cover that in the next sections.

Oh, and a bonus: If Delay Until is in the past, it will be evaluated as an immediate execution, so we do not need to worry about that.

Business Rule for calculation

But for the story, it would be nice if the reminder is not right at the deadline but sometime before! So we need to deal with that and that will be calculating the correct time for the reminder in a separate field. Our first attempt with Business Rules shows a weakness in the Formulas of Business Rules: They can only add/subtract days. This will work here if the requirement is “send the reminder 1 day before due”, but not if it is “send the reminder 12 hours before due” because the formula for adding days only allows whole numbers.

Of course, any other method of writing a field with the correct value would work, e.g. Flow, Plugin and JavaScript will work as well, but will add complexity.

PowerFX and calculated columns

Our next attempt will be with calculated columns, with the modern PowerFX ones and a classic field. Both have a problem: While they are more flexible than the Business Rule formula, the resulting field does not work with Delay Until! But we can still work around it.

So first of all, the idea is we subtract one hour from the Due Date and trigger on Due Date since you cannot trigger on calculated fields.

Pretty much the same happens with a classic calculated column.

Delay Until Action

How can we still make it work? There is also a Delay Until action in Power Automate! And since the fields are in the trigger output we can directly feed them to this action.

The flow will now wait for the given timestamp and then will resume execution. But of course, since this is in the flow execution, we might as well just calculate an expression, skipping the PowerFX/calculated field after all.

Trigger vs. Action

If the action is more flexible here, why should I bother with the trigger option at all? Well, there are three considerations why I think the trigger option is better.

Number one, the trigger outputs are calculated upon start. In the sample of the due notification, you want to check if the task is not already closed by the time the flow is about to send it. With the trigger option, you have the correct values, if you used the actions to wait for days probably, you will want to re-retrieve the task to check for its state, introducing an inefficiency.

Second is the long runs. If you are using the action, run duration is now dominated by the Delay Action, making it hard to determine how long the runs take in terms of real operating time. Also, you might have a long list of runs that are all running, while with the trigger option, the whole monitoring looks exactly like a flow that has no waiting conditions at all.

And third, you might run into the 30-day flow timeout. In our story, if the Due Date is in 45 days, no one will get a notification if you used the action, since the flow will have timed out. With the trigger option, it will run right on time (if the flow was turned on when the change event happened as well as on the target time).

Summary

Let’s summarize.

Prerequisites:

You have a clear idea of when the Flow actions shall execute.
You can PERSIST that DateTime to a Dataverse field.

Action:

Enter the logical name of the field that holds the target execution time to the Delay Until option of the Dataverse Trigger.
(Optional) Add a condition that the field should not be empty into the Filter Rows option to prevent immediate execution.
(Optional) Add the logical name of the field to the Selected Columns option to limit the pileup of executions due to other changes in the meanwhile.
Add an internal condition to check the deferral time to prevent early execution when the target time was moved while the Trigger delayed the execution.

With these in place, you can get around ugly solutions like polling (Scheduled Trigger) and busy waiting (Delay Until Action). It will result in short flow run durations, will not introduce inefficiencies due to re-retrieving and even can break the 30-day barrier of flows.

[VIDEO] Power Platform Learners: How to integrate SharePoint in the Power Pages?

Fri, 03 May 2024 00:00:00 +0000

Following up on the video about hierarchical permissions, this time we will integrate Sharepoint for storing files from a Power Page.

Check it out here.

[VIDEO] Power Platform Learners: Business Applications launch event highlights

Thu, 02 May 2024 00:00:00 +0000

In the April edition of the Power Platform Learners Group, we got some updates from the Business Applications launch event which was all about Copilot. I’ll admit, I had not attended and jumped in with a really quick tip from my blog.

Check it out here.

[VIDEO] A solution for calling Custom APIs from Power Pages

Sun, 28 Apr 2024 00:00:00 +0000

Repository Link: https://github.com/Kunter-Bunt/PowerPagesActions

Check it out here.

Help, my Duplicate Detection isn't firing!

Sun, 21 Apr 2024 00:00:00 +0000

Your duplicate detection (DD) isn’t working, now what? As with every problem, stay calm and we’ll work our way through all the reasons why it might not be working. Well, at least all the reasons I know.

Duplicate detection is disabled

You will find this setting in Advanced Settings > Data Management > Duplicate Detection Settings. You will want to make sure that the whole feature is enabled and your respective suboperation where you expect DD to be performed.

Rule not published

Your rules are found in Advanced Settings > Data Management > Duplicate Detection Rules. Check that the rules that you want to apply are published and any other rule is unpublished. Notice that DD rules are unpublished upon deployment if they are included in the imported solution! That might be the reason why you have regular problems with unpublished rules.

Rule can not be published

There is a limit of 5 rules per entity on duplicate detection rules. So if you hit this limit, the publish will fail and you will need to deactivate another rule on the same entity.

Rule options not correct

Case Sensitivity and Exclude Inactive Records can severely limit the results. Think about the lead here, qualified or disqualified leads will not be taken into account.

DD does not work on activation

Especially if you use Exclude Inactive Records you might expect the records to be checked upon activation. But sadly I have to tell you that there is another limitation, DD does not work on activate/deactivate.

Wrong field Display Name

Harder to spot is this one: You might have selected the wrong field because you have renamed the field on the form. So the Display Name of the field on the form might be City in a section called Billing Address, you select it in the DD rule criteria and it does not yield the expected result. To check this, I would suggest going to the customizations, opening the form, then selecting the field and opening the column behind it, to check its display name.

Duplicate Display Name

It gets nasty if in the situation above you have actually changed the display name of both Address 1: City and Address 2: City to City. They will be differentiated on the form through their respective section, but in Advanced Find, Power Automate and other places you won’t be able to do so. That’s why it’s generally not a good idea to name 2 fields the same outside of forms, but it’s manageable through trial and error still.

However, DD takes that up a notch: In that situation, the display names in the selection get cleared of duplicates (ironic, I know) and thus, only one of the 2 City fields is shown. And what you select then is pure luck. So simple rule: If you want to use a field with DD, you can’t have a second field with the same display name!

Summary

I hope one of these causes hit your problem, if not, I can only wish you good luck with your further search. Remember that you also can open a ticket with Microsoft support, they are often very helpful with their insights from the backend.

[VIDEO] Power Platform Learners: Hierarchical Table Permissions in the Power Pages

Thu, 18 Apr 2024 00:00:00 +0000

This time we have a little demo for you on how File Attachments can work in Power Pages, for that we will need hierarchical site permissions.

Check it out here.

Showing Notifications from Frontend and their UX

Sun, 14 Apr 2024 00:00:00 +0000

We have several options for notifying the user of something from the frontend. However, the Client API documentation does not picture many of these ways. So this post shall work as a reference for discussions, since it takes time to prepare a demo, especially if the business has no previous experience and needs all the options. Please note that In-App Notifications are missing! This is because I don’t think this should be a tool for the frontend but rather for the backend.

Setup

To demonstrate the methods, I’ve set up ribbon buttons on a custom entity in a custom app. Then I recorded a short gif of each method. The following sections will consist of a short explanation, a code sample and those videos. A short tip for the gifs: If they look a little bit grainy on your browser, you can click on them to enlarge them to the native resolution.

If you want to have a closer look, check the accompanying repository. For a quick look and feel I recommend the managed solution as it can be uninstalled cleanly after your experiments.

Form Notifications

The name suggests it, these are for the form. Therefore to show this, a formContext is needed. Alongside the message to show and a level that determines the color (INFO, WARNING or ERROR), there is also an identifier that can be used to remove the message again. In the code below this is done after 5 seconds.

// level: INFO | WARNING | ERROR
function FormNotification(formContext, level) {
    formContext.ui.setFormNotification(`Hello from ${level} Form Notification`, level, "formNotification");
    window.setTimeout(ClearFormNotification.bind(this, formContext), 5000);
}

function ClearFormNotification(formContext) {
    formContext.ui.clearFormNotification("formNotification");
}

Be careful, if you are planning multiple notifications on the same form, as soon as you have two, they will be folded. And while the top level keeps the color of the highest level, the unfolded notifications are gray and the level is only shown in the icon, making it harder to differentiate them.

Global Notifications

Compared to a form notification, a global notification is shown on the whole app, it will span wider across the navigation and above the ribbon. It also has more options! We can include an action button and a close button and also have an additional notification level of SUCCESS.

You will notice that the code is more involved, simply because there are more options and the identifier of the notification is not passed by us but is returned in the deferred. Again, I’ve included a sample to auto-remove the notification after 5 seconds.

// level: 1: SUCCESS | 2: ERROR | 3: WARNING | 4: INFO
function GlobalNotification(level) {
    var notification = {
        action: {
            actionLabel: "Visit Google",
            eventHandler: () => Xrm.Navigation.openUrl("https://www.google.com/")
        },
        level: level,
        message: "Hello from Global Notification",
        showCloseButton: true,
        type: 2
    };

    Xrm.App.addGlobalNotification(notification).then(
        (id) => {
            LogNotificationResult("Message set: " + id);
            window.setTimeout(ClearGlobalNotification.bind(this, id), 5000);
        }, 
        LogNotificationResult.bind(this, "Message error"));
}

function ClearGlobalNotification(id) {
    Xrm.App.clearGlobalNotification(id).then(
        LogNotificationResult.bind(this, "Message cleared"), 
        LogNotificationResult.bind(this, "Message clear error"));
}

function LogNotificationResult(message) {
    console.log(message);
}

Another important differentiation is the fact, that global notifications will persist a navigation, so if the form is closed, the notification stays.

Also, no formContext is needed, making this suitable for views and “global” scripts. In combination with the action button, you could for example guide a user from a view to a certain record. Or, to be quirky: You create an enable rule on a button in the application ribbon that monitors the database (via Xrm.WebApi) and if a certain state is detected, suggests the user an action. E.g. “Your weekly report is ready! [Go to Report]”. But before you consider that, also look for the In-App Notifications, which could be triggered from the backend as soon as the report is ready. The only disadvantage with those is the fact that they can take some seconds to show up, so they are not real-time, more like the same minute.

Here, the same thing regarding folding applies as with the form notifications, as soon as there are two global notifications are shown, they will fold. Note, that it is possible to show one form and one global notification without a folding happening.

Field Notifications

Next up are notifications for specific fields. Consider something like “The combination of values for these 2 fields is not allowed”. There are 2 types, one for the control, and one for the attribute. Both will block saving (in contrast to the other errors we showed before). I do prefer the notification on the control since it provides immediate feedback to the user. But maybe you want to prevent exactly that and defer the error to saving, assuming the user will correct the error on his own anyway…

In terms of coding, the control notification is pretty similar to the form notifications we’ve already seen, there is just no level, it’s always ERROR. The attributes method setIsValid is different in that there is no id for the notification, there can only be one per attribute, and it’s either valid or not.

function AttributeValidation(formContext, valid) {
    formContext.getAttribute("mwo_name").setIsValid(valid, "Hello from Attribute Validation");
    window.setTimeout(AttributeValidation.bind(this, formContext, true), 10000);
}

function ControlNotification(formContext) {
    formContext.getControl("mwo_name").setNotification("Hello from Control Validation" , "controlNotification");
    window.setTimeout(ClearControlNotification.bind(this, formContext), 5000);
}

function ClearControlNotification(formContext) {
    formContext.getControl("mwo_name").clearNotification("controlNotification");
}

Dialogs

Dialogs are very “in your face”. Which can be good or bad of course. Alert Dialogs have exactly one button to close them, Confirm Dialogs have two options and we can determine which one the user clicked. Error dialogs have 2 variants, one with an error code, and one with a custom message. The error codes receive their text from a predefined list of MS, so this is especially useful if you want to pass on an error you received from the backend. For all other types of errors, you can use a custom message. You can also provide details, which will be part of the downloadable log.

Note that dialogs can’t be closed by code, they are designed to be dismissed by the user.

function AlertDialog() {
    var alertStrings = { confirmButtonLabel: "OK", text: "Hello from Alert Dialog", title: "Dialog Title" };
    var alertOptions = { height: 120, width: 260 };
    Xrm.Navigation.openAlertDialog(alertStrings, alertOptions).then(
        function (success) {
            console.log("Alert dialog closed");
        },
        function (error) {
            console.log(error.message);
        }
    );
}

function ConfirmDialog() {
    var confirmStrings = { cancelButtonLabel: "Skip", confirmButtonLabel: "OK", text:"Hello from Confirm Dialog", title:"Dialog Title" };
    var confirmOptions = { height: 200, width: 450 };
    Xrm.Navigation.openConfirmDialog(confirmStrings, confirmOptions).then(
    function (success) {    
        if (success.confirmed)
            console.log("Dialog closed using OK button.");
        else
            console.log("Dialog closed using Skip button or X.");
    });
}

function ErrorDialogCode() {
    var errorOptions = { errorCode: -2147135487, details: "Details from Error Dialog" };
    Xrm.Navigation.openErrorDialog(errorOptions).then(
        function (success) {
            console.log(success);        
        },
        function (error) {
            console.log(error);
        });
}

function ErrorDialogMessage() {
    var errorOptions = { message: "Hello from Error Dialog", details: "Details from Error Dialog" };
    Xrm.Navigation.openErrorDialog(errorOptions).then(
        function (success) {
            console.log(success);        
        },
        function (error) {
            console.log(error);
        });
}

If you download the logs, it will contain the error details you passed to the function.

Exception Message: -2147135487

ErrorCode: -2147135487
HexErrorCode: 0x80055001
Error Details: Details from Error Dialog

Activity Id: f42dc166-c52b-4841-a01e-298afff445a1

PowerFX (Modern Commanding)

And finally PowerFX. This became relevant with modern commanding, where you can create ribbon buttons with a Low Code approach. This has only one option, Notify. This is optically translated to a global notification but does not have all its parameters. It only has a message, level and a timeout can be passed.

// NotificationTypes: Success, Error, Warning, Information
Notify("Hello from PowerFX", NotificationType.Information, 5000)

Summary

While our options with JavaScript are numerous, PowerFX is rather limited in terms of notifying the users. However, it’s only available in the ribbon right now and not for form scripting, so this is not that big of a deal. If you need more flexibility, use JavaScript, here you can not only show notifications on the app level but also the form and field level, additionally, dialogs can be used as a hard prompt to the user.

I hope this helps you imagine the user experience you want to provide, have a nice refinement!

[VIDEO] Power Platform Learners: Virtual Tables in Power Pages

Mon, 08 Apr 2024 00:00:00 +0000

What hasn’t worked on the first try in the group presentation is picked up by Sweta in the Power Pages Quick Tips series, showcasing the integration of external data with Virtual Tables.

Check it out here.

[VIDEO] Creating Authentication Tokens with Power Pages

Sun, 07 Apr 2024 00:00:00 +0000

JSON Web Token allows for Authentication and Authorization with WebServices. For example, the Dataverse Web API can leverage such a tokes (with the Dataverse audience) to determine what you can read. With Power Pages, we can also create such tokens as well to secure our custom services. We only need a trusted certificate and an App Registration.

Check it out here.

[VIDEO] Power Platform Learners: Know more about Power Platform Administration and Power FX in Desktop Flows

Tue, 02 Apr 2024 00:00:00 +0000

The March edition of the Power Platform Learners group! My contribution this time was around an admin center setting that will influence the behavior on the creation of Customer Addresses, preventing the creation of empty ones.

Check it out here.

My First Shot at PCFs with React

Sun, 31 Mar 2024 00:00:00 +0000

Did you know there is a preview for using React in Code Components (aka Power Apps Component Framework, PCF)? Well, I recently received training on using React natively so I thought this is a great opportunity to consolidate my knowledge.

I plan to broaden the topic around VIES VAT, so this experiment will contain a new PCF that shall do the same thing as the original VAT Number Validator just for Power Pages.

Full example

Please note that this is a first shot, the actual validation part is mocked at this stage, we will worry about CORS and calling VIES VAT in another article.

Therefore the code at this stage has received a separate branch, so make sure to view the branch my-first-shot/react-pcf when comparing your solution.

Setup

As this is a preview feature, keep a close eye on the official documentation, the parameters might change!

To create my control I’ve used pac pcf init --name PowerPagesVatNumberValidator --namespace PowerPagesVATNumberValidatorNameSpace --template field --framework react --run-npm-install.

You can also shorten the parameter names to pac pcf init -n PowerPagesVATNumberValidator -ns PowerPagesVATNumberValidator -t field -fw react -npm.

The main difference here is the --framework or -fw parameter, making it a React component.

Note: You cannot have a .gitignore in the folder where you are executing the pac pcf init command, if you have, you will receive an IO error.

Other commands you might need are npm run refreshTypes after you changed the ControlManifest.Input.xml, pac solution init --publisher-name MariusWodtke --publisher-prefix mwo to create a new Solution locally and pac solution add-reference --path ..\ to add the .pcfproj file as a reference to your solution. If you now dotnet build your solution, the PCF will also be built and included in the solution. To test locally, npm start watch launches a sandbox in the browser to quickly test changes. Please note that not all features of PCF are supported in the sandbox, for example, I noticed that getResource does somewhat work, but hands out undefined as the requested content. Also, remember that when deploying the built solution to Dataverse you will need to increase the version of the control node in the ControlManifest.Input.xml, otherwise Dataverse won’t pick up the changes.

The component

A lot of the magic of the VAT Number Validator happened in index.ts, this will be much different even in the easiest React controls because you want to work in .tsx files instead. I named my entry-point Control(.tsx) in correlation to the convention for App(.tsx) as the entry-point for native apps. The index.ts will call this entry-point and pass along some needed objects, like the input parameters and a function that will ultimately call notifyOutputChanged to persist the calculated results to the actual form field. In contrast to classic PCFs this happens in the updateView method which looks like this in my case:

public updateView(context: ComponentFramework.Context<IInputs>): React.ReactElement {
    const props: IControlProps = {
        context: context,
        outputChanged: (outputs) => this.outputChanged(outputs),
    };

    return React.createElement(
        Control, props
    );
}

private outputChanged(outputs: IOutputs){
    this.outputs = outputs;
    this.notifyOutputChanged();
}

public getOutputs(): IOutputs {
    return this.outputs;
}

So, updateView creates the root React element and passes the context with the inputs. The React element passes back the outputs, should the user input something into the field this is persisted in the form via notifyOutputChanged.

Now I can use my Control.tsx to define the elements that are rendered inside. I want to mention the concept of useState: It returns a getter and a setter. And when a component uses the getter it will be rerendered every time the setter is called. So in the following sample, when vatStates.img is set asynchronously after the correct image is determined and loaded, the img element will be refreshed automatically.

<img 
    src={vatStates.img} 
    className='pcfvatimage'
/>

The variable vatStates is already a complex object here, as I prefer to extract the handling of multiple states to a separate class with hooks. The hooks in the sample are stored in the /services folder and have the use-prefix as a convention for the public methods. If you take a closer look at the vathooks.ts you will notice that the actual validation only looks for the user input starting with “AT” for marking it as valid. That’s of course not correct, but allows us to observe the loading of the sample image and persisting the bound fields.

This preview also includes Fluent UI and using it should give you a look that is consistent with the Microsoft designs. You can find the component here, I’ve used a TextField as input.

<TextField 
    className='pcfvatinput' 
    value={vatStates.input} 
    onChange={(_, value) => vatStates.onInput(value ?? '')}
    styles={{
        fieldGroup: { border: "none" }
    }} 
/>

There is not much to elaborate on this component, you can work here as explained in regular React tutorials. The only difference is the onChange will have to call notifyOutputChanged method directly or indirectly. Here this happens through vatStates.onInput, internalOnInput and props.outputChanged. If you skip this, your inputs will not persist in the form and therefore will not be saved with the form.

Problems I faced

I did not want to inline styling and wanted to work with a .css module, however I couldn’t make the sandbox pick it up and instead used a regular .css. A .css just has to be referenced in the ControlManifest.Input.xml and then you can use the defined classes in your components.

As already mentioned, the sandbox does not work correctly with getResource, it loads the resource when observing the network, but passes undefined to the callback. For debugging purposes, I solved this with a ternary, rendering a fixed image in the sandbox so that styling can be checked.

context.resources.getResource(
    "img/at.png",
    data => data
        ? setImg("data:image/.png;base64," + data) // -> rendered in dataverse
        : setImg("data:image/.png;base64,iVBOR...ggg=="), // -> rendered in sandbox
    () => console.log("Failed to get img"));

And finally, the New Look. Here the look of the Fluent UI component is not in line with the other fields, making it very apparent, that this field is self-made. This might change if we were using Fluent UI v9 (we can’t right now, the library versions in the ControlManifest.Input.xml are fixed) and maybe applying additional styling, but the current transition highlights how even well-fit PCFs can be a break to the user experience with future wave updates and do require maintenance. Here are some screenshots of the new look and in the next section is a short video of the “old” look, where the integration (apart from the font) is much better.

Summary

React makes it easy to work with asynchronous resources and render the results in a way that is not the ultimate Christmas tree. Together with Fluent UI, the addition of this framework capability is a great fit for slick PCFs that behave well for the user while also having clean code behind them.

[VIDEO] Power Platform Learners: AI driven Chatbot in Power Pages

Sat, 30 Mar 2024 00:00:00 +0000

What hasn’t worked on the first try in the group presentation is picked up by Sweta in the Power Pages Quick Tips series, showcasing the integration of external data with Virtual Tables.

Check it out here.

[VIDEO] Power Platform Learners: How to use External Data Source in Power Pages and Delegation of Service Principles in ALM

Thu, 28 Mar 2024 00:00:00 +0000

Our new members Sweta and Milad show us some cool Power Platform Features for their introduction. Milad has something for Service Principles with Power Platform Pipelines and Sweta brings Virtual Tables for Power Pages to the table.

Check it out here.

[VIDEO] Power Platform Learners: Identify Bootstrap version

Mon, 25 Mar 2024 00:00:00 +0000

Ambesh already showed us how to enable Bootstrap 5 for new Power Pages, but how do you know which version is active on an already existing Power Page? This video holds the answer!

Check it out here.

Business Rule and Autonumber timing

Sun, 24 Mar 2024 00:00:00 +0000

This week just some observations regarding timing that might be helpful in your solution designs. We are going to find out when Business Rules are executed within the execution pipeline and when Autonumber fields are filled by Dynamics.

Execution Pipeline

In the official documentation Microsoft only lists the following Stages of the Event Pipeline:

PreValidation
PreOperation
MainOperation
PostOperation

In reality, this implies that there is also something like a MainValidation and PostOperation splits into two parts. One synchronous part is still within the transaction and one asynchronous part will be executed outside of the transaction by the Asynchronous Service.

So the real Event Pipeline will look something like

PreValidation
MainValidation
Database Transaction
- PreOperation
- MainOperation
- PostOperation
Asynchronous

I would assume that especially Autonumber would be executed somewhere in the MainOperation and from the Audit History I know that Business Rules, unlike synchronous workflows, are not executed PostOperation. But let’s find out!

Setup

To check my theory, I wrote a simple plugin that uses the tracing service to print all attributes present in the target.

This Plugin is deployed to my Dataverse environment and registered with the Plugin Registration Tool (PRT) for PreValidation, PreOperation and PostOperation of Create of the Account entity. MainOperation is not available in this case, that would only be possible for Custom APIs or Virtual Table implementations.

For the Business Rule, I set up a Business Rule with Entity Scope and made it fill emailaddress2 with a fixed value if it is empty. Important: emailaddress2 is not on the form in this experiment because otherwise the field would already be filled when the form is submitted, meaning the value would be present before PreValidation.

For the Autonumber field, I chose the accountnumber, the presence of this field is the reason why I’ve used the account table. This field is on the form but is not filled in the tests.

Testing

For testing, I now create accounts and check the trace logs for the plugin executions where the attributes are logged. Let’s run through the results, I’ve marked the important lines below.

PreValidation

account(1390bc28-44cc-ee11-9079-0022489ef7a6) 
{
    'name': 'Test 3'
    'msdyn_travelchargetype': '690970003'
    'msdyn_taxexempt': 'False'
    'creditonhold': 'False'
    'donotpostalmail': 'False'
    'donotfax': 'False'
    'donotphone': 'False'
    'donotbulkemail': 'False'
    'donotemail': 'False'
    'preferredcontactmethodcode': '1'
    'statuscode': '1'
    'msdyn_gdproptout': 'False'
    'processid': '00000000-0000-0000-0000-000000000000'
    'transactioncurrencyid': 'transactioncurrency(6f02758b-6fc2-ee11-907a-0022489bee1d)'
    'ownerid': 'systemuser(50baf8f5-0cc2-ee11-907a-0022489bee1d)'
    'donotsendmm': 'False'
    'donotbulkpostalmail': 'False'
    'accountratingcode': '1'
    'accountclassificationcode': '1'
    'isprivate': 'False'
    'territorycode': '1'
    'businesstypecode': '1'
    'shippingmethodcode': '1'
    'marketingonly': 'False'
    'followemail': 'True'
    'merged': 'False'
    'address2_addresstypecode': '1'
    'customersizecode': '1'
    'participatesinworkflow': 'False'
    'address2_shippingmethodcode': '1'
    'address2_freighttermscode': '1'
    'accountnumber': '1000'
}

PreOperation

account(1390bc28-44cc-ee11-9079-0022489ef7a6) 
{
    'territorycode': '1'
    'msdyn_travelchargetype': '690970003'
    'address2_shippingmethodcode': '1'
    'accountid': '1390bc28-44cc-ee11-9079-0022489ef7a6'
    'followemail': 'True'
    'donotbulkemail': 'False'
    'donotsendmm': 'False'
    'createdon': '2/15/2024 8:52:48 PM'
    'statecode': '0'
    'isprivate': 'False'
    'businesstypecode': '1'
    'donotpostalmail': 'False'
    'owningbusinessunit': 'businessunit(5eb3f8f5-0cc2-ee11-907a-0022489bee1d)'
    'ownerid': 'systemuser(50baf8f5-0cc2-ee11-907a-0022489bee1d)'
    'donotbulkpostalmail': 'False'
    'name': 'Test 3'
    'accountnumber': '1000'
    'address2_addresstypecode': '1'
    'donotphone': 'False'
    'transactioncurrencyid': 'transactioncurrency(6f02758b-6fc2-ee11-907a-0022489bee1d)'
    'modifiedby': 'systemuser(50baf8f5-0cc2-ee11-907a-0022489bee1d)'
    'donotemail': 'False'
    'statuscode': '1'
    'modifiedonbehalfby': ''
    'preferredcontactmethodcode': '1'
    'msdyn_gdproptout': 'False'
    'accountratingcode': '1'
    'createdby': 'systemuser(50baf8f5-0cc2-ee11-907a-0022489bee1d)'
    'donotfax': 'False'
    'merged': 'False'
    'customersizecode': '1'
    'marketingonly': 'False'
    'processid': '00000000-0000-0000-0000-000000000000'
    'shippingmethodcode': '1'
    'msdyn_taxexempt': 'False'
    'creditonhold': 'False'
    'modifiedon': '2/15/2024 8:52:48 PM'
    'participatesinworkflow': 'False'
    'accountclassificationcode': '1'
    'address2_freighttermscode': '1'
    'emailaddress2': 'test@marius-wodtke.de'
}

PostOperation

account(1390bc28-44cc-ee11-9079-0022489ef7a6) 
{
    'territorycode': '1'
    'msdyn_travelchargetype': '690970003'
    'address2_shippingmethodcode': '1'
    'accountid': '1390bc28-44cc-ee11-9079-0022489ef7a6'
    'followemail': 'True'
    'donotbulkemail': 'False'
    'donotsendmm': 'False'
    'createdon': '2/15/2024 8:52:48 PM'
    'statecode': '0'
    'isprivate': 'False'
    'businesstypecode': '1'
    'donotpostalmail': 'False'
    'owningbusinessunit': 'businessunit(5eb3f8f5-0cc2-ee11-907a-0022489bee1d)'
    'ownerid': 'systemuser(50baf8f5-0cc2-ee11-907a-0022489bee1d)'
    'donotbulkpostalmail': 'False'
    'name': 'Test 3'
    'accountnumber': '1000'
    'address2_addresstypecode': '1'
    'donotphone': 'False'
    'transactioncurrencyid': 'transactioncurrency(6f02758b-6fc2-ee11-907a-0022489bee1d)'
    'modifiedby': 'systemuser(50baf8f5-0cc2-ee11-907a-0022489bee1d)'
    'donotemail': 'False'
    'statuscode': '1'
    'modifiedonbehalfby': ''
    'preferredcontactmethodcode': '1'
    'msdyn_gdproptout': 'False'
    'accountratingcode': '1'
    'createdby': 'systemuser(50baf8f5-0cc2-ee11-907a-0022489bee1d)'
    'donotfax': 'False'
    'merged': 'False'
    'customersizecode': '1'
    'marketingonly': 'False'
    'processid': '00000000-0000-0000-0000-000000000000'
    'shippingmethodcode': '1'
    'msdyn_taxexempt': 'False'
    'creditonhold': 'False'
    'modifiedon': '2/15/2024 8:52:48 PM'
    'participatesinworkflow': 'False'
    'accountclassificationcode': '1'
    'address2_freighttermscode': '1'
    'emailaddress2': 'test@marius-wodtke.de'
    'msdyn_taxexemptnumber': ''
    'msdyn_travelcharge': ''
    'exchangerate': '1.000000000000'
    'msdyn_travelcharge_base': ''
}

Results & Implications

This is quite far from what I expected. The Autonumber received its value before the PreValidation! In the form, Autonumber fields are empty before the first save, but they are filled before any plugin can run.

The business rule ran somewhere between the PreValidation and PreOperation stages. So you can expect that they have been executed before your PreOperation plugins run, but not for your validation logic that you push to the PreValidation Stage.

The PostOperation stage then offers no new insights, some properties were added, like the exchange rate, but the subjects of our test are already done.

Because the Autonumber is executed before the Business Rule, this means the Business Rule can use the result in its conditions or actions. This is in contrast to Calculated fields which will be available earliest in the PostOperation stage since they are calculated upon retrieval, which is not possible PreCreate and might deliver wrong results PreUpdate. Also, all custom Plugins can assume that the Autonumber has been executed, but PreValidation Plugins will perform their actions before the Business Rule.

Summary

This was a short reverse engineering session and we have clarity on timing for these standard features now. Autonumber executes before the PreValidation stage and Business Rules with Entity scope (aka Table scope) are executed between PreValidation and PreOperation if they were not executed on the form in the frontend anyway.

I hope this helps you in your mission to the perfect solution with the Dynamics standard functionality. My experiment here ended with the conclusion: I can use both the results of an Autonumber and a Business Rule action (Set Value) to feed a Calculated field which will display correctly right after saving. I just can’t use another Calculated field for the Business Rule, in that case, I would have had to resort to a second Calculated field and a dependency between those two.

[VIDEO] Power Pages Web API with N:N Relationships

Sun, 17 Mar 2024 00:00:00 +0000

This time we got the feedback that the standard experience for N:N Relationships is not ideal. The customer wants checkboxes instead. This is where the Web API of Power Pages can help us create a custom user experience for the users!

Check it out here.

[VIDEO] Power Platform Learners: PAC support for Power Pages

Sun, 10 Mar 2024 00:00:00 +0000

This episode of the Power Pages Quick Tips is about the Power Apps CLI (aka PAC or Power Platform CLI) and how it can be used for a more ProDev experience with Power Pages. It enables us to download and upload a given Portal, for example, to move between stages or build up version control.

Stay tuned and subscribe to the channel, the rest of the crew will join us soon for more tips & tricks around the Power Platform.

Check it out here.

Teams Integration: Join a chat

Sun, 10 Mar 2024 00:00:00 +0000

One problem with the connected chats in Dynamics is: How do you get access if you are not already part of the group? Dataverse does such a good job of breaking silos in organizations willing to do so, but if Teams chats are widely used, they may become mini-silos where relevant information is only accessible to a very selected group of people.

But this shall not draw you away from using the Teams integration! Instead, consider the Self-Join option. This enables anyone with the appropriate permissions in Dataverse to join existing connected chats.

How to enable Self-Join?

The Teams options are found at Sales Hub -> App Settings -> Chat and Collaborate. Here you want to scroll down to the entities, select the given entity, activate the switch for Join chat and save.

How does it feel?

After enabling it, it’s pretty straightforward to join an existing conversation. First, we will take a look at what happens if you have the timeline integration enabled as well.

This picture has important information inside: All chat history is shared upon joining. This is good for getting the most out of this functionality, otherwise, you would be starting into the chat with no context of what has been already discussed. But it also means these chats are not as private as a chat you just have with a colleague. Even if you had to add someone in Teams, you could still choose not to share the chat history. This means that you will have to train the users so they understand, that the connected chat is more of an official communication around the record.

If you did not activate the timeline integration, there is of course another way to join via the chat pane.

When does it not work?

Well firstly if you do not have write or append permission on the record. The chat pane will show the chat as locked and if you try to click the button at the timeline entry, you will receive an error about missing permissions.

The second reason it might not work is when you did not enable the entity for self-joining. Remember that this setting is per entity, so while it might work for one type of record, it might not for another. The chat pane will look the same as if you had no permissions, clicking the button at the timeline entry reveals a different error.

Lastly, it will also not work if you have used the pinned tab in Teams as “connection” as this is not counted as connected chat. This chat won’t be listed in the connected chats section and therefore there will be no join button. So you can safely use the Dynamics 365 tab of Teams in chats that you want to keep private, only chats created/manually connected from Dynamics are subject to self-joining.

Summary

Enabling self-join is done in the collaboration options in a per-entity fashion. Once you enable self-join for an entity, users with either write or append privileges to a record may join the connected chat(s). They can do so either via the timeline entry (if this feature is enabled) or the chat pane. This does only work for chats that were connected from Dynamics, chats are not connected to Dynamics by adding the Dynamics 365 tab to Teams.

Teams Integration: Using the Timeline

Sun, 03 Mar 2024 00:00:00 +0000

We’ve already talked about chat as the lighter integration of Teams. And there is a preview to make it even better: Timeline Integration. Even though this is marked as a customer service feature, it will still work nicely in the sales app context I’ve set in this series.

How to enable Timeline Integration?

Luckily, the Teams Integration settings are a one-stop job. So we are again at Sales Hub -> App Settings -> Chat and Collaborate. Here it’s the Show Teams chats on the connected record’s timeline (Preview) Flag we are looking for. Also note the fact, that this needs a Global Administrator to enable it because changes in Teams will be captured by an Application and synched back to Dynamics.

How does it feel?

Well, when you now connect a new chat to a record, here I’ve used an Opportunity, after some time and manually refreshing the timeline, a new activity will appear. By clicking on the button at the activity, the chat will open.

The activity will display who connected the chat and who did the most recent change. I did not see that much value in the most recent change. In the examples below, Alan made the change by simply being added to the chat when it was created and in the second example, Jeff self-joined, resulting in an unknown app to perform the most recent change.

Why is it useful?

Those last sentences may sound like I wouldn’t like this feature, but I think it’s a wonderful feature for discovering chats! Let’s take a look at what was shown before I clicked the button.

Nothing is telling me about the connected chat apart from the Timeline entry. I would need to open the chat drawer with the button at the top right to find the chat. Therefore the chat is easily overlooked and this will limit the adoption of the integration. Therefore I think you should enable this to help the users after the first connection of the chat.

Activities

The timeline shows activities, which means there are also activity records. When clicking these in Activities, the chat will also open. This might be useful when searching for a certain chat, but you could as well just search in Teams and find the initial note to the record in Dataverse there. So I think this will mostly be used by the administrator to measure adoption…

When does it not apply?

This only works when you connect the chat from Dynamics as detailed in the post about chat. That specifically means that it will not make a timeline entry if you pin the Dynamics 365 Tab in a Teams chat, and this is a good decision by MS! Because there are other features like Self Join that would make this a serious issue in regards to privacy.

So if you want a timeline post to find the chat at a later point in time, start the chat from Dynamics.

Summary

If you can get a Global Administrator on board to enable the Timeline Integration, do so! It’s as simple as flipping a switch and provides the users with a visible hint to existing Teams chats in Dynamics. Once the user identifies the chat in the timeline, he is just one click away from the chat window. Also if there are too many activities and users struggle to find the chat, this can be solved by pinning the activity!

If you choose not to enable this, for example, because it’s a preview feature, the chats can still be found via the chat pane, which is opened at the top right once you enabled chats. This has less visibility, but if the users have the chat pane always open, they will likely not bother about the timeline and will notice the chats there.

[VIDEO] Power Platform Learners: My Highlight from Wave1 2024

Sat, 02 Mar 2024 00:00:00 +0000

The Power Platform Learners group is growing! In this episode, we picked our favorites from the wave update. I chose a lot of security enhancements for Plugins, Views and Apps. Also, I completely missed that Plugin Packages are now generally available!

Check it out here.

[VIDEO] Power Pages Form Validation and the benefits of Webfiles

Sun, 25 Feb 2024 00:00:00 +0000

For the Lead form, we only want to allow entries for persons older than 18 years. A great fit for Client Site Validation, but there is a bug in the code, and the debugging tools are not working correctly! With the usage of Webfiles, we can get a better debugging experience to quickly find the error. And with using Fiddler we can even test some fixes without deploying a change to the server to avoid the time this takes.

Check it out here.

PowerBI: Filtering Embedded Reports

Sun, 18 Feb 2024 00:00:00 +0000

In this post of the PowerBI series, we embedded a report in a Dynamics form. But I think you also noticed that this was somewhat pointless because the report showed the same data on every record, it lacked context. This time we are going to fix this with a filter!

Simple filter

To set a filter first, we need to find out the table and column name of the target column in the PowerBI report. You can find these in the Table View when opening the report in the Desktop App.

From here, fill the following Template by replacing the <tags>:

{
    "Filter": "[{\"$schema\":\"basic\",\"target\":{\"table\":\"<PowerBI Table Name>\",\"column\":\"<PowerBI Column Name>\"},\"operator\":\"In\",\"values\":[$a],\"filterType\":1}]",
    "Alias": {
        "$a": "<CE Column Logicalname>",
    }
}

Note: The ugly formatting is on purpose! When I prepared this article I had to follow the advice here to remove all line breaks in the Filter property of the JSON as this is an encoded JSON.

The result for my sample looks like this:

{
    "Filter": "[{\"$schema\":\"basic\",\"target\":{\"table\":\"account\",\"column\":\"Account Name\"},\"operator\":\"In\",\"values\":[$a],\"filterType\":1}]",
    "Alias": {
        "$a": "name",
    }
}

Now the report looks much different! Of course, my report for this series is not well designed for this scenario, the only thing that makes sense is the filtered contact grid. Notice how the Pie Chart for the country changed: When we selected an account manually in the Dashboard/Embedded Report, it got a cross highlighting, but the filter applies to the whole page, so the visual is simply filtered. I have also enabled the Filter Pane in the PCF settings to show you the effects on the displayed report.

Or filter

You can also filter one PowerBI column to 2 different CE fields. This is also the sample Microsoft provides. With the operator “In” we can just define a second Alias (aka Parameter) for the Filter like this:

{
    "Filter": "[{\"$schema\":\"basic\",\"target\":{\"table\":\"account\",\"column\":\"Account Name\"},\"operator\":\"In\",\"values\":[$a,$b],\"filterType\":1}]",
    "Alias": {
        "$a": "name",
        "$b": "accountnumber"
    }
}

Again, I’m not good with these samples, but notice here how 2 Accounts are listed now, one with an empty (Blank) name for the empty accountnumber of the CE record and one with name of the CE record.

And filter

And finally, you can filter on multiple fields matching with AND. For that, you simply define 2 filters like this:

{
    "Filter": "[{\"$schema\":\"basic\",\"target\":{\"table\":\"account\",\"column\":\"Account Name\"},\"operator\":\"In\",\"values\":[$a],\"filterType\":1},{\"$schema\":\"basic\",\"target\":{\"table\":\"account\",\"column\":\"Account Number\"},\"operator\":\"In\",\"values\":[$b],\"filterType\":1}]",
    "Alias": {
        "$a": "name",
        "$b": "accountnumber"
    }
}

Sorry for that long line, but if I put a linebreak there, you can bet someone will copy it blindly and be frustrated for it not working.

The result looks pretty much the same as in the first picture, the name and number match up.

Considerations

I don’t have any knowledge of a way to connect two filters in the JSON as an or and that poses an interesting architectural requirement: While I can match two or more CE columns to one PowerBI Column I can’t match one CE column to multiple PowerBI columns.

How could I run into this? Just an example: You have migrated the accounts of 2 legacy systems into CE and put the respective account number into the accountnumber field. Now the designer of the PowerBI Dataset aggregates from both systems as well and tries to deduplicate the accounts, he puts in 2 columns for accountnumberA and accountnumberB to be able to fill both of them. Now you will have trouble solving this. If the dataset also contained an accountnumber, which one would it be in case of a deduplication? One of the CE records would show an empty report. Splitting it in CE won’t help either, it still would not match in case of a deduplication where both numbers are filled. The dataset designer can’t even solve this on his own if he would match the CE accounts on his side as he still has to put 2 accountnumbers into one field, which will not work unless you can afford a contains filter-operator. A deduplication on CE side will likely not be possible on CE side, because if it had, you would have done it in the first place.

One thing you could do is to feed back a new number back to CE based on the dataset, lets call it reportnumber. This could be the deduplicated accountnumber in the dataset, pushed to CE via a Dataflow. Now you can filter CEs reportnumber against PowerBIs accountnumber and will always get the correct result.

Summary

Filters make embedded PowerBI reports much more useful! To apply a filter, you enter a JSON in the configuration of the PowerBI PCF in the Dataverse form and reference the correct PowerBI table and column names as well as the logicalname(s) of the CE field(s) on the form. The result is a prefiltered report which can for example show all orders for the customer from an ERP system without needing a full integration via Virtual Entities or similar technologies. You can filter one PowerBI column by multiple CE fields or multiple PowerBI columns with an AND. An OR filtering on multiple PowerBI columns is not possible, you can only filter a single PowerBI column with an OR by using the IN operator.

Teams Integration: Connecting a Team via Flow

Sun, 11 Feb 2024 00:00:00 +0000

We have covered the standard approach of connecting a Teams team with Dataverse for the basic and enhanced experience. But this time we will discuss automation around that. The standard wizard has a lot of steps that you might not want your users to go through every time. They also have a lot of flexibility in where they want to attach the record but that might not be what the IT-department wants as well.

Our premise for this post will therefore be “Users do need a Team for collaborating with others when an Opportunity reaches a certain stage and this should be a new Team named like the Opportunity”. To automate the creation, I have chosen Power Automate as seems to be a perfect fit for its wide variety of connectors.

Creating the Team

That’s the easiest of this whole post since there is a Teams connector and that’s one of its actions. Note however that under advanced, the Visibility has a default value of public, which might be unwanted.

Reading all necessary information

Now the team is already there, only one more thing to do, connect it to Dataverse, right? Yeah, kind of, but to create a _"Microsoft Teams Collaboration entity we need a lot more information than just the ID that was returned from the Create a Team action.

First, we will be getting the Team and its default channel called “General”.

Then we will also want the URL of the Sharepoint Site, which is not returned by any action of the Teams connector. Instead, we will use the Office 365 Groups Connector, which has an action to send a generic HTTP request to the Graph API where we can get it in the property webUrl. Please note the wait period of a few seconds here. It drove me insane when the Flow always said “404 not found” and copying the URL in the browser returned the expected result. The Graph API needs a second to catch up, probably due to indexing, anyway after a few seconds it will work, 5 to 10 seconds should be enough.

For copying: https://graph.microsoft.com/v1.0/groups/@{outputs('Create_a_team')?['body/newTeamId']}/sites/root?$select=webUrl

We will need the full URL as well as a relative one, I have extracted these to two variables.

And that’s everything we will need to create a Microsoft Teams Collaboration entity.

Adding a Team member

But before we do that, let’s quickly take a side step and add someone to the team. Because if only our Power Automate integration user is in there, that won’t yield any value. There need to be users, and probably the person working the opportunity is the right one. For simplicity, I have chosen the Created by here because while I think the Owner makes more sense, I would have needed to catch the fact, that the owner can also be a team.

Connecting the record

Now, we go on to create the Microsoft Teams Collaboration entity. Let’s go with the picture first:

For reference, as code view:

"parameters": {
    "entityName": "msdyn_teamscollaborations",
    "item/msdyn_groupid": "@outputs('Get_a_team')?['body/id']",
    "item/msdyn_tenantid": "eba86d05-d196-4bd8-8793-b2cae91984dd",
    "item/msdyn_channelid": "@outputs('List_channels')?['body/value'][0]['id']",
    "item/msdyn_channelfolderrelativeurl": "@{variables('SharepointRelative')}/Shared Documents/General",
    "item/msdyn_teamid": "@outputs('Get_a_team')?['body/internalId']",
    "item/regardingobjectid": "@triggerOutputs()?['body/opportunityid']",
    "item/regardingobjecttypename": "opportunity",
    "item/msdyn_teamsiteurl": "@variables('SharepointFull')",
    "item/msdyn_channelname": "General",
    "item/msdyn_channeltype": "Standard",
    "item/msdyn_teamname": "@triggerOutputs()?['body/name']",
    "item/regardingobjecttypecode": 3
}

Most of these should be clear, Team ID and Internal Id are from the Get a Team action and the Collaboration Channel ID value assumes that the first channel shall be connected (for a new team this is the default channel “General”). This assumption around the “General” channel is also applied in the Collaboration Channel Name and CollaborationChannel Relative Folder URL. For Collaboration Channel Type may be Private or Standard, so Standard for the default channel and the Team Site URL is the webUrl we saved to a variable earlier.

An easy way to get the Collaboration Tenant Identifier is to look it up in the overview of the Entra ID (aka Azure AD). This, as well as the Sharepoint base URL that I removed to get a relative URL, will likely be fixed because often we deploy between different Environments of the same tenant. If however, you are planning to transport the solution to a different tenant, consider using Environment Variables to be able to adapt the value to the target tenant.

The other values are related to the record in Dataverse. If you are not using Opportunity, of course, the values for Related Dynamics 365 Record ... will change and your naming scheme for the Team might be different. An interesting note: I try to avoid the Entity Code whenever possible because it changes for custom entities with deployments. But here you need to set it, otherwise, you will get the error pictured below. This should not be a bigger problem as the integration only works for a limited set of standard entities.

Note: There are hints, that the limitation to the entities that can be integrated with teams might be lifted, check out this recent change to the Entity.xml of a custom entity:

The Result

So first let’s picture the full flow that we just picked apart:

After the team is created and connected, the Opportunity will notice and the Teams button will show the existing team (if you have not hidden this button, which is likely in the described scenario from the beginning). Also, the Documents Tab now shows the /Shared Documents/General folder of the Sharepoint site connected to the team.

Pros and Cons

So there is a catch. We never pinned the Dynamics 365 tab to the Teams channel. The users will have to do that on their own if they like this feature. I am not aware of how this could work with flows, hit me up if you have an idea. Resorting to a classic plugin has the problem that we would need to do the authentication without a good way to store the secret…

But there are many pros as well! For once, in an optimal case does not require any user interaction at all and also makes sure all Teams are created the same way. The fact that the Teams are “managed” by the user creating them (the user is an owner) allows us to implement further logic. You can for example add members to the Team from Dataverse actions, like connecting another user in the Sales Team Connection subgrid on the right. The flow user can also make posts in the channel and I bet you can think of more stuff you want out of the Teams integration. With the standard you might always run into permission issues, either the flow user has very liberal privileges in the corporate Teams, or it will simply not be possible unless the users are trained to include that user in the team.

Summary

With Power Automate we can certainly mock a connected Teams Team! We will have to leverage a third connector apart from Teams and Dataverse in the Office 365 Groups connector, but the integration will behave very similar to the OOTB experience without the need for the user to select as many options correctly in a multi-step wizard. The Teams channel won’t have the Dynamics 365 tab pinned by default, that’s something a user will have to add manually. But this approach offers repeatability and allows for further automated activities in Teams down the line.

[VIDEO] Power Platform Learners: Enable Bootstrap5 in Power Pages

Fri, 09 Feb 2024 00:00:00 +0000

In this episode of the Power Pages Quick Tips, we talked about Bootstrap 5, the newest version of the framework which claims to be more lightweight and faster, which should of course also translate to quicker Power Pages as well.

Stay tuned and subscribe to the channel, the rest of the crew will join us soon for more tips & tricks around the Power Platform.

Check it out here.

[VIDEO] Using FetchXml in Power Pages

Sun, 04 Feb 2024 00:00:00 +0000

We already took a look at displaying a list to the user. This used the products of Dataverse which allowed the Dataverse Users to control what visitors will see on the Power Page. But that list might not fill all requirements in terms of looks. With FetchXml in Power Pages, we can build a more flexible list to show the data exactly as we like to!

Check it out here.

[VIDEO] Power Platform Learners: Dataflow Deployment Considerations

Sat, 03 Feb 2024 00:00:00 +0000

The group of the Advents Calendar is coming back to the Power Platform Learners channel. To get the new year started, the first episode had a pretty open pool of topics and I chose to showcase something from a recent post. In the next episode, which should be in February, we will talk about the new release wave announcements.

Check it out here.

[VIDEO] Power Platform Learners: Enhanced Data Model

Mon, 29 Jan 2024 00:00:00 +0000

The Power Platform Learners channel is not dead after the Power Platform Advent Calendar! Together with Ambesh Singh, we will talk more about Power Pages, THE tool for your customers and partners to effectively interact with your company through Dataverse.

In this episode of the Power Pages Quick Tips, we talked about the Enhanced Data Model, a big step after so many years of Powerapps Portal!

Stay tuned and subscribe to the channel, the rest of the crew will join us soon for more tips & tricks around the Power Platform.

Check it out here.

PowerBI: Deploying an Embedded Report with Dataverse

Sun, 28 Jan 2024 00:00:00 +0000

In the post about Embedded Reports, we did talk about the customizations needed to show a PowerBI Report on a form in Dynamics, but not about general ALM praxis: Customize on a Development environment and then deploy a solution. We will catch up here and explore the Solution Awareness of Reports.

Preparations

For the report to be selectable for embedding, it needs to be included in a solution anyway, so if you followed the post about Embedded Reports, your solution includes a Dataset, a Report and probably an Entity with a form.

Plain Import

If we take this solution now, export and import to the target environment, the form will show the report, but no data. This is because the Dataset does not yet include data. We can fix this in the PowerBI Service by selecting the managed Workspace for the Dataverse environment, which was automatically created as soon as we imported the solution with the Report/Dataset inside. Here we can manually refresh the Dataset and if needed authorize the connection in the Settings.

The Connection Problem

But as marked in the last screenshot, the connection from the original environment was kept in the Dataset and the editing capabilities in the PowerBI Service cannot simply change it.

Note: As of writing this article, editing semantic models in the PowerBI Service is a preview feature. Your milage may vary.

Therefore I have to edit the query in the Desktop App and then publish it again to the Workspace of the target environment. And this change will be overwritten with a new deployment! So we need a different solution. Fortunately, there is one for Dataverse: When you click edit on the Dataset in the Solution, there is an option to use the current environment as the connection. If this is set to yes, the Connection-URL will always point to the environment where the solution is deployed! On the first deployment, you will still need to set the refresh schedule and probably do a manual refresh to make the embedded report work and check that the connection is authorized, but after that, there should not be any problems.

Non-Dataverse Connections

For Datasets that do not connect to Dataverse, this won’t be as easy, because there is no “current environment” to connect to. In this situation, I would like to inspire you to look into the Pipelines of the PowerBI Service.

First, we include the components in a solution on the source environment, then we deploy this solution once to the target environment(s). Now the requirements for embedding are fulfilled. Any updates to the report/model are now deployed via the PowerBI Pipeline which moves the components between the connected workspaces and sets the correct connection values.

Just be aware that you will have problems importing a new version of the solution, you will encounter an error like this:

Import failed: Unsynced customizations detected. 
Please sync changes with Power BI and try again. 
Datasets with customizations: [<ExternalReferenceId=5a4c6949-b787-4920-b608-effd9baeafb3, HasCustomizations=True>]. 
Reports with customizations: [<ExternalReferenceId=9bf7ca28-3b28-4fff-8f5e-6bb1b3847589, HasCustomizations=True>]

This can be corrected by using the Sync changes button on the components in the solution in the target environment. This does work on managed solutions as well. But an import of this solution after the PowerBI Pipeline is set up is not advisable anyway, it will reset the connection until the PowerBI Pipeline runs again.

Summary

At least with a Dataverse connection, the trick of using “an existing connection in the target environment” makes deploying embedded reports easy and only requires manual setup after the first deployment of a dataset. The result contains my changed “AAAdventure Works” Account, only being present in the target environment.

Stay tuned for the next episode in this series where we will look into filters to make these reports more useful by applying filters based on values on a form.

Deploying Dataflows

Sun, 21 Jan 2024 00:00:00 +0000

In the first shot of Dataflows, we’ve explored the feature and imported products from an Azure SQL database. But a feature without deployment is merely a PoC.

Dataflows in Solutions

Luckily, we can just add dataflows to solutions! We can not create them inside a solution, or edit them, this has to happen in the dataflows section of the Maker Portal. But after preparing the dataflow there, we can just select Add Existing->Automation->Dataflow in our solution.

What is not transported?

So that’s it, add it, deploy it and it will run? Sadly not. The connection to the database is not transported with the solution. That’s of course good news as the opposite behavior would mean a secret like a password is included in the solution. But that means we will have to do some manual work.

First, you find the deployed dataflow in the dataflows section of the maker portal. If another user imported the solution you can reassign the dataflow by finding the importing user and then selecting Change Owner (you need to be a System Administrator for that). And if you don’t know who first imported the dataflow, you can check the owner column in the solution that contains the dataflow.

Next, you need to edit the dataflow. The Transform screen will welcome you with a warning to connect to the data source. Here, the secret values need to be reentered. Now step through the rest of Wizard. If you also deployed the target entity, the mappings should be already set.

Another thing that is not included in the solution is the incremental refresh settings. That’s less intuitive but needs to be considered if the defaults were changed. These values are at least unlikely to change, so most probably you only need to set these up with the first deployment alongside the connection.

Watch out!

A dataflow can only be edited by its owner. And we can change the owner if we are admin. But guest users and application users (a.k.a. App Registrations or S2S apps) are not found by the dataflows view “All Dataflows”! That means if the dataflow was first imported by a guest user, it can only be edited to set the connection by this user. If it was imported by an application user - usually via an automated pipeline - it’s even worse, since there is no UI Login for that application, the connection cannot be set at all.

Even upgrading the solution to a version without the dataflow will not resolve this. For me, this still left a trace in the system, although it was not visible in the Default Solution anymore. Another import with a regular user made the dataflow show up with the old owner again. The only solution that worked was to create a copy of the dataflow in the source environment and import that to the target environment.

For this new import, I’ve used a separate solution that is not included in the automated pipeline. Instead, it is transported manually now.

If this is not an option, for example, due to company policies, a Dataflow Template might be an option to include in the solution. After the deployment, an administrator would create the dataflow from that template, which I can not see much benefit to handing them the solution and configuring the connection after the import.

Summary

You can include dataflows to solutions. The connection to the data source will not be included and will have to be set after the first import as a post-deployment step. Make sure you are not importing the solution with an application user and I also strongly advise against a guest user for the import, you might lose control because you can’t reassign the dataflow. If necessary, create a separate “manual” solution for dataflows if you are at risk of these import errors.

Check out the official article of Microsoft on solution awareness to make sure you have the latest version of the limitations.

[VIDEO] First Steps of Code Editing in Power Pages

Sun, 14 Jan 2024 00:00:00 +0000

We have used the Design Studio to create static content, show forms to enter data and lists to let the users view dynamic data. This time we will broaden our capabilities again by editing the code of a page, allowing for full web development flexibility.

Check it out here.

VAT Number Validator PCF: CORS Tricks with Dataverse

Sun, 07 Jan 2024 00:00:00 +0000

I hate CORS! It has cost me so many nerves throughout my developer career and still while I have some patterns now for myself, you can be sure that colleagues will find a way to run into these problems and approach me with wild errors.

And CORS is a topic of PCFs as well. Recently I discovered the VAT Number Validator in the PCF Gallery and immediately thought “How did the author solve the CORS problem here?”

The original solution

While researching that in the linked blog article I noticed that the author, Allan De Castro, is a colleague from France, best regards from this point.

Allan mentions the usage of https://cors-anywhere.herokuapp.com/ which as a third party may fail and is therefore not a preferred solution for enterprise use cases. The actual solution contained https://cors.bridged.cc instead which is a commercial alternative, selling the service of passing through requests with a CORS wildcard. Having a contracted party is of course better, but it still introduces the risk of a third party not being available.

The (short) CORS explanation

CORS stands for Cross-Origin Resource Sharing. It requires that if a Website implements a request to a different domain, the server accepting the request must explicitly allow the request.

It is an important detail that this is enforced and validated by the browsers, not the server handling the request! When JavaScript performs a request in code (POST for example), the browser first sends an OPTIONS request to the server requested and evaluates the response. Is the current domain and the HTTP method allowed? Are all headers required for the actual request valid?

All of these can be set with a wildcard at the destination, so a server can allow all operations from any domain with any headers. However, remember the first sentence “request to a different domain”, so all of this is not required if your page is requesting a server on the same domain that also delivers the page itself.

My solution in the past

I had to implement the VAT Number Validator twice in my life already, once as a backend solution and once in the frontend. At the time we were not on the PCF train yet and used plain JavaScript, but the problem remains the same, CORS does not allow you to directly call http://ec.europa.eu/taxation_customs/vies/services/checkVatService from the browser.

Our solution there was to use the existing Azure API Management (APIM) as a proxy. You define an API on the WSDL of the European VAT Service (VIES) and add an inbound policy to allow CORS from your Dynamics Environment URLs (XXX.crmY.dynamics.com). Additionally, when defining the API you can tell the APIM to perform a SOAP/REST conversion, allowing you to pass a JSON body as input which is much easier to define in JavaScript.

SOAP body:

var soadpRequest = "<?xml version='1.0' encoding='UTF-8'?>" +
    "<SOAP-ENV:Envelope xmlns:ns0='urn:ec.europa.eu:taxud:vies:services:checkVat:types'" +
    " xmlns:ns1='http://schemas.xmlsoap.org/soap/envelope/'" +
    " xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'" +
    " xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'>" +
    "<SOAP-ENV:Header/><ns1:Body><ns0:checkVat>" +
    "<ns0:countryCode>" + this._vatNumberElement.value.slice(0, 2).toUpperCase() + "</ns0:countryCode>" +
    "<ns0:vatNumber>" + this._vatNumberElement.value.slice(2) + "</ns0:vatNumber>" +
    "</ns0:checkVat></ns1:Body></SOAP-ENV:Envelope>";

REST body:

var soadpRequest = {
    countryCode: this._vatNumberElement.value.slice(0, 2).toUpperCase()
    vatNumber: this._vatNumberElement.value.slice(2)
};

If there is a provisioned APIM already, this solution will be free. If you need or have a consumption-based APIM, either the 1 million free requests or 3.8 EUROCENTS(!) per 10.000 requests are quite cheap. Of course, keep in mind that these conditions and prices are a snapshot and Microsoft could change them.

But this whole solution requires extra resources, the APIM, and thus works well in a project situation with the customers Azure subscription but not in a public PCF, so we need something different.

Defeating CORS in Dataverse Contexts

But by now we have an easy and completely free method of defeating CORS problems in Dataverse Contexts: Custom APIs.

This works because CORS is browser-only and allows communication to the server that is delivering the website. So the browser is calling XXX.crmY.dynamics.com which is allowed and the server code of Dynamics calls ec.europa.eu which is also allowed.

Here is a quick rundown of how this looks.

First, you need to tell the PCF Framework that you need the webAPI in the ControlManifest.Input.xml. This by the way limits the PCF to Model Driven Apps because Portals and Canvas Apps don’t have that API available in the same way.

<feature-usage>
    <uses-feature name="WebAPI" required="true" />
</feature-usage>

Then you define a request class matching the inputs of your Custom API. This is very easy here, there is just one string input “VAT”.

class ValidateVATRequest {
    private readonly VAT: string;

    constructor (vat: string){
        this.VAT = vat;
    }

    getMetadata = function () {
        let metadata = {
            boundParameter: null as unknown as string,
            parameterTypes: {
                "VAT": {
                    "typeName": "Edm.String",
                    "structuralProperty": 1,
                },
            },
            operationName: "mwo_ValidateVAT",
            operationType: 0,
        };
        return metadata;
    };
}

Then we can instantiate that class and call the webAPIs execute method to invoke the API. After converting the response body to JSON we can use all outputs. I’ve used the original outputs of the VIES service, so we have Valid, Name and Address available.

var request = new ValidateVATRequest(this._vatNumberElement.value);
var response = await (this._context.webAPI as any).execute(request);
var result = await response.json();
if (result.Valid == true) {
    ...
}

And finally of course we need the Custom API. Apart from the records in CRM, this is a plugin class that extracts the VAT from the inputs, feeds it to the connected SOAP Service and extracts the response properties back to the output.

protected override void ExecuteDataversePlugin(ILocalPluginContext localPluginContext)
{
    var context = localPluginContext.PluginExecutionContext;

    string input = context.InputParameters["VAT"] as string;
    localPluginContext.Trace($"input: {input}");
    input = input.Replace(" ", "").ToUpper(); // general cleaning of input

    string country = new string(input.Take(2).ToArray());
    string vat = new string(input.Skip(2).ToArray());
    localPluginContext.Trace($"country: {country}, vat: {vat}");

    var service = new checkVatPortTypeClient();
    service.checkVat(ref country, ref vat, out bool valid, out string name, out string address);

    localPluginContext.Trace($"valid: {valid}, name: {name}, address: {address}");
    context.OutputParameters["Valid"] = valid;
    context.OutputParameters["Name"] = name;
    context.OutputParameters["Address"] = address;
}

Next steps

The decision now was, is this an improvement for the existing control or should it be a fork? This is because the Custom API ties this down to Model Driven Apps which might not be wanted. But I’m in contact with Allan and it seems the Control was always aimed at Model Driven Apps anyway so the changes will be merged. Until the changes are available in the official control, you can download the control or take a look at the source code in my fork.

Update: The Fork was merged to the official control and is available for download.

Demo time!

Simple and effective, you enter the VAT Number and it gets validated as well as Name and Address are resolved.

Summary

I still hate CORS :D But when you have Dataverse as the platform, it’s easy to circumvent with Custom APIs. Other frontends might require different solutions, like Flows for Canvas Apps or simply Azure API Management as a Swiss army knife, but as long as you have a server that you can program, you can get around it!

Teams Integration: Connect Chats

Sun, 31 Dec 2023 00:00:00 +0000

Let’s chat! Sometimes a full team is just too much for a Dynamics record. A chat would be more lightweight and posts might be more visible to the participants, especially if the chat is not used that frequently.

Setup

Enabling chatting is again at Sales Hub -> App Settings -> Chat and Collaborate. We can choose in which apps users can chat (by default the service apps are enabled here) and to which entities we can connect chats. Also take a close look at the second screenshot, if you select the ellipses of an entity in the configuration, you can customize the experience for the user. Most importantly some of those settings might be considered security-relevant, like self-joining chats.

Note: In my environment it took around 15 minutes to show the features correctly after successfully saving the settings.

Co-presence chatting

When someone is on the same record as you, you can start a chat with them. When Teams opens, the message box is prefilled with a link to the record. At first glance this seems not that helpful, the other side is already there! But adding a space (and thus converting the text to a link) reveals a nice feature of the app in Teams: The link is converted to a card and the open button behaves much like if you had added the tab.

Connecting a chat

But the whole operation we performed before was only in teams. From Dataverse, there is no link from the record to the chat, so once it moves down the list of conversations, it will be hard to find. Also, it was just a message in the regular chat with me and my colleague, nothing dedicated to the record itself, making it hard to integrate others later on in the same matter because the chat history might contain other things. So, a really “new” chat tied to the record is better for storing the information shared!

This is done with the Chat buttons in the global ribbon or the drawer at the side. Here you can select an existing chat from your recent chats or create a new one. Since I think it makes sense to make a chat per record, I created a new chat here. And that works with only one additional participant! That way I can still have my private chat Alan and a dedicated “official” chat for that (Key-)Account.

Once connected, the chat shows in the timeline and a drawer at the bottom displays. And of course, opening the chat pane via the buttons will display it as well. But only if you are a member of the chat! The experience of a user that is not joined yet is something we will explore separately. Depending on the settings, you can also disconnect chats from the record.

Summary

At first look, the Chat integration is simple for both sides: The administrator just enables it for apps and entities and the user can just start by creating a new chat for a record. On second thought, configuring this feature might take months of discussions in larger corporations: Are users allowed to self-join? How do we limit the self-joining capabilities with the Write/Append privileges? Do we need to consider the information leak in Teams by the Bot/Note? Nevertheless, Chats are a lightweight way to interact with colleagues with or without Dynamics access. The integration promotes the documentation of communication, even if it’s a quick, unstructured communication.

Power Platform Advent Calendar: 24.12.2023 Farewell

Sun, 24 Dec 2023 00:00:00 +0000

Are you ready to unleash the power of Power Platform? Join us for a festive and fun video series that will show you how to create amazing apps, govern your tenant, introduce Copilot in Power Platform and learn something about Azure Communication Services. Each day, you will get a new tip from our experts that will help you learn something new, solve a problem, or improve your skills. Whether you are a beginner or a pro, you will find something useful and interesting in this advent calendar. Don’t miss this opportunity to power up your productivity and creativity with Power Platform!

Check it out here.

Service Bus 5: Deploying Service Endpoints

Sun, 24 Dec 2023 00:00:00 +0000

After finishing a development it’s time to deploy it. In the last post of this series, we covered how to deploy the Azure Service Bus. But the Service Endpoint in Dynamics linking it needs to be deployed as well!

What’s the problem?

At first glance, it seems easy since you can put the Service Endpoint into a solution, but inspecting the customization.xml reveals the problem. The Namespace and Path (Queue or Topic) are in the export while the SAS Key is not. The SAS Key not being there is of course positive, but the Namespace and Path being present means deploying the solution will overwrite these properties. That would mean we are using the same Topic for each Environment and then differentiate in the subscriptions. And that’s something I suggest against due to security concerns as explained in the first post.

A simple solution

So how to handle it? Well, without making some sort of handstand, you can follow the following steps:

Make a separate solution that only contains the Service Endpoint.
Add the steps of it to your regular solution.
Export the Service Endpoint solution and import it to the target environment.
Connect the Plugin Registration Tool to the target environment.
Change the settings for Namespace, Path and SAS Key to the correct values and save.

And then you never deploy the Service Endpoint Solution again! That is possible because the flexible parts like the Steps and Images are part of your other solution but it’s also a crux since this needs to be known by all other developers and the knowledge of how this is a one-time setup process must never vanish. Risky…

A pipeline solution

And also it is a manual effort. One-time per environment only, but there are always reasons why you prefer automation. For this, we will use the help of the Power DevOps Tools of Wael Hamze. A tool we don’t need that often anymore since Microsoft has published a similar set of tasks, but it includes the perfect task for the job.

And the question of course is: What is the content of svcBus.json? You can find the class definition here, but I will provide you with a sample as well.

[
  {
    "Id": "7756786a-229c-ee11-be37-000d3a207f96",
    "Name": "__Name__",
    "NamespaceAddress": "sb://__Name__.servicebus.windows.net/",
    "Contract": "Topic",
    "Path": "__Path__",
    "MessageFormat": "JSON",
    "AuthType": "SASKey",
    "SASKeyName": "Dataverse",
    "SASKey": "__SASKey__",
    "UserClaim": "UserId",
    "Description": "",
    "Url": null,
    "AuthValue": null,
    "Steps": []
  }
]

Putting the secret directly into the file is another security concern, so I’ve already prepared this sample for the File Transform Task. This task will take your variables and replace the properties of the JSON file. Because of the array enclosure, we need to prefix the variables with a “0.” for the first element, “1.” for the second, and so on.

I’d still suggest putting the steps to a regular solution, there is no problem in deploying them regularly. You just have to make sure the Guid of the Service Endpoint is the same as on the Development Environment, but since that was in the exported customizations earlier, it should be no problem to configure properly.

A quick note on YAML Pipelines: Variables can also be defined here with a dot, so it would look like

variables:
- name: 0.Name
  value: 'mariuswodtke-dev'

or you use a variable group to have the traditional mode of entry which is probably preferred for the secret.

A generic solution

What if you can’t use the Power DevOps Tools? E.g. because you are not using Azure DevOps or you are not allowed to install the Tasks. Well, we can still code this! After all, Service Endpoint is a table and we can update a record there, especially since we can assume that the Guid is constant.

So with C#, this can look like this:

var namespace = "sb://mariuswodtke-dev.servicebus.windows.net/";
var secret = "secret";
var svcenpt = new Entity("serviceendpoint", new Guid("7756786a-229c-ee11-be37-000d3a207f96"));
svcenpt.Attributes.Add("namespaceaddress", namespace);
svcenpt.Attributes.Add("saskey", secret);
OrgService.Update(svcenpt);

Or with Powershell:

Set-PSRepository PSGallery -InstallationPolicy Trusted
Install-Module Microsoft.Xrm.Data.Powershell -Confirm:$false

$conn = Get-CrmConnection -ConnectionString $connection

$namespace = "sb://mariuswodtke-dev.servicebus.windows.net/";
$secret = "secret";
Set-CrmRecord -conn $conn -EntityLogicalName serviceendpoint -Fields @{"namespaceaddress" = $namespace; "saskey" = $secret} -Id "7756786a-229c-ee11-be37-000d3a207f96" -Upsert

And I think if you use something like Java and have created or updated a record in this language you can transfer the approach.

Summary

Deploying Endpoints is a little trickier than wished for but with the right strategy, we can make it work safely. After every deployment of the Service Endpoint, some settings like Namespace, Path and SASKey need to be updated. This can happen manually or be automated. No matter what approach you choose, I recommend a separate solution that is deployed only once to each new environment e.g. because its Version Number is constant. Nevertheless, the Pipeline Solution/Generic Solution is a safeguard in this because it makes sure that the Service Endpoint is in the correct state after every deployment. They can also help with key rotations and with frequent environment changes.

Power Platform Advent Calendar: 18.12.2023 Power Pages Filtered Lists

Mon, 18 Dec 2023 00:00:00 +0000

Check it out here.

[VIDEO] Showing List Data in Power Pages

Sun, 17 Dec 2023 00:00:00 +0000

Not only can we let users enter Data into Power Pages, but we can also show them the data we administer in Power Pages. So in this video, we will publish our product table to the users to browse our catalog.

Check it out here.

Power Platform Advent Calendar: 14.12.2023 Power Pages Prefilling Forms

Thu, 14 Dec 2023 00:00:00 +0000

Check it out here.

Power Platform Advent Calendar: 11.12.2023 Configuration Migration Tool

Mon, 11 Dec 2023 00:00:00 +0000

Check it out here.

Teams Integration: Enhanced Collaboration Experience

Sun, 10 Dec 2023 00:00:00 +0000

In the previous post, we explored most of the collaboration features already, but what is better in the Enhanced Experience? The answer is simple, the creation/connection of Teams Teams (no, this is no mistake, it was not me naming the groups in Teams “Teams”) can happen from Dynamics.

Enabling the Enhanced Experience

Just like with the Basic Experience, the Enhanced Experience is enabled under Sales Hub -> App Settings -> Chat and Collaborate. This time however it’s not enough to be an Administrator of Dynamics CE, but be a “Tenant Administrator”. My Global Admin role in my Tenant is of course enough, but for bigger corporations, this means that one of the few administrative Accounts needs to be enabled as an Administrator for the Dynamics Environments as well to accept the permissions pictured in the second screenshot. Don’t forget to save your new settings!

Connecting a Team

After enabling the enhanced integration, at first, there seems to be no difference. However, the italic text at the bottom of the dialog has vanished and when clicking “Get Started” in the Collaborate dialog, it will not take you to teams directly but show you some more options.

We can see the list of our Teams directly in the wizard and also have the option to create a new Team which we will explore in the next section. After selecting the team, we also have to select a channel as well.

Then we may select members to be added to the team (and channel if it’s private). Here you will not just see anyone but people you as Sales Team (via Connections),

After the dialog completes, we are redirected to Teams (in a new Tab), directly to the channel’s new Tab for the record. As expected the people I selected to be added to the Team are now members.

New Team and Channel

In the previous section, we selected existing Teams and Channels. But in both steps, we had the option to create something new as well. Creating a new Team already comes with a General channel, but we also have the option to create new channels, even private ones. No other options are presented (*aside from the Sensitivity Label in the next section), so any special channel options you will have to set in Teams after being redirected.

Sensitivity Labels

If you want to enable Sensitivity Labeling in the Team creation as well (the third switch under Sales Hub -> App Settings -> Chat and Collaborate), some more permissions are required for Dynamics.

Then, to see the labels, they need to be enabled for Teams in their Scope. If you think about leveraging this option, I assume your organization already uses these labels for Teams and they are already set up. If your tenant looks like mine and is totally blank in this regard, follow the steps listed here (including the quite extensive sub-articles) to configure. And after that give Entra ID some time to process it to prevent yourself from questioning your sanity!

Once you start seeing the labels in the regular creation process within Teams you should also start seeing them in the dialog in Teams.

Outlook

As we saw, the enhancement here is mainly that we get this dialog for the team directly in Dynamics and we don’t have to work in 2 applications when we start in Dynamics, which is always great. If you and your users will love this is mainly a question of what is their primary application, Teams or Dynamics CE. The Dynamics users will probably love this because they never leave their home soil to connect with their colleagues. A user that primarily uses Teams will probably just start the process from Teams as before.

Details may always change. Stay up to date with the official documentation as well!

Power Platform Advent Calendar: 09.12.2023 Power Pages - Anonymous Case

Sat, 09 Dec 2023 00:00:00 +0000

Check it out here.

Teams Integration: Basic Collaboration Experience

Sun, 03 Dec 2023 00:00:00 +0000

Teams is probably the most important app for almost all business users in companies that work in the Microsoft ecosystem. Therefore we should discuss the Dynamics Teams integration and what better way to do no than first exploring the standard features.

Basic vs Enhanced Experience

MS quite cleverly named these to promote the fact that the Enhanced Experience is better. It requires a Tenant Admin to enable while the Basic Experience does, but getting an Admin on board for such an important integration should be no problem. Nevertheless, we will only discuss the Basic Experience in this post and save the Enhanced Experience for another post. That is because many features stay the same, so we will first set a basis here and look at the improvements that can be achieved later.

Enabling Teams

To enable the Teams integration, go to Sales Hub -> App Settings -> Chat and Collaborate. Here you can flick the switch “Turn on the linking of Dynamics 365 records to Microsoft Teams channels”. Saving this will take a while. After that, you will find the Collaborate button in the ribbon of the supported records which for example include Lead, Account and Contact. I will be using Opportunity throughout my demonstration.

NOTE: Dynamics uses caching for the ribbon, so a simple reload of the record might not be enough for your browser to notice the new button.

Using Collaborate for the first time

This will show a screen to take you to Teams. I use the web version here. In Teams, the Dynamics App first has to be added to the Tenant if it is not already installed. So while you did not need an Admin to enable the feature, you might need them now to install the app. If already in the tenant, the dialog that is automatically opened offers to open the app.

Dynamics App in Teams

We are greeted with a Dashboard, but that demands to configure it in the settings. After selecting the environment and app there, it shows that this “Dashboard” is the whole app. Don’t get me wrong, I’m not complaining here, I like this much more than just displaying a Dashboard as this is much more powerful.

Connect to a Team

In a Teams channel, you have the + symbol at the top to add tabs, the Dynamics app will be displayed here. First, we will add a record to the channel. You can search for a record, but chances are that the record you want to connect is already listed in Recents because you recently edited it. And then it shows in this tab as if you had it open in the real app. But this time without the navigation.

We can also add a view, even to the same channel. This can even work with personal views (if shared with the members of the team), which can be a nice feature to pin the records that are relevant to a sales team. Since you can click records in the view and navigate further through lookups and subgrids, the users might not have the urge to switch to the full app we explored earlier.

Issues: I had some trouble here at first doing it via the plus. After using the dropdown “Add to a team” once, it started working for all the teams. Unless members are not allowed to add apps.

Documents

Did you see that “This record is successfully connected to Dynamics 365” with the record we added to the channel? This action was not only manipulating Teams but also Dynamics where a Microsoft Teams Collaboration Entity is created, linking to the channel. This allows you to visit the Documents Tab in the Opportunity and see the documents belonging to the Sharepoint Site connected to the Teams channel. For the demo, I created a file in the Files Tab of the channel and I can see it in Dynamics as well.

Also, if you connected a “regular” Sharepoint location before connecting the Teams, both locations can exist side by side.

Connect to a chat

In my chat with Alan Steiner, I added the record as well. This at first looked very similar to adding a record to a team, but at second glance there are some differences. You don’t have the option to link a view and also the connected record does not show the “This record is successfully connected to Dynamics 365” message, meaning that the files from this chat are not connected to Dynamics. Still useful when collaborating without a full team!

Connect to a meeting

In a meeting, you can also connect to a record. Similar to the chat, no views and no “full connection”. Also as a side pane, this looks different and not as powerful as the full forms. But it allows you to create tasks and notes for the Opportunity without leaving the context of the Meeting and should someone need the full form everyone now has the “pop-out” button at the top right as well. A link in the chat would also do, but certainly, it is more professional if you prepare this ahead of time in the meeting options.

Using Collaborate again

Back when we added our record to a team, it got connected to Dynamics. When we select the Collaborate button again, the team will be shown. We still can not do much from Dynamics apart from jumping to the correct team. + Create a new connection works just like the Get Started in the beginning and takes us to Teams.

Outlook

That was quite a heap of useful features with this integration. But did you notice how everything starts at Teams? The only direct action from Dynamics you can take is to add/edit files once the Teams connection is established. And that will change when we enable the Enhanced Experience which we will explore in the next post.

Details may always change. Stay up to date with the official documentation as well!

Power Platform Advent Calendar: 01.12.2023 Kick-Off

Fri, 01 Dec 2023 00:00:00 +0000

Check it out here.

[VIDEO] Adding a Form to Power Pages

Sun, 26 Nov 2023 00:00:00 +0000

This time we will add a form to our Power Page. This will allow users of the Website to enter data and submit it directly to Dataverse. Again a simple form can be set up in minutes and will provide you with a Dataverse-like feeling of entering and submitting data.

Check it out here.

Service Bus 4: Infrastructure automation with Biceps

Sun, 19 Nov 2023 00:00:00 +0000

Technically you know everything you need to from the first 3 articles of this series. But as you develop more and more functionality and the amount of subscriptions or topics grows, there will be configuration errors happening. The most typical thing: Someone configures a new subscription for dev and test, finishes their feature and then forgets about it. Some time later the listener gets released to production and won’t start due to the missing subscription.

This can be mitigated by using Infrastructure as Code (IaC). This ensures that when the feature is completed and the code for the listener is checked in, the infrastructure for it is checked in alongside, preferably in the same Pull Request.

Bicep

The tool we will be using for this today is Bicep. It was developed by Microsoft for deploying Azure Resources. I won’t go too much into the very basics of this tool, if you are stuck with my explanations, MS Learn has a full learning path providing much more help.

But that much information we need: To deploy (execute, interpret, whatever) the contents of a .bicep file, we will need the Azure CLI installed. I also recommend installing the Bicep Extension if you are using VS Code, as this will grant you autocomplete features as well as linting, always welcome features if not having a firm grasp on a new language.

servicebus.bicep

In a bicep file, you define resources that receive parameters and when executed, the resource will be turned into a real thing in Azure. We can also define modules that group such resources, but let’s worry about that later, just be aware, that we are about to define a module in the servicebus.bicep file.

param serviceBusName string
param location string = resourceGroup().location

resource serviceBusResource 'Microsoft.ServiceBus/namespaces@2022-10-01-preview' = {
  name: serviceBusName
  location: location
  sku: {
    name: 'Standard'
    tier: 'Standard'
  }
}

Our Resource here is Microsoft.ServiceBus/namespace. It has a location like “Western Europe”, an SKU which I hardcoded here to Standard and Basic won’t offer the Topic I’m about to configure and Premium is quite expensive and will only be used in heavy load or special security requirements. Notice the param serviceBusName which is something you need to pass if you want to deploy this.

topic.bicep

Next is another module I called topic. Here are some interesting bits as well: The service bus has an existing before its definition. That means we don’t want to create it, but we want to validate its existence. And we can use it as the parent for our topic after that. The topic parameter is an object, so you need to pass something more complex. This of course is a parameter you don’t want to specify in the CLI, but later we will define a main.bicep where we can code some complex objects. Lastly, this module calls another module, called subscription.bicep. And it does so with a loop [for subscription in topic.subscriptions: ...]. The dependsOn also specifies that this deployment cannot start before the topic is created.

param serviceBusName string
param topic object

resource serviceBusResource 'Microsoft.ServiceBus/namespaces@2022-10-01-preview' existing = {
  name: serviceBusName
}

resource serviceBusTopic 'Microsoft.ServiceBus/namespaces/topics@2022-10-01-preview' = {
  name: topic.name
  parent: serviceBusResource
  properties: {
    autoDeleteOnIdle: 'P10675198DT2H48M5.477S' // Never
    defaultMessageTimeToLive: 'P14D'
  }
}

module subscriptionModule 'subscription.bicep' = [for subscription in topic.subscriptions: {
  name: '${deployment().name}-${substring(subscription.name,0,min(length(subscription.name),25))}'
  params: {
    serviceBusName: serviceBusResource.name
    topicName: topic.name
    subscription: subscription
  }
  dependsOn:[
    serviceBusTopic
  ]
}]

subscription.bicep

Of course, this file also needs to be present. And its probably the most important for this article as the subscriptions and rules are the thing that connects this article to the Dynamics Service Endpoint specifics.

param serviceBusName string
param topicName string
param subscription object

resource serviceBusResource 'Microsoft.ServiceBus/namespaces@2022-10-01-preview' existing = {
  name: serviceBusName
}

resource serviceBusTopic 'Microsoft.ServiceBus/namespaces/topics@2022-10-01-preview' existing = {
  name: topicName
  parent: serviceBusResource
}

resource serviceBusSubscription 'Microsoft.ServiceBus/namespaces/topics/subscriptions@2022-10-01-preview' = {
  parent: serviceBusTopic
  name: subscription.name
  properties: {
    isClientAffine: false
    lockDuration: 'PT5M'
    requiresSession: false
    defaultMessageTimeToLive: 'P14D'
    deadLetteringOnMessageExpiration: true
    deadLetteringOnFilterEvaluationExceptions: false
    maxDeliveryCount: 10
    status: 'Active'
    enableBatchedOperations: true
    autoDeleteOnIdle: 'P10675198DT2H48M5.477S' // Never
  }
}

resource serviceBusRule 'Microsoft.ServiceBus/namespaces/topics/subscriptions/rules@2022-10-01-preview' = [for rule in subscription.rules: {
  parent: serviceBusSubscription
  name: rule.name
  properties: {
    filterType: 'CorrelationFilter'
    correlationFilter: { 
      properties: union(
        contains(rule, 'entity') 
        ? { 'http://schemas.microsoft.com/xrm/2011/Claims/EntityLogicalName': rule.entity } 
        : {}, 
        contains(rule, 'message') 
        ? { 'http://schemas.microsoft.com/xrm/2011/Claims/RequestName': rule.message } 
        : {})
    }
  }
}]

As you can see, I’ve hardcoded most of the settings for the Subscription here. That’s because I don’t see any necessity to alter any of these between different subscriptions of the same endpoint. For the rules, this is a different story. Each has its unique filters, for the Dataverse endpoints, these will usually be the EntityLogicalName and RequestName. Notice the ternary operators that allow for one of the parameters to be empty. This for example allows for configuration on the message Associate which simply has no entity.

main.bicep

The last file for today: main.bicep. This puts it all together, provides some parameters and is the one we are going to deploy.

param serviceBusName string
param location string = resourceGroup().location

var topics = [
  {
    name: 'dataverse'
    subscriptions: [
      {
        name: 'account-export'
        rules: [
          {
            name: 'accountUpdate'
            entity: 'account'
            message: 'Update'
          }
          {
            name: 'accountCreate'
            entity: 'account'
            message: 'Create'
          }
        ]
      }
    ]
  }
]

module serviceBusModule 'servicebus.bicep' = {
  name: '${deployment().name}-${serviceBusName}'
  params: {
    serviceBusName: serviceBusName
    location: location
  }
}

module topicModule 'topic.bicep' = [for topic in topics: {
  name: '${deployment().name}-${topic.name}'
  params: {
    serviceBusName: serviceBusName
    topic: topic
  }
  dependsOn: [
    serviceBusModule
  ]
}]

We’ve seen object parameters in the modules for topic and subscription and here we see how to fill this parameter. It became a rather deep object with the topic, its subscriptions and the rules of this subscription. A note on that: I expected list objects to be separated by a comma, but the linter quickly flagged that mistake to me.

This file still specifies a parameter to be set serviceBusName. This will have to be specified in the CLI when calling the file.

Deploying

The first step, logging in az login. This will open a browser to handle the authentication. Next depending if you have multiple subscriptions: az account set --subscription "MySubscription". And then we can already deploy az deployment group create --name bicep --resource-group sbtest --template-file 'main.bicep' --mode Incremental. The 2 things you might want to change here are a) the --resource-group which is probably not called sbtest in your environment and b) the deployments --name could be more descriptive. But please note that there is a maximum of 64 characters allowed for deployment names and inside the modules the name is appended with the current resource name! For the subscription deployment this is attempted to mitigate assuming there might be quite long subscription-names name: '${deployment().name}-${substring(subscription.name,0,min(length(subscription.name),25))}'.

After the execution, you can check on the successful (or failed) deployment at the resource group.

Summary

With our 4 levels of nested resources (namespace, topic, subscription, rule) we also created 4 files to specify those resources. servicebus.bicep to create the namespace, topic.biceps to crate the topic below and subscription.bicep creates the subscription and rules below the topic. main.bicep now specifies the parameter object and calls the modules and is the file that is referenced in the deployment. But with those in place, all we need to do for new functionality with a new subscription is to add it to the topics variable and redeploy. This approach also ensures the same settings for all subscriptions and allows you to change them for all subscriptions in bulk. Nifty, if you have 20+ subscriptions. I hope this approach saves you some headache on deployment day as it should just be a CLI command to be run and if it worked for the test/staging environment, why wouldn’t it for the production?

Dynamics CE Business Rules: Manipulating Status (Reasons)

Sun, 12 Nov 2023 00:00:00 +0000

I had to write this article because I was unable to find this information online: “Can you set a specific Status/Status Reason with a Business Rules in Dynamics?” So I had to go blind and just try and here is the outcome for you to make a confident statement about whether you can solve your requirement with a Business Rule (BR).

To set the scene, let’s dive a little into my requirements. Quotes need to be confirmed by a certain group of people before they can be offered to the customer. This shall prevent excessive discounts. After a quote is confirmed it shall not be changed anymore. The proposed solution was to use Column Security (formerly called Field Security) and add the people who can confirm those quotes to a Column Security Profile to allow them to change that field. The problem is, that you can’t activate Column Security on the Status/Status Reason columns. It would not make any sense anyway because you then would also be unable to win or lose a quote afterward without access to the column. So the idea is to make a simple switch (boolean) with Column Security to only allow the approvers to change it and make a Business Rule to activate the quote when the field is set to prevent any changes after the quote is confirmed.

Setting StateCode

We will be starting with a Business Rule set to Entity Scope. It sets the Status (StateCode) to active for a Draft Quote that is Confirmed.

The rule works as expected, when the Confirmed field is set, the Status switches to Active and after saving the Quote is locked. The Status Reason was automatically switched to the default choice In Progress.

Setting StatusCode

Next, the same again (Entity Scope) just with setting Status Reason (StatusCode). Because in the standard the Status Reason In Progress is there for both Draft and Active, I’ve introduced a custom choice called Confirmed as well. This has the nice side effect, that it is distinguishable from a normal activation via the Activate button which would default to In Progress.

This does not work! The combination Confirmed and Draft is obviously illegal but unlike changing Status in the previous section this situation is not autocorrected by the system and is therefore just not changed.

Setting StateCode and StatusCode

If setting only the Status Reason does not work, surely first setting Status and then Status Reason will work, right?

Yes, it does. And by the way, it also works if we change the order and set Status Reason first, at least for the Entity Scope this does not matter.

Using Form Scopes

When using Form Scopes instead it is usually very important to ensure all relevant fields are on the form. If they are visible or marked as read-only does not matter, they just need to be there. This is true for all fields manipulated by an action as well as all fields being evaluated in a condition. But Status is different. The Form Editor claims it’s not on the form, but the Business Rule still works.

But as soon as I remove setting the Status again it stops working.

Summary

Conclusion time. Setting Status and Status Reason does work with Business Rules, just make sure that you set Status if it needs to change, Dynamics will not do that for you if you only set the Status Reason. If however, you set only Status, the Status Reason will be automatically corrected to the default choice for the given Status.

One caveat with this and Quotes: When revising, all fields are copied, including the Confirmed field… So we need a clever solution for resetting that field too.

Sharepoint Integration (Extended) 3: Using the REST Endpoint

Sun, 05 Nov 2023 00:00:00 +0000

The last time around we discussed the usage of PnP.Core as an easy-to-use helper to interact with Sharepoint from client code. The library has far too many dependencies to be suited for plugins, but that’s exactly what we will be looking into.

Sharepoint REST API

The fact that Microsoft likes REST services has already saved me more than once with Azure integrations. And usually, the APIs are quite self-explaining once you make the first successful request. Sharepoint is not much different, let’s take a look at some examples of Microsoft.

Get items from a list:

GET https://{site_url}/_api/web/lists/getbytitle('listname')/items

Accept: "application/json;odata=verbose"

Add a new item to a list:

POST https://{site_url}/_api/web/lists/getbytitle('listname')/items

Content-Type: "application/json;odata=verbose"
Accept: "application/json;odata=verbose"

{
  "__metadata": {
    "type": "SP.Data.listname.ListItem"
  },
  "Title": "MyItem"
}

That sounds easy, right? And up until now I always found how to do things in that API just by googling things like “Sharepoint REST API Upload File” or “Sharepoint REST API Set Metadata” (-> this one needs special headers!).

But if we were to try any of these requests, none of them would work. They’d all return a 401 because we are missing the Authorization Header.

Authorization

For authorizing the app registration from the first post it is important to note, that the API does not accept tokens created with a client secret. The token needs to be created with a certificate and that is why we set up the app registration that way.

But getting a token with a certificate was not an easy task without the help of other NuGets, this topic has received a separate article. So here is a quick rundown of the possibilities with only a little explanation.

Using Microsoft.IdentityModel.Clients.ActiveDirectory

This NuGet is nice because it does need to be ILMerged or similar since it’s loaded to the Dynamics Sandboxes. But it’s also deprecated! That means it will probably stop working as soon as the Dynamics SDK is loaded to the sandboxes no longer rely on this NuGet. So probably not the best option, but certainly the easiest for a quick PoC.

using Microsoft.IdentityModel.Clients.ActiveDirectory;

var cert = new X509Certificate2(certBytes); // certBytes is the content of the .pfx certificate file
var certificate = new ClientAssertionCertificate(clientId, cert);

AuthenticationContext context = new AuthenticationContext($"https://login.microsoftonline.com/{tenantId}");
AuthenticationResult authenticationResult = context.AcquireTokenAsync(resource, certificate).Result; // resource is the url of the sharepoint without site, e.g. https://crmXXX.sharepoint.com
var authorizationHeaderContent = $"Bearer {authenticationResult.AccessToken}";

Using Microsoft.Identity.Client

This is the NuGet that you should use instead of Microsoft.IdentityModel.Clients.ActiveDirectory. The problem here is the usual NuGet problem: You can only upload one assembly. The options are the unsupported ILMerge or the plugin packages which are in preview at the time of writing. I’ve tried this exact NuGet in a dedicated article to plugin packages, so it will work, but as said, it’s in preview.

using Microsoft.Identity.Client;

var cert = new X509Certificate2(certBytes); // certBytes is the content of the .pfx certificate file
var client = ConfidentialClientApplicationBuilder.Create(clientId)
    .WithCertificate(cert)
    .WithAuthority($"https://login.microsoftonline.com/{tenantId}").Build();

var authenticationResult = client.AcquireTokenForClient(new string[] { $"{resource}/.default" }).ExecuteAsync().Result; // resource is the url of the sharepoint without site, e.g. https://crmXXX.sharepoint.com
var authorizationHeaderContent = $"Bearer {authenticationResult.AccessToken}";

Bodging something

So lastly the method that does not require any NuGets. Microsoft develops Microsoft.Identity.Client is Open Source which allows us to grab the important bits for our certificate authentication.

For the code below to work you will need to copy in some of the classes from Microsoft.Identity.Client. Since my last article, the classes moved! If the links are dead again, try to search the file names in the repository.

NOTE: I modified and stripped the classes to then not need other things like System.Text.Json and for example the Base64UrlHelper we only need Encode.

var cert = new X509Certificate2(certBytes); // certBytes is the content of the .pfx certificate file

var jwt = new JsonWebToken(new CommonCryptographyManager(), clientId, $"https://login.microsoftonline.com/{tenantId}/oauth2/v2.0/token");
var signedToken = jwt.Sign(cert, Base64UrlHelpers.Encode(cert.GetCertHash()), false);

var form = new Dictionary<string, string>
{
    { "grant_type", "client_credentials" },
    { "client_id", clientId },
    { "client_assertion_type", "urn:ietf:params:oauth:client-assertion-type:jwt-bearer" },
    { "client_assertion", signedToken },
    { "scope", $"{resource}/.default" }
};
var tokenString = Client.Post($"https://login.microsoftonline.com/{tenantId}/oauth2/v2.0/token", form);
var token = JsonSerializer.Deserialize<AzureActiveDirectoryToken>(tokenString).access_token;
var authorizationHeaderContent = $"Bearer {token}";

Summary

No matter what method for gaining an access token you chose, now you will have a JWT. With that let’s look at one last request, and now one that is working:

POST https://{site_url}/_api/web/folders

Content-Type: "application/json;odata=verbose"
Accept: "application/json;odata=verbose"
Authorization: "Bearer ey..."

{
  "__metadata": {
    "type": "SP.Folder"
  },
  "ServerRelativeUrl": "documents/myFolder"
}

You guessed it? POST on the folders API of course creates a new folder and in the body, we are passing that we want to create, a folder with the relative URL “documents/myFolder”. With that, I will send you to the depths of the internet to find your exact use case, but keep your eyes peeled for some follow-up with more operations.

My First Shot at Sales Copilot

Sun, 29 Oct 2023 00:00:00 +0000

Microsoft is all in on AI. And that means we won’t get around it. But don’t get me wrong as well here, generative AI is cool! Naturally, by now the first customer request reached me and I’m skilling up on what the Sales Copilot for Dynamics CE can do right now (October 2023) and you will join me on that journey.

Setup

Setup of the Copilot SHOULD be straightforward, but as my tenant is not in North America the cross-border data processing agreement kept me searching for a while. It’s in the bottom right corner of the environment page. That is the first hurdle: Is this agreement really ok for your organization? But to be honest I think MS will roll this out worldwide, so that might be a matter of waiting.

After agreeing to that, the yellow box you see in the next screenshot will disappear and you can enable the assistant app by app or just everywhere with the checkboxes at the top. The settings are found at Sales Hub > App Settings > Sales Copilot (preview).

After a full refresh, the selected apps will now show the Copilot pane on the right side of the screen.

Settings

Apart from the apps you can also configure the fields to be evaluated for summaries and “catch up”. Catch-up shall evaluate audit history for you, well at least for up to 10 fields. In general, I think we will end up with specialized views for the correct field selection as this will be vital to the output of the AI and you probably don’t want to make any compromises with the requirements for a regular view.

The preview feature “Compose” has no settings at the time of writing.

Summarize

From now I will use this like a user. And as a user of ChatGPT, I expected chat to be a chat. Well, the first attempt did not go so well and the whole evening did not go any different: The “suggested requests” are the only requests this bot understands.

So this is the summarize request, you type the name of a record (use a slash “/” to get an autocomplete) and it will use the 7 fields from the view in settings to generate a short text.

Catch-up

You can use the catch-up feature with the phrase “show me recent changes for” and it will evaluate the 10 fields from the view in settings for changes in the last 7 days. For the sample, I logged in with a second user and made some changes to the opportunity.

Cool right, but the next sample does not work so great: I changed the estimated revenue twice and the bot only got the last change and failed to combine both changes into one (10000/12000 -> 15000).

News

“Get latest news for” lets you specify an account and get a list from Bing News for it. So essentially the same as visiting bing.com/news and then entering the account name into the search box. But you don’t need to open another browser tab and with “/” you get an autocomplete which is nice.

Today

The last of the chat function is “Prepare me for today’s meetings”. This shall evaluate notes and emails of the regarding record of appointments in the next 24 hours. So to use this feature, you would need a fully working Exchange sync to have some appointments and synchronized emails. Nevertheless, I tried to mock something up here.

Wow, that did not work so great! Because there was no regarding for the second appointment the bot did not list it at all. For me, that’s a problem, because who has all his appointments linked correctly? I might miss a meeting here! It should at least tell me it can’t prepare a summary, because there is no linked record. But ok, let’s try again with both records linked.

Ok, that’s better, but still, I need to select a record to get the summary. So if I have 5 meetings, I need to go through this 5 times…

Compose

First I had some trouble with this: You can’t use that feature from the Activities Grid, but from Timeline and Up Next it should work! But I’ve tried it with the Microsoft Account and that’s apparently also illegal, but at least Opportunity and Lead work, which would be in line with the configurations for summary and catch-up.

The second tab for Compose shows a summary of the email and offers to write a response, let’s try!

The email tone can be selected as well and finally with “Add to email” we can insert the text and of course change it to our needs.

Summary

I’ll be honest with you: I’m only mildly impressed by the chat features. Nothing in there seems to be more than “hardcoded” functionality. Everything from there can be achieved with well-designed forms (the Summary tab has that name for a reason) and Dashboards. This becomes a different story if, for example, the catch-up would allow you to query multiple records at the same time, imagine you have 10 open opportunities and Copilot can tell you which of these have changed over the last few days. For just one record I could simply visit the Audit History myself. But then again, I’m a professional, someone who has had little touch points with Dynamics yet might find a connection through these features! A chat is of course easier than to navigate forms if you don’t know what you are doing, so assuming it will get more options and maybe “multi-record features” the future looks brighter here.

In contrast, I liked the compose feature right away. There is still potential, at least in my testing it did not seem to leverage the context of the surrounding records and prior emails, but if you are like me and waste time on formulating while you know what you want to write, this can save actual working time. My experience with TLDR-bots says that they do work well, so I think we can assume that Copilot will be helpful with longer emails as well.

I want to use this opportunity to hint you to an AI that works much better: Bing Chat Enterprise. This can answer so many questions and the Sales Copilot would benefit from embedding the existing queries into this bot. With the speed this generative AI topic moves I can’t imagine such a powerful Copilot will spare Dynamics for long.

Service Bus 3: Processing Events with a plain Console App

Sun, 22 Oct 2023 00:00:00 +0000

In the last post, we already set up a working processor for Dataverse events. But what if AppServices and WebJobs are not preferred or are simply not possible for you? An example would be because you are on OnPremise infrastructure or Azure VMs or the Azure Kubernetes Services are used. There has to be an option to create a processor without such helper technologies, right? Yes, of course there is and here we are going to explore how.

General preparations

You can find the full project code here.

Something else often forgotten in this kind of article is the description of the used dependencies (here NuGets):

Azure.Messaging.ServiceBus => Contains the classes for Connecting to Service Bus
Microsoft.Extensions.Configuration/.Json => Used for reading appsettings.json
Microsoft.Extensions.Logging.Console => Using the Console as a Logging Output, may not be required if you use a different logging mechanism
Microsoft.PowerPlatform.Dataverse.Client => RemoteExecutionContext class for Deserialization
Azure.Identity => Only if you will use a managed identity if you are OnPremise, you can skip this

And of course, check out the first post of this series where we set up the service bus and our possibility of sending events to this service bus. So by now every time you create an account, a message should pop up in your subscription. Of course, it might also be helpful to have read the last post as well for some context (e.g. regarding managed identities) as this is probably the easiest method to set up a processor.

The project

We will start by creating the project. I am choosing .NET Core here as by now the CRM SDK for .NET Core (Microsoft.PowerPlatform.Dataverse.Client) has reached General availability and I expect Microsoft to push us further in the .NET Core Direction in the future.

Next, we install the NuGets to make sure the code will compile, here’s the list again for a quick copy: Microsoft.Azure.WebJobs.Core, Microsoft.Azure.WebJobs.Extensions.ServiceBus, Microsoft.Extensions.Logging.Console, Microsoft.PowerPlatform.Dataverse.Client.

And next is code. We only need two classes, program.cs and functions.cs. I chose the same split here as the WebJobs, technically of course this can all be written into the program.cs.

var config = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build();
var sbNamespace = config.GetSection("AzureServiceBus")["fullyQualifiedNamespace"];

var client = new ServiceBusClient(sbNamespace,new DefaultAzureCredential(), new ServiceBusClientOptions());

So just like with the WebJob I created a file called appsettings.json, marked it for CopyToOutputDirectory and its content looks like this:

{
  "AzureServiceBus": {
    "fullyQualifiedNamespace": "mariuswodtke-dev.servicebus.windows.net"
  }
}

This “fullyQualifiedNamespace” is passed to the ServiceBusClient alongside the DefaultAzureCredential for logging in with the managed identity and ServiceBusClientOptions which you might want to customize depending on your open ports as these do change whether you use TCP or WebSockets here.

As promised in the preparations, you don’t need to use a managed identity, if you use regular SAS keys like we did with Dataverse it will look like this.

var config = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build();
var sbConnectionString = config.GetSection("AzureServiceBus")["connectionString"];

var client = new ServiceBusClient(sbConnectionString);

{
  "AzureServiceBus": {
    "connectionString": "Endpoint=sb://mariuswodtke-dev.servicebus.windows.net/;SharedAccessKeyName=Processor;SharedAccessKey=REDACTED;EntityPath=dataverse"
  }
}

This of course has the problem, that the SAS key is in the appsettings.json, so this plain file would need to be guarded. For example, the risk of the secret being committed to source control is always present.

To gain such a connection string, you can copy the approach from the policy of the first post, just this time with the Listen claim.

var functions = new Functions();

var processor = client.CreateProcessor("dataverse", "account-export", new ServiceBusProcessorOptions());
processor.ProcessMessageAsync += functions.ProcessQueueMessage;
processor.ProcessErrorAsync += functions.ProcessError;

await processor.StartProcessingAsync();
Console.ReadKey();

Next, we are creating a processor on the subscription. Here the ServiceBusProcessorOptions might be interesting if you want to limit concurrent processing to 1 (MaxConcurrentCalls) like I suggested last time. Then we add the functions that will be the processors for the message and potential errors and finally call StartProcessingAsync to start processing. Because this method returns as soon as processing has started, I need to block the program from exiting afterward.

And finally, we need to take a look at the Functions class:

public class Functions
{
    private ILogger log;

    public Functions()
    {
        log = LoggerFactory.Create(_ => _.AddConsole()).CreateLogger("User");
    }

    public Task ProcessQueueMessage(ProcessMessageEventArgs args)
    {
        DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(RemoteExecutionContext));
        var message = serializer.ReadObject(args.Message.Body.ToStream()) as RemoteExecutionContext;

        log.LogInformation(message?.MessageName);

        return Task.CompletedTask;
    }

    public Task ProcessError(ProcessErrorEventArgs args)
    {
        log.LogError(args.Exception.Message);

        return Task.CompletedTask;
    }
}

So the ProcessError does nothing much for error handling, it just reports the error here, but you can do more advanced stuff here like immediately dead-lettering a message in case of certain errors.

But as mentioned in the WebJob post, JSON deserialization is problematic here. But .NET binary is as well! You shall not use the BinaryFormatter in .NET 6.0 anymore due to security issues. We can argue that we control the incoming messages, but the green squiggles are not beautiful and no static code review will like it, forming a constant source of needing to justify ourselves. So looking back at the problems mentioned last time: Newtonsoft.JSON has problems with some properties of RemoteExecutionContext not being settable. System.Text.JSON’s problems start with the DateFormats and continue with the Collections not being writable after initialization. That would need a lot of custom converters to fix this. The JavaScriptSerializer would work but is not supported for .NET Core. Luckily DataContractJsonSerializer does work as shown above (and it would work for a WebJob as well if you let the SDK pass you the message as a string).

IMPORTANT: The Message Format on the Service Endpoint in Dataverse needs to be set to “JSON” for this to work.

And then again there is no logic, just logging a value of the context out to the console to prove that the deserialization worked.

The result

So if we do a debug run now, the output should look a little something like this.

Of course I can’t make suggestions for deployment here because I don’t know where you are deploying to. But essentially you need to make sure the content of the bin folder is on the server and then make sure the .exe is always running when the server is running. It is not enough to just execute the .exe, because it will stop working as soon as the server restarts. Something like the Windows Task Scheduler can help to overcome this.

Summary

In this article, we formed a very generic processor for Dataverse messages in an Azure Service Bus. This processor can run on virtually any hardware and operating system. Just make sure the correct .NET runtime is installed and it will run. The project is only 60 lines of code in total, but of course, it is missing the most important thing: Your logic! So I won’t bother you anymore, let’s start coding.

[VIDEO] First steps in the Power Pages Maker

Sun, 15 Oct 2023 00:00:00 +0000

After we created a Power Page to serve external users with a website, this time we will explore some of the editing capabilities. In only a few minutes of video, the site will gain multiple pages with images, text and buttons.

Check it out here.

Powerautomate: Multiplexing and App Association

Sun, 08 Oct 2023 00:00:00 +0000

Are you using PowerAutomate (Flows) with Data? Then get ready for this change by Microsoft!

Multiplexing

Multiplexing is something that forbids leveraging the fact that only the owner of the flow needs a Flow Premium license to offer automation to other users. If premium connectors are used within the flow and it offers direct value to other users, those users will need a Flow Premium license as well. There is a hole in this though: If one of the two ends (trigger or action) is directly related to a Dataverse app and the value is provided to the users of this app, the entitlement for this value can be derived from the license they have for Dataverse (e.g. Sales Professional, Customer Service Enterprise and so on). In some situations, you still need to be careful, e.g. think about a Flow that triggers from Dataverse and stores a document in Sharepoint. Now if this is stored for the Dataverse user that should be no problem, but if the user using the document is not a Dataverse user they might need a Flow Premium license to be entitled to gain the value from that flow.

What’s new?

We will actually have to mark the flows that fall under this exception. That’s not too hard, it’s only the effort I’m just afraid of the effort for existing implementations with dozens or even a hundred flows. But let’s do this, select a Flow, navigate to the Details and you will find the App Association section at the bottom right. Then Add Association and then select one or more of your Dataverse Apps. After saving the Apps will be displayed in this view as well as the Details of the Flow.

And that’s it! Now repeat this for all Flows and think about what apps they relate to. If you can’t pin a certain app, that might be the red flag that you are currently multiplexing and the users “using” the Flow might need a license.

When does it need to be done?

Microsoft announced notifications going out on October 15th and the enforcement (the flow being turned off) will happen after 90 days. So this means you have until after Christmas before this needs to be completed. This should be a sufficient time frame to perform the association, but still needs to be planned because it will be forgotten otherwise. The official documentation is found here, check it for updates regarding the timeline.

Summary

This was something completely different for me, I hope you did not get bored with all that legal talk. While we talk about that: Be aware that nothing here is legal advice and the licensing guides do change regularly which may render the statements made here useless. For the actual matter: The change here is not too big and it should be possible to find a few hours to complete the app association within 90 days. Yet you should be aware and to be honest I think the idea of this move is for you to reevaluate if you are multiplexing and should buy additional licenses.

Service Bus 2: Processing Events with a WebJob

Sun, 01 Oct 2023 00:00:00 +0000

In the first post of this series, we started with sending Dataverse Events to a Service Bus. Of course that in itself does not have any value, we need to do something with these Events! So in this article, we will create a processor for these events, specifically a WebJob on Azure.

General preparations

You can find the full project code here.

Something else often forgotten in this kind of article is the description of the used dependencies (here NuGets):

Microsoft.Azure.WebJobs.Core => General Webjobs stuff in Program.cs
Microsoft.Azure.WebJobs.Extensions.ServiceBus => Bindings to Service Bus
Microsoft.Extensions.Logging.Console => Using the Console as a Logging Output, may not be required if you use a different logging mechanism
Microsoft.PowerPlatform.Dataverse.Client => RemoteExecutionContext class for Deserialization

The project

And next is code. We only need two classes, program.cs and functions.cs, I’ll start with program.cs

var hostBuilder = new HostBuilder();
hostBuilder.ConfigureWebJobs((context, builder) => {
    builder.AddServiceBus(options => options.MaxConcurrentCalls = 1);
});

These first lines contain an important concept used in WebJobs: The HostBuilder. It configures the WebJob before it is run, this allows the WebJobs to be “triggered” and not just be a continuously running application. Well actually they are of course but things like waiting for a new message are not an explicit code operation but a definition within the Functions. We are adding a Service Bus here, we will discuss later how the WebJob knows which Service Bus we want to connect to. The option for MaxConcurrentCalls = 1 makes the job process one message after another. This is great for debugging and usually makes sure the receiving database does not get overwhelmed. But it can also lead to a bottleneck within your processor. An idea for this I have seen in projects is to make this a variable in the appsettings that is set to 1. The value is then either scaled in deployment or directly in the running AppService on Azure by an Administrator. If you connect to Dataverse make sure to not use a value bigger than 10 because a) it won’t scale well and b) you might get issues with the ServiceClient since you cannot open to many connections to Dataverse.

hostBuilder.ConfigureLogging((context, b) =>
{
    b.AddConsole();
});

Next is logging, I’m just using the Console here, but I still wanted to include this to the post, to make you aware that there are more options here, like Application Insights if you want to stay within Azure. Once everything is configured we build and run the HostBuilder. This RunAsync() will block the console indefinitely and usually it throws here if you misconfigured something.

var host = hostBuilder.Build();
using (host)
{
    await host.RunAsync();
}

Ok, over to the Functions.cs. As the name suggests, this is the entry point for our functionality.

public static void ProcessQueueMessage([ServiceBusTrigger("dataverse", "account-export", Connection = "AzureServiceBus")] RemoteExecutionContext message, ILogger log)
{
    log.LogInformation(message.MessageName);
}

Technically, these are only 2 lines of code, but a lot is going on. I’ll start with the ServiceBusTriggerAttribute, the first parameter (“dataverse”) here is the topic and the second one (“account-export”) is the subscription. The Connection parameter (“AzureServiceBus”) is just a reference to the settings, so a quick dive into the appsettings.json file.

{
  "AzureServiceBus": {
    "fullyQualifiedNamespace": "mariuswodtke-dev.servicebus.windows.net"
  }
}

So the parameter refers to this setting. The setting can directly contain a connection string (“AzureServiceBus”: “Endpoint=sb://mariuswodtke-dev.servicebus.windows.net/;SharedAccessKeyName=Dataverse;SharedAccessKey=REDACTED;EntityPath=dataverse”) or an object as shown that spares the secret. Again I will refer you to a little later how that connection will actually work if we only pass the namespace URL of the Service Bus.

Back to the Functions.cs code, the ServiceBusTriggerAttribute decorates the real parameter of the function RemoteExecutionContext message. RemoteExecutionContext is part of the Microsoft.Xrm.Sdk namespace and is the object we passed to the Service Bus, the WebJobs SDK will automatically deserialize it.

IMPORTANT: If you followed the first post exactly, you will receive an error here. This is because Newtonsoft.JSON refuses to deserialize RemoteExecutionContext. There is a simple solution to this: Change the Message Format to “.NETBinary”, this format will be deserialized. If it needs to be JSON for some reason you can skip the automatic deserialization by specifying message as string (string message) and then deserializing yourself. The JavaScriptSerializer does work, but is exclusive to .NET Framework. (Check the post about plain console processing for a working JSON solution)

Setting up the App Service

I will do this via the Azure Portal, after all, if you do something in Azure the first time around, it’s the easiest way to achieve a result quickly.

So I used the + Create in my Resource Group, searched for “Web App” and filled the first tab. Some notable settings are the Runtime Stack which I matched to the project runtime. For the App Service Plan, I created a plan in the Free tier, not something to use for production but a great option for a first test. Web Apps can be moved between App Service Plans if you later create a paid plan.

Now in the newly created App Service (Web App) navigate to Identity and turn the System Assigned Managed Identity on.

Handling Authentication

And now we lift the secret of how the authentication works! So the WebJob SDK will automatically use the Managed Identity we just assigned, so the only thing we need to make sure is that this Managed Identity is authorized to access the Service Bus. This is done in the IAM Section of the Service Bus.

IMPORTANT: This needs to be done on the whole Service Bus (Namespace). The IAM Section is also available on the topic, but the WebJobs SDK wont be happy with that. This is one of the reasons I suggested a seperate Service Bus per stage. If that is not possible, you can fall back to the Shared Access Policies of the topic, but you will need to store them securely, for example in an Azure Key Vault.

And we can do the same thing locally as well! Just authorize your own account as Azure Service Bus Data Receiver and then in Visual Studio under Tools => Options, find the Azure Service Authentication and authenticate your account. Now Visual Studio can provide this Identity to the WebJobs SDK and you are ready for a debugging run of your

NOTE: I’ve used a specific account for my Visual Studio here because my real account is not in the same Tenant, which often leads to problems and requires the components to manually set the tenant id, which usually means injecting the Identity manually. In this situation its easier to just create a new account, assign it a password and then enable that for the Azure Resources you want to access from your Code.

The result

Now it’s time for a debug run, but well, there is not much logic in my function. It just prints the MessageName to prove that the deserialization works. Note the interfaces implemented by RemoteExecutionContext, it does implement the IPluginExecutionContext that you will already know from regular plugins. So everything is as expected, the InputParameters will contain the “Target”, if you have configured a PreImage it will be in the PreEntityImages and so on.

Deploying

After the successful debug let’s deploy. While later you should look into Pipelines with GitHub or Azure DevOps, a first deployment (or publish) can happen directly from Visual Studio.

After the deployment, you can check the logs at the App Service. Navigate to WebJobs there and select the Logs Icon.

Summary

So I guess it’s your turn now to implement the real logic. In this post, we created a .NET Core Console Application, configured and deployed it as WebJob, worked on a passwordless authentication and finally deployed it to Azure to process the messages. So the only thing left to do is to implement what shall actually be done with the message. Shall it be written to a third database/application? Do you want to enrich the Dataverse record? Maybe some advanced processing? I guess your stakeholders have something ready for you!

[VIDEO] Setting up your first Power Page

Sun, 24 Sep 2023 00:00:00 +0000

Do you want to provide external users with a website fed with data from Dataverse? Instead of building APIs or synchronization mechanisms with the website’s database, you can also use Power Pages! This first video in the Power Pages series walks through a setup, even if you don’t have a Dataverse Environment yet.

Check it out here.

Service Bus 1: Exporting Dataverse Events

Sun, 17 Sep 2023 00:00:00 +0000

Are you aware of the Service Endpoints of Dataverse? These are integration options to process Dataverse events like Create and Update outside of Dataverse/PowerPlatform. This “Outside of Dataverse” can be things like an API hosted anywhere, but it can also be an Azure Service Bus and that is what I want to discuss here.

What is a Service Bus

I will skip deeper explanations here, just the most important concepts: Service Bus is a message queueing service. So a queue in Service Bus is really what the name says, a queue. The sender pushes messages in and the listener extracts them from oldest to newest. The second concept is a topic. The sender still pushes messages to that topic, but from here the message can go into 0 to n subscriptions from where the listener(s) read from, still, oldest to newest. Think of it like a front-desk queue: You arrive, voice your request and get told to which queue you should enqueue to get the right employee for your request. But unlike the real world, the front-desk assistant can also clone you and enqueue you at 2 or more “queues” (aka subscriptions) at the same time. The third important concept is buffering. A message is not gone from the queue as soon as it is read, instead it needs to be completed. That means if there is an error in processing the message, it won’t be completed and therefore will be read again after the timeout period for processing is over. You can configure what will happen to messages that can’t be processed within x attempts. Those messages can (and should) be moved to a dead-letter queue, where you can revisit them, for example after fixing a bug in your code.

Why not simply use Plugins instead

Usually, you would use a Plugin to process the Dataverse events but some key indicators might lead you towards an Azure Service Bus and a Listener instead:

You are integrating a system that has outages. The Service Bus will buffer the messages during the outages.
You are integrating a table that has frequent operations or a considerable amount of data. The Service Bus will buffer the messages and the listener will push them over at the rate the other system can receive them.
You need libraries and don’t want to use the unsupported ILMerge. A listener deployed to Azure (or any OnPremise Server) can use as many NuGets and Libraries as it likes.
You are integrating a system that is behind firewalls that do not allow inbound connections. The listener can be deployed inside the network, connecting only outwards to pull messages from the Service Bus instead of having them pushed into the network.
You need to be able to deploy fixes during business hours. Service Bus will buffer the messages, while a Dataverse deployment would yield a disturbance for the users.

So with these arguments, a lot of integration topics gain from using a Service Bus. Then there are almost always benefits if you can not or do not want to use Power Automate with its own retry mechanisms.

Creating a Service Bus

We will create the Service Bus in the Azure Portal. Use the search box at the top to search for the Service “Service Bus”, select it and then “+ Create”.

I suggest using the Standard SKU. Premium is quite expensive and will only be viable for really big message volumes, volumes so big that we would question Dataverse as the Datastore for that amount of transactions anyway. On the other hand, Basic is quite cheap but lacks the Topics feature which is super handy. Also, I do suggest creating different Service Bus Namespaces for different environments/stages of Dataverse. Based on the properties in the deployment, Microsoft might disagree on this, but splitting production and dev/test resources is always a good idea.

Next is the topic, which I’ve named “Dataverse” here: In another post about deployment we will explore the fact that having more topics or queues as endpoints increases the effort of deploying them. Therefore it makes sense to at least group the matters to not have more than a handful of topics for Dataverse in the Bus. Just to have a sample: In a project, we did not stick to a single topic and introduced a second one when an integration needed a lot of entities and triggered on update of many fields of these entities. This would have pushed messages to existing subscriptions for fields the connected logic should not trigger. That could have been filtered out in code, but balancing the effort with a new endpoint was the easier option.

The Subscription is named “account-export” here, mimicking an integration. Since we will be pushing more events in the future, this subscription needs a filter as well. Since they will not show well, the properties to filter on are “http://schemas.microsoft.com/xrm/2011/Claims/EntityLogicalName" and “http://schemas.microsoft.com/xrm/2011/Claims/RequestName". And maybe if you are not using separate Bus/Topic as suggested: “http://schemas.microsoft.com/xrm/2011/Claims/Organization".

For simple scenarios, you can just filter on a single entity like “account”. For this just set a correlation filter like in the screenshot. Sometimes you will also want to filter on the Message “Create” or “Update” if there is maybe also a Delete event being pushed to the Bus! This can be handled with the SQL filters:

"http://schemas.microsoft.com/xrm/2011/Claims/EntityLogicalName" = 'account' AND
(
	"http://schemas.microsoft.com/xrm/2011/Claims/RequestName"='Create' OR
	"http://schemas.microsoft.com/xrm/2011/Claims/RequestName"='Update'
)

And lastly, we need a Policy on the topic to allow Dataverse to push messages. We will only need the send permission for now, listening will be part of the next post.

Configuring the Service Endpoint

Now we need the Plugin Registration Tool. This can be included as NuGet to an existing Project or you download it from here (“Download Package”), change the extension from .nuget to .zip and unpack it. The path for me looks something like “\.nuget\packages\microsoft.crmsdk.xrmtooling.pluginregistrationtool\9.1.0.184\tools\PluginRegistration.exe”. Of course things like the version might differ for you. Connect to your environment and then Register a new Service Endpoint with the Policy we just created. Please note that the wizard did not recognize it being a Topic and that I changed the format from .NET Binary to JSON for the sake of this tutorial. But I assume you already have a favorite anyway, one tip if you can use WebJobs: .NET Binary works well here! But I don’t want to overcomplicate that here: When doing your first development, stick to your preferred format for now, you can still change it until you have the first listener done.

And from now everything runs as if we were registering a normal plugin. Just be sure to make it asynchronous.

Checking the results

Ok, everything is set up now, let’s create an Account and then we should find it in the Service Bus.

After creating the Account, the Topic lists a Message in the subscription. Using the Integrated Service Bus Explorer at the Subscription lets us peek at the message and indeed it is our Account. Here is also a picture of the Properties, this is important because the Filters we created earlier do not work on the body of the message, only on the properties! I cannot filter on body.target.name being present.

Summary

This was obviously only part one of the journey. We have now exported messages in a fixed format set by Dataverse, but someone needs to interpret and process these messages. That is something we will discuss in future articles and we will also cover how this can be deployed between environments. But for now, let’s celebrate our achievement for today: We exported Dataverse events to Azure without writing a single line of code!

Advanced LINQ Queries for Dataverse (1)

Sun, 10 Sep 2023 00:00:00 +0000

When it comes to performance optimization I have a single piece of advice for you: Reduce the amount of queries, period. Forget about parallelizing, List vs. Array, a StringBuilder or loop unrolling, if you have a loop with a Retrieve inside, it’s almost always magnitudes more efficient to look at queries than anything else. Just because of the latency. If you have a loop of 10.000 items with a retrieve inside which takes 50ms, that’s 500 seconds. There are of course other methods to discuss like ExecuteMultiple and BypassCustomPluginExecution, but queries are the easiest and most efficient optimization to try.

Select Many Relationships

Using the Navigation Properties of Earlybounds you can load a related entity. The following query starts at the account and loads all related contacts.

var contacts = ctx.AccountSet
    .Where(_ => _.Id == accountId)
    .SelectMany(_ => _.contact_customer_accounts)
    .Select(_ => new Contact { FirstName = _.FirstName, LastName = _.LastName })
    .ToList();

That alone does not yield an immediate optimization, because I could have expressed that as well with a “simple” query.

var contacts2 = ctx.ContactSet
    .Where(_ => _.ParentCustomerId.Id == accountId)
    .Select(_ => new Contact { FirstName = _.FirstName, LastName = _.LastName })
    .ToList();

Select Relationship

var contact = ctx.AccountSet
    .Where(_ => _.Id == accountId)
    .Select(_ => _.account_primary_contact)
    .Select(_ => new Contact { FirstName = _.FirstName, LastName = _.LastName })
    .FirstOrDefault();

This sample is a little different and this time it’s an actual saving. We are selecting a single value relationship here, the primary contact of an account. If we do the same with simple queries, we will need two queries. Doing it with a single query saves the latency once, but will put a little more load on the database to perform the join, which is usually far less than a latency.

var account = ctx.AccountSet
    .Where(_ => _.Id == accountId)
    .Select(_ => new Account { PrimaryContactId = _.PrimaryContactId })
    .First();

var contact2 = ctx.ContactSet
    .Where(_ => _.Id == account.PrimaryContactId.Id)
    .Select(_ => new Contact { FirstName = _.FirstName, LastName = _.LastName })
    .FirstOrDefault();

Sadly this method still has some shortcomings, what if I want both values from the contact and account? The following code DOES NOT WORK, it will only fill the FirstName property.

var contacts = ctx.ContactSet
    .Where(_ => _.Id == contactId)
    .Select(_ => new Contact { FirstName = _.FirstName, contact_customer_accounts = _.contact_customer_accounts })
    .ToList();

Joining

If we need both entities, we will have to switch to query syntax. I like to use the method syntax a lot because in my opinion, it’s quite readable for simple queries, but for these larger ones, arguably, query syntax is the better choice.

var model = (from contact in ctx.ContactSet
            join account in ctx.AccountSet on contact.ParentCustomerId.Id equals account.AccountId
            where contact.ContactId == contactId
            select new
            {
                Contact = new Contact { FirstName = contact.FirstName },
                Account = new Account { Name = account.Name }
            }).FirstOrDefault();

That sample outputs both the Account and Contact here. There are some things to observe here. First, I’ve used a dynamic here for the select (new {...}). This only works within the calling method, if you need to return both values to another method, consider making a small class or struct. Or you could return a Tuple<Contact,Account>, but access with tuple.Item1 and tuple.Item2 is arguably not very readable.

Also, notice how I’ve used contact.ContactId in the where clause and account.AccountId in the join. Using contact.Id is legal in the simple query below, but if you are working with a Join, you will have to use the long id names instead.

var cont = (from contact in ctx.ContactSet
                where contact.Id == contactId
                select new Contact { FirstName = contact.FirstName }
                ).FirstOrDefault();

Another cool feature here is the ability to filter on the related entity. So in the sample below, we are only caring about the Contact, but we don’t have the ID of the Account yet. A simple query could mean that we first get the Account with that exact Name and then query by ParentCustomerId, but with a join, we can filter directly by account.Name.

var cont = (from contact in ctx.ContactSet
                join account in ctx.AccountSet on contact.ParentCustomerId.Id equals account.AccountId
                where account.Name == "Alpine Ski House (sample)"
                select new Contact { FirstName = contact.FirstName }
                ).ToList();

Putting it all together

The last query is everything in one: We will do two joins by also looking at the PrimaryContactId of the Account. We will also query by a field on the account and we will return all 3 records, the contact, its account and the primary contact of the account.

var model = (from contact in ctx.ContactSet
                join account in ctx.AccountSet on contact.ParentCustomerId.Id equals account.AccountId
                join primaryContact in ctx.ContactSet on account.PrimaryContactId.Id equals primaryContact.ContactId
                where account.Name == "Alpine Ski House (sample)"
                select new
                {
                    Contact = new Contact { FirstName = contact.FirstName },
                    PrimaryContact = new Contact { FirstName = primaryContact.FirstName },
                    Account = new Account { Name = account.Name }
                }).ToList();

Now it gets a little special: Let’s assume we have 2 contacts that have that account as ParentCustomer. That means that the query will return 2 results. And that also means 2 Contacts, 2 Accounts and 2 PrimaryContacts. So you might need to post-process that result before handing it back to logic, e.g. by grouping by Account.Id. Or the logic simply does not care. Need a sample? A tool exporting a .csv file with a row for each contact with some values from Account and PrimaryContact simply would iterate through the results and write down the values.

Summary

Relationships and Joining are a great way to reduce queries and thus latency. Before thinking about any other optimization for slow Tools, APIs or Plugins, check your queries first and think about their dynamics. If query1 returns 100k results and for each result, another query2 has to be fired that is a BIG deal. We will soon look into optimizations for writing data to Dataverse as well to optimize you further!

Excel: Exporting deep joins and lost of rows

Sun, 03 Sep 2023 00:00:00 +0000

Hopefully, this article just comes out as a “short tip” regarding Excel and Dynamics. I do assume you know the standard tools, you can select the Export to Excel option on a grid to open the records in Excel. There are multiple options with dynamic and static worksheets as well as an online option. The other thing is the Excel Templates, they can predefine some evaluations and visualizations of the data.

The limitations

There are two limitations I want to discuss here: The options won’t export more than 100.000 rows and you can only show columns one lookup deep. The first limitation is pretty clear, but let me give you a sample for the second one.

Let’s assume you have a contact view. You want to display the annual revenue of the account (parentcustomerid), that’s no problem for Dynamics. But if I now want to display the email address of the account’s primary contact (primarycontactid) as well, that’s not possible with the OOTB options.

And since we can’t define the view, we can also not export it to Excel.

NOTE: You can define such a view with the FetchXml Builder in the XrmToolbox, but it will not behave correct. E.g. it wont display a name for the “illegal” column and in my testing the view also broke the Excel features.

A solution

We can overcome both problems with the PowerQuery feature of Excel. PowerQuery is the language that powers PowerBI (read more here) and does not use FetchXML to get data. Instead, it uses the read-only SQL Endpoint and that means it does not share many of the limitations of FetchXML based integrations.

So I wrote the query in SQL, entered it in the Get Data dialog, authenticated to Dynamics and then loaded the data. See below, pictures tell more than a thousand words here.

NOTE: The concrete requirement here involved 9 joins (one to the parent entity and then 8 different lookups from there) and a few hundred thousand rows, which took the SQL Server 1-2 minutes to refresh the worksheet.

The catch

Well, the catch is that you can’t upload it to Dynamics! This file gets all the data and then the user has to define the filters in Excel. That can be a good or a bad thing based on your users. Also, while you can use it for importing changed data to the base entity with a data map, there is nothing like a dynamic worksheet here, as mentioned, the SQL connection is read-only.

Summary

To summarize, with the SQL endpoint of Dynamics you can export more than 100.000 rows and as many joined records as you like to Excel. But in return, you are losing a lot of the integration that lies within the Excel features because you are now accessing the SQL endpoint raw. While it can be the only option to generate such an Excel for the user, the acceptance of them having to open a file, refresh the data and then filter it to their needs might vary a lot based on your organization. Do your users love Excel anyway? Then this will be second nature to them. Are they used to Dataverse and the Advanced Find filters? They might simply hate it…

PowerBI: Embedding a Report to a form

Sun, 27 Aug 2023 00:00:00 +0000

In the last post of the PowerBI series, we added a Dashboard to Dynamics. I recently came across a shortcoming of this approach. It lacks the context menus. So for example the Export data button is missing. Also. you will have to provide the filters within the visuals. So for example via the cross-filtering feature of PowerBI we were able to filter by country by clicking on it in the pie chart, but for example by city would have not been possible!

Prerequisites

I suggest following the post PowerBI: Publishing a first Dashboard to Dynamics because that already creates a Report from which the Dashboard is created. If you bring your own Report, make sure the PowerBI Embedding Feature is enabled on your environment under Settings -> Features -> Embedded Content.

Add Report to Dynamics

If you already tried to add the Report to the form, but there were none available, that’s because you need to add them to the solution first!

Embedding the Report

Now the Report is available in the Form Editor. Select it from the Components -> PowerBI Section. And that’s it.

The Workspace

Then the experience wasn’t so straight for me: The embedded report displayed weird errors about related data, but my Report in PowerBI did not! Turns out, Dataverse created its workspace and copied over the report and dataset. And that dataset needed a refreshing in my case to display correct data. So make the report work again in this new workspace and it should then also work in Dynamics. I can imagine other problems here like a broken data source connection that needs to be reauthenticated.

The Result

Since the Dashboard from last time was pretty similar to the report, this embedding looks quite similar to the result of the previous post. But there are subtle differences. Notably for my use case, the Export data button is present. But as we saw in the options in the Form Editor, we can also present the_Filter Pane_ to the user, opening more flexibility in using the report.

Summary

I still see so much to discuss here: We need to talk about the JSON filter string option. Likewise, we need to get some external data in to show how this can display data that we do not want to import to dynamics and that also does not comply with the requirements for displaying it as an external table. And finally, this post dug up the question “Is there anything I need to look out for when deploying this?”

But on the plus side: If you have a ready-made report and your user should see it in Dynamics, we now have 2 great options available. The embedded report seems to be the more powerful choice, but it may be more natural for the users to have a Dashboard if you are not working with a prefiltering.

Without a NuGet: Certificate Authentication with AAD and C#

Sun, 20 Aug 2023 00:00:00 +0000

Now this is something different and very specific. So I am writing this series on Sharepoint and how to integrate it from the Dynamics Backend. And Sharepoint Online has a strange restriction for the current state-of-the-art Azure AD App-Only authentication. It only works if you use a certificate and not with a secret.

Authenticating with a Secret

Let’s first start with this rather easy method. There are lots of resources on the internet covering this, but it’s still important to cover it as a base because a lot of concepts will be similar. Of course, we will be doing it without a NuGet.

Essentially we just need to send a POST request to https://login.microsoftonline.com/{yourtenantid}/oauth2/v2.0/token with a form content. The form content has the following 4 parameters:

"grant_type": "client_credentials"  
"client_id": {yourappid}  
"client_secret": {yourappsecret}  
"scope": {whereyouareloggininto}/.default

TenantId, AppId and AppSecret can be retrieved from the AppRegistration you created.

NOTE: Lost here? Check the section “The Portal Way” of this article for some pictures and descriptions on how to create an app registration and where the Secrets section is.

The scope might be a little more difficult. Usually, it’s the URL of the app you are trying to log in. So for Dynamics this is something like XXX.crm.dynamics.com and for Sharepoint, it is the root URL of Sharepoint. So for example I am trying to log in to the site https://crm553494.sharepoint.com/sites/CRM that means my scope is https://crm553494.sharepoint.com/.default. Don’t be fooled here, just because you authenticate to the whole Sharepoint does not mean you are authorized for all sites within it. And remember, this won’t work due to the restriction that only authentication with a certificate is allowed with Sharepoint!

What you will get back is a JSON object that contains a property “access_token” that you will pass onto the real application in the header “Authorization” and the format “Bearer {access_token}”.

Now as C#:

public string PerformSPRequest(string tenantId, string resource, string clientId, string secret, string site) {
    string token;
    var form = new Dictionary<string, string>
    {
        { "grant_type", "client_credentials" },
        { "client_id", clientId },
        { "client_secret", secret },
        { "scope", $"{resource}/.default" }
    };
    FormUrlEncodedContent formContent = new FormUrlEncodedContent(form);
    var url = $"https://login.microsoftonline.com/{tenantId}/oauth2/v2.0/token"
    using (var aadClient = new HttpClient()) {
        var response = aadClient.PostAsync(url, formContent).Result;
        var responseContent = response.Content.ReadAsStringAsync().Result;
        response.EnsureSuccessStatusCode();
        token = new JavaScriptSerializer().Deserialize<AzureActiveDirectoryToken>(tokenString).access_token;
    }

    using (var spClient = new HttpClient()) {
        spClient.DefaultRequestHeaders.Authorization = $"Bearer {token}";
        var content = "..."
        var spUrl = $"{resource}/sites/{site}";
        var spResponse = spClient.PostAsync(spUrl, content).Result;
    }
}

public class AzureActiveDirectoryToken
{
    public string access_token { get; set; }
}

NOTE: As already mentioned, Sharepoint will reject the token due to it being created with a secret.

Debugging a token

This might become relevant when you are questioning why a token does not work. Paste your token to the website jwt.ms

So a token consists of a header (red), a body (blue) and a footer/signature (green). The header is general information like that we are dealing with a JWT token and that RSA256 was used as an encryption algorithm. The body contains all the relevant information, like for whom (sub) and by whom (iss) the token was issued, how long is it valid (exp) etc. and so on. The footer is a signature of the body. This makes sure no one alters the body, for example extending the validity of an expired token. If you then check the signature against the body it would be invalid. And in the end, all 3 parts are encoded as Base64 and split with dots, this is why they are so easy to analyze since the body is just a Base64 encoded JSON.

Also, check the claims tab, this will explain to you how Sharepoint knows this is a token generated by a secret: The property “appidacr” gives it away!

Generating a certificate token with a NuGet

There are multiple that can do it, but the NuGet Microsoft.Identity.Client is the current official one by Microsoft.

using Microsoft.Identity.Client;
using System.Security.Cryptography.X509Certificates;

public string PerformSPRequest(string tenantId, string resource, string clientId, string secret, string site) {
    byte[] bytes = Convert.FromBase64String(secret);
    var cert = new X509Certificate2(bytes);

    var client = ConfidentialClientApplicationBuilder.Create(clientId)
        .WithCertificate(cert)
        .WithAuthority($"https://login.microsoftonline.com/{tenantId}").Build();

    var authenticationResult = client.AcquireTokenForClient(new string[] { $"{resource}/.default" }).ExecuteAsync().Result;

    using (var spClient = new HttpClient()) {
        spClient.DefaultRequestHeaders.Authorization = $"Bearer {authenticationResult.AccessToken}";
        var content = "..."
        var spUrl = $"{resource}/sites/{site}";
        var spResponse = spClient.PostAsync(spUrl, content).Result;
    }
}

As you can see I am passing the Certificate as a Base64 string here because that’s easier to store for me with Dynamics. The constructor of X509Certificate2 can also take a file and you can work with a certificate store as well! Nothing much more to say here, its just straightforward getting a token.

Why I don’t want to use the NuGet

Essentially because I’m a Dynamics Developer. Dynamics 365 historically takes exactly one assembly for plugins and everything has to be contained inside apart from the system libraries like System.Net and so on. That’s because they are loaded to an isolated sandbox that will only contain your library. Well not quite… Because the plugins you are running need to be provided with a connection to Dynamics, Microsoft’s CRM SDK is loaded as well and some more libraries, like Microsoft.IdentityModel.Clients.ActiveDirectory which is likely used for the login. And this library can achieve a certificate authentication! Unfortunately, Microsoft has also marked this library deprecated in favor of Identity.Client, so you would rely on it. Also, this is a pretty specific dependency that could just stop working if Microsoft migrates to Identity.Client and we have no idea when it will break. So not a good option for production use cases.

But what about Microsoft.Identity.Client? It’s not loaded to the sandboxes, we could ILMerge it to our assembly! Yes, but that’s unsupported. The new Dependent Assembly Plugins feature can actually include this by packaging it together with the real assembly as a NuGet to upload. And it does work: In my first shot post about this, this was the exact NuGet to include because of this exact challenge with Sharepoint.

But this feature is in preview at the time of writing, none of the tooling other than the PRT (Plugin Registration Tool) supports it and frankly, it does not go that well with the existing project.

When discussing this option again a colleague opened my eyes here with the comment “Did you run this with Fiddler and check what they [note: Microsoft] are doing?” Well, I closed as many programs as possible, ran an Integration Test from Visual Studio and had the result that we are going to talk about next.

Doing it without a NuGet

So what is used here is quite cool: Instead of a classic 3-way handshake where AAD sends a challenge, you encrypt it with the Certificate and send it back, a self-signed JWT token is used.

This token is issued by me for me and is signed by myself. When it is sent to AAD, it can check with the public part of the certificate that the signature is correct and can therefore be sure that the token, which only has a short lifespan, is issued by the correct client.

To generate this token I went hunting in Microsoft’s NuGet. Luckily they do publish it open-source, therefore I was just able to grab relevant parts from there. I don’t want to make a super long exhibit here, so I will provide you with links to all relevant files in their repository instead and only print my part to the article:

NOTE: I modified and stripped the classes to then not need other things like System.Text.Json and for example the Base64UrlHelper we only need Encode.

With these Classes in place, the code from above looks like this:

using System.Security.Cryptography.X509Certificates;

public string PerformSPRequest(string tenantId, string resource, string clientId, string secret, string site) {
    byte[] bytes = Convert.FromBase64String(secret);
    var cert = new X509Certificate2(bytes);

    var jwt = new JsonWebToken(new CommonCryptographyManager(), clientId, $"https://login.microsoftonline.com/{tenantId}/oauth2/v2.0/token");
    var signedToken = jwt.Sign(cert, Base64UrlHelpers.Encode(cert.GetCertHash()), false);

    var form = new Dictionary<string, string>
    {
        { "grant_type", "client_credentials" },
        { "client_id", clientId },
        { "client_assertion_type", "urn:ietf:params:oauth:client-assertion-type:jwt-bearer" },
        { "client_assertion", signedToken },
        { "scope", $"{resource}/.default" }
    };
    var tokenString = Client.Post($"https://login.microsoftonline.com/{tenantId}/oauth2/v2.0/token", form);
    var token = JsonSerializer.Deserialize<AzureActiveDirectoryToken>(tokenString).access_token;

    using (var spClient = new HttpClient()) {
        spClient.DefaultRequestHeaders.Authorization = $"Bearer {token}";
        var content = "..."
        var spUrl = $"{resource}/sites/{site}";
        var spResponse = spClient.PostAsync(spUrl, content).Result;
    }
}

Summary

So the key to doing a simple certificate authentication with Azure Active Directory was the “client_assertion_type” being jwt-bearer and then the task is to create a valid bearer token. The fact that Microsoft publishes its code is a big help here since the relevant classes are not that big, the stripped classes are only around 400 loc without comments.

Therefore skipping the NuGet is valid for the use case of authenticating with a certificate and has much fewer side effects than switching to Dependent Assembly Plugins and will help us big time in the Sharepoint Integration (Extended) series.

Cookies

Thu, 17 Aug 2023 00:00:00 +0000

In general, this site is optimized to use no cookies other than functional. A functional cookie for example saves whether you selected the dark or the light theme. However, some third-party functionality might not share this paradigm. The following sections try to explain the implications of enabling certain features with the toggles. Remember that you can always disable the toggles again and the corresponding third-party scripts will no longer be loaded, but also be aware that cookies that those scripts set remain in your browser until you clear them.

Comments

Comments on this blog are delivered by Giscus, which uses Github as the Backend. While Giscus itself is an open-source project that claims to use no tracking, their servers are hosted in the US, making you communicate overseas if you visit from Europe. Also if you want to leave a comment you will have to log in to Github, which is owned by Microsoft. Check both Giscus and Github for their privacy statements before you decide to enable comments.

PowerBI: Publishing a first Dashboard to Dynamics

Sun, 13 Aug 2023 00:00:00 +0000

Did you know PowerBI Dashboards can be published to Dynamics? It’s a great feature! Not only does PowerBI have many options for displaying data that the regular Dynamics Dashboards lack, but it also has more options in styling. Not to speak of the possibility of integrating data from non-Dataverse sources.

Step 1: Connecting to Dataverse

If you haven’t already, first install PowerBI Desktop. That can be done at the Microsoft Store or app.powerbi.com by selecting the Download Icon at the top right. Technically I don’t think we will be using any feature today that would not work in the browser version at app.powerbi.com. However, a best practice from my analytics colleagues: You are going to need a feature of the Desktop version sooner or later, so simply always use PowerBI Desktop.

When creating a new Report, in the top ribbon, select Get Data. Here you can choose from a lot of connections, for this post, we will use Dataverse. After entering your credentials you will be presented with a screen holding all available Dataverse instances and all tables within it. For the demonstration, I chose Account and Contact, since these 2 have a relationship that we will display later.

Step 2: Transform Data

Here we are not going to do a lot for the first Dashboard. You should be aware that you can introduce new columns here and delete others to reduce the model and correct column values. That would be needed here since in the later screenshots you will see that “USA” is also written as “U.S.” and “United States” in the sample data. But at this stage I wouldn’t have known that issue, only after visualizing it I can go back to fix it in Transform Data.

But I wanted to show you a cool detail here: I suspected needing to map the optionset values to friendly names. But it did that in the base language for me!

Step 3: Relations

PowerBI also recognizes the relationships between these entities. Unfortunately, there are 2 of them. The parentcustomerid is where the contact references the account it belongs. And primarycontactid where an account selects its main contact. PowerBI can only have one of the two in the model, trying to create a star in the dependencies, a doubled relationship would hamper that structure.

Step 4: Visualizing

Yeah, I don’t want to talk too much about it. Apart from me never getting it to a beautiful state, it does not matter too much for the later stages. Be creative here. I used an account/country pie chart, an account list, a contact list and a gauge with the annual revenue for the demo: If I select a country in the pie chart, the account list is filtered. If I select an account there, the contact list gets filtered accordingly. The gauge filtering of course works for both of these filtering operations.

Step 5: The PowerBI Service

In the screenshot above I already marked the publish button. We will use it now to upload the report to the PowerBI Service. For the demo the “MyWorkspace” default value is fine, but for an enterprise project, you will probably want to have a dedicated workspace for your Dataverse Dashboard.

Now we continue at app.powerbi.com. We can’t show the Report as a Dashboard in Dynamics, we need a PowerBI Dashboard! We can just create that in the Workspace and then navigate to the Report again and use the Pin to Dashboard option from the ribbon to pin the current page. Make sure no unwanted filters are active because these would be snapshotted as well!

Now the Dashboard looks like the report and we can proceed showing it in Dynamics, but there is one more step to ensure the data stays up to date: The scheduled refresh. For this, head back to the Workspace, find the dataset and select the Scheduled Refresh Icon. Here you will need to configure which account to use for the refresh and how often to refresh. Usually Daily is sufficient, but sometimes you will need quicker refresh rates. If they get really low you will have to take a look at your performance as well, because data might be outdated by the time it was processed by the service. On the other hand, some systems might have very long times between data changes, for example, budgetary databases only being updated once a year.

Step 6: Embedding in Dynamics

Now the data is published (yet only available to the members of the workspace), kept up to date and part of a dashboard that we can publish. PowerBI Dashboards in Dynamics cannot be created for the whole system, only as personal Dashboards. So, head to an app with Dashboards and select New PowerBI Dashboard.

In the wizard, we select our Dashboard from step 5 and then it is done!

NOTE: Missing the “PowerBI Dashboard” Option? Make sure the PowerBI Embedding Feature is enabled on your environment under Settings -> Features -> Embedded Content.

Now, of course, not every user should go through these steps just because this is a personal Dashboard! Let’s share it. I’ve again marked the share button in the screenshot above. But that’s not enough! The users can then select the dashboard, but they won’t be able to see its contents since they don’t have access to the PowerBI Service Components we created.

When adding the users here, it is sufficient to only add them as viewers. They will still be able to use the filtering, but they can’t alter the dashboard. This contributor capability should only be given to a few users who are maintaining the report with you.

Summary

While the article is quite long due to its many pictures, the actual time it takes to make such a dashboard is short. The most time spent in PowerBI is usually the modeling part. Since we used a Dataverse source here and just kept everything as is, that was quick as well. While publishing such a dashboard is arguably more complex than just creating a system Dashboard in Dynamics, you have much more freedom designing the Dashboard in PowerBI. Also, the possibility to include other data sources is a real game changer, but that’s something for another article.

My First Shot at Dataflows with SQL

Sun, 06 Aug 2023 00:00:00 +0000

This time I will do my first experiments with Dataflows. Spoiler alert: There are quite some options left that would need a separate article, so at first glance, this seems to be a powerful feature.

Prerequisites

As a data source the same Azure SQL Database will be used that we already used for the External Table post. If you do not have a table ready, that post describes how it was set up in Azure with minimal cost. For reference, this is what the structure of the table looks like:

Creating the Dataflow

On make.powerapps.com, ensure you are on the correct environment and select Dataflows from the left menu. For me, it was hidden in the More flyout. If you can’t find it there either, try Discover all as this menu shows all Power Platform components. Still not finding it? Check that your environment has a database, this is required as a Dataflow will persist records to a Dataverse table.

After giving our Dataflow a name, the next screen will present the selection of sources. There is a great variety of connectors, but for this first shot, the trusty SQL table will do. When I entered my server and database the wizard recognized that I had a connection to this database already and preselected it, nice! Therefore I will refer you to the External Table post here as well.

Now we select the table we want to import and then we can transform the data. This is very interesting as with the External Table the data has to be exactly right in the source database, this time around we can tweak it. As this is the “first shot” article, I have done the minimum here and only used Add Table from Examples to add a year column that extracts from the last modified column.

Once we are done Transforming, for which you can spend days if the data is not already in the shape we need it, it’s time to select the destination. First I took a Products table I created sometime earlier and tried the Auto Map feature.

That worked well everywhere where the names matched, the ID fields were not automatically mapped because they are named differently than in the database. So be prepared to do the mapping manually if your database uses more technical names.

The other option is to create a new entity. I resorted to this to start from clean ground when evaluating the records, but take a look at the publisher prefix! So then I exited the wizard to recreate the dataflow in a solution, but I did not find it in the menu in the solution, only Dataflow Template was available or importing an existing Dataflow. I think that’s something to revisit when looking at deployment of these, but this side track had a nice learning: When I exited the wizard the system saved my Dataflow as unpublished so I could edit it to finally create my fresh entity.

The last dialog is about when the import will happen, on-demand or scheduled. Theoretically, the wizard allows you to go down to minutes, but depending on the size of your data this will not be enough to insert/update it in Dataverse. I chose daily here, probably a common choice.

The Result

That will be a quick section: No problem here! At the end of the wizard, select publish, it will take a few minutes. Then open the Advanced Find, look for the entity you mapped or created and the data should be there.

Everything looks fine here, all the data, including our custom “Year” column was transported. The creator/owner of these records might be interesting in use cases outside an experiment: I never had to select who this should be, so apparently it’s just the owner of the Dataflow. For a development environment that might be fine, but a production environment should probably have a service user here. Again something to look out for when trying to deploy a dataflow.

Since the entity filled with data here is a regular entity, you can integrate it into Model Driven Apps, create forms and so on. You could even add new records or edit existing ones. However, keep in mind that the changed data will be overwritten with the next execution of the Dataflow. But adding additional fields that are not mapped from the source would stay intact as well as new records (unless you selected the option to delete records not present in the source).

Summary

Dataflows import data to regular Dataverse tables. They achieve this with definitions that are much like PowerBI, giving us many online resources on how to transform data before loading it to Dataverse. In contrast to External Tables, Dataflows create an editable copy of the data. This also means that the data is not real-time and is only as fresh as the last refresh.

There is much to explore here: Different column types like Choice and Currency. Relationships within the source or to Dataverse. Deployment topics like Dataflows vs Dataflow Templates. But for today’s experiment, this is enough. Keep your eyes peeled for more Dataflow content!

Sharepoint Integration (Extended) 2: Using PnP.Core

Sun, 30 Jul 2023 00:00:00 +0000

So now that we have a login from the last post, let’s use it! In this post, we will use PnP.Core to help us interact with Sharepoint. After all, I am a CRM Developer and not a Sharepoint specialist, so a library to help with my tasks is most welcome.

Prerequisites

So I do assume you have the service principle set up. If not it’s time to head back here. The next rather important consideration is PnP.Core as a library itself. It has a lot of dependencies, usually, that’s not a problem, but this means we won’t be able to upload it to Dynamics, no ILMerge or Plugin Packages will help here due to unmanaged code in some dependencies. This means that this method is not for plugins but for standalone tools, APIs etc.

To give you some samples of what I have had to build that benefited from the help of PnP.Core:

A tool that migrates a file archive from a file share to Sharepoint. Connect them to the according record in CRM by alternate key.
An API function that takes a form filled by the user alongside pictures. The CRM user should be able to review the pictures when using the documents tab.
A tool that cleans up all versions of documents, since the Sharepoint storage was going overboard with frequent changes to large files. As you can see, the first 2 requirements are to take files and “connect” them to Dynamics while the 3rd sample is an exclusive Sharepoint problem, but the reality is, no matter if the requirements fall more to Sharepoint or more to Dynamics, in the end usually there is no one else to implement it so after all, you as Dynamics developer need to somehow cover it.

Next, I will be using .Net Core in this tutorial. This is technically not required, but with the general availability of the Dataverse Service Client for .Net Core, I can’t see a good reason anymore to stick with .Net Framework for external tools like the one we will be building here.

And one last thing: I do somehow assume you do know how to use the Dataverse Service Client or the classic CrmServiceClient (IOrganizationService), so the code shown will completely ignore the CRM bits and instead will mock corresponding queries as simple variables to keep the focus on what we are trying to achieve: Integrating Sharepoint.

Authenticating

Before we can manipulate Sharepoint we need to log in.

I’ve started with a Console App (.Net 6.0) and installed 2 NuGet packages PnP.Core and PnP.Core.Auth. Then, with the new top-level statements feature I can code directly into the Program.cs file:

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using PnP.Core.Auth.Services.Builder.Configuration;
using PnP.Core.Services;
using PnP.Core.Services.Builder.Configuration;

var authName = "certificate";
var siteName = "CRM"
var host = Host.CreateDefaultBuilder()
.ConfigureServices((hostingContext, services) =>
{
    services.AddPnPCore(options =>
    {
        options.PnPContext.GraphFirst = true;
        options.HttpRequests.UserAgent = "ISV|MariusWodtke|PnPDemo";

        options.Sites.Add(siteName, new PnPCoreSiteOptions
        {
            SiteUrl = "https://crmXXXX.sharepoint.com/sites/CRM"
        });
    });
    services.AddPnPCoreAuthentication(
        options =>
        {
            options.Credentials.Configurations.Add(authName,
                new PnPCoreAuthenticationCredentialConfigurationOptions
                {
                    ClientId = "cce5e182-eb79-40d9-abd6-3dc7c4c54718",
                    TenantId = "7cd962d3-c5b5-4762-89f3-0e72d8f8b08c",
                    X509Certificate = new PnPCoreAuthenticationX509CertificateOptions
                    {
                        Certificate = GetCertificate("CC4D7175E37641B38A4960BB8EFC8C56653DFF8E")
                    },
                });

            options.Credentials.DefaultConfiguration = authName;
            options.Sites.Add(siteName,
                new PnPCoreAuthenticationSiteOptions
                {
                    AuthenticationProviderName = authName
                });
        }
    );
})
.UseConsoleLifetime()
.Build();

This is very similar to the sample found in the getting started guide of PnP.Core. I chose the “no appsettings.json” variant and changed the authentification credentials to use a certificate. While we are on the subject of the certificate, if you haven’t already, double-click the .pfx file we created last time, select “Local Machine” in the first dialog window and then click next until the dialog finishes, the defaults should be fine. Now our computer knows the secret part of the certificate and will be able to use it for logging in.

The retrieval of that secret is done by the GetCertificate method mentioned in the code above. It takes the Thumbprint of the certificate, which I always find in the AppRegistrations Certificates & Secrets section, but there are probably other ways as well. The code of this method looks like this:

X509Certificate2 GetCertificate(string certThumbprint)
{
    X509Store store = new X509Store(StoreLocation.LocalMachine);
    store.Open(OpenFlags.ReadOnly);
    var certs = store.Certificates.Find(X509FindType.FindByThumbprint, certThumbprint, false);

    if (certs.Count < 1)
        throw new ArgumentException($"No certificate found by Thumbprint: {certThumbprint}");

    return certs[0];
}

Since this method uses the StoreLocation.LocalMachine it is important that you select “Local Machine” when installing the certificate. If you didn’t do so don’t worry, you can install the .pfx again or change the StoreLocation! The reason for me to use LocalMachine here is that it makes the deployment to servers easier where the program might not be executed by the same account deploying the server, hence the CurrentUser installation yields problems in this scenario.

Creating a file

Now let’s do something! I will upload a file from my computer to Sharepoint. I know you are bursting with excitement for this amazing task, but doing this ensures that the login works and we have the correct permissions and then you can hop on doing other things and if you get weird errors you at least know it’s your code that is broken and not the service principle or something like that.

To have a file to upload I added a file Test.txt to the project, wrote “Hello World!” inside and set Copy to Output Directory to “Copy always”. Next comes the following code:

await host.StartAsync();

using (var scope = host.Services.CreateScope())
{
    var pnpContextFactory = scope.ServiceProvider.GetRequiredService<IPnPContextFactory>();
    using (var context = await pnpContextFactory.CreateAsync("CRM"))
    {
        var file = "Test.txt";
        var accountName = "Fabrikam West";
        var accoountId = Guid.Parse("fb6b3f4b-1be7-e611-8101-e0071b6af231").ToString("N").ToUpper();
        var foldername = $"{accountName}_{accoountId}";
        var list = await context.Web.Lists.GetByTitleAsync("Account");

        var folder = await list.RootFolder.EnsureFolderAsync(foldername);
        var spFile = folder.Files.Add(file, File.OpenRead(file), true);
    }
}
host.Dispose();

So, we used IPnPContextFactory.CreateAsync to get a Context like the ServiceContext you know from Dynamics. Next PnPContext.Web.Lists.GetByTitleAsync queries the library we are working in. Since the Sharepoint standard series focuses on the account, I’ve used it here as well. Then we create a Folder in the library with RootFolder.EnsureFolderAsync where EnsureFolder works like a GetOrCreate, so there are no problems if the folder is already present. And finally, we will call Files.Add to upload our file. Straight forward I guess. While I’ve left out all CRM calls you can already see that I’ve leveraged the knowledge from the inner workings post to make sure the folder is exactly named like Dynamics would name it. This has an interesting side effect, when I now open up the Account in Dynamics and head to the Documents section, Dynamics will show me the uploaded file, likely because it also uses something like EnsureFolder to create it.

That’s cool, but I want to warn you about banking on this behavior: If someone changes the Account name by a single letter before opening the Documents section, Dynamics will generate a new, different folder.

Instead, you should create a documentlocation to connect them immediately. That way the changed name is not a problem, Dynamics finds the existing location and can show it. For this you will need to set these 3 fields:

regardingobjectid and relativeurl should be no problem, this is the account and the foldername. In simple scenarios parentsiteorlocation is simple as well, query for the documentlocation with relativeurl “account”, so the logicalname of the entity. This stops being so easy when you have two sites with a Library “Account” since suddenly you have 2 documentlocations with the relativeurl “account” but different parent sites. Also if you want to connect to a location in the hierarchical setup, this gets trickier as well, but in this case, you will already have to deal with that once you are creating the folder because it then is no longer under the root folder but 2 folders deeper.

Summary

But after retesting and writing this article, I have to say PnP.Core makes it easy to dip your toes into “Sharepoint Development”. Well we are not developing here, we are manipulating the content of Sharepoint with programs. The setup is easy and the code you need to write to do basic manipulations is quite short. For more advanced manipulations that are not as intuitive as Files.Add, check out their great documentation with samples and tutorials here: https://pnp.github.io/pnpcore/index.html The only downside to this SDK is its dependencies, making it unsuitable for Dynamics Plugins. This is why we will explore using the Sharepoint REST API in future posts as well. A little heads up: This is of course more cumbersome, so I do use PnP.Core whenever the requirements allow it.

Sharepoint Integration (Standard) 4: The Inner Workings

Sun, 23 Jul 2023 00:00:00 +0000

Having some knowledge about the inner workings of this integration is often beneficial. It helps you track bugs and understand what can work and what can not. Of course, I have never seen the code of Microsoft and therefore this is merely a compilation of observations.

The basics

While we talked a lot about the Sharepoint Document in the post about customizing, here we will talk about the Document Location. This entity mainly consists of a Relative URL which holds the current path element and s Parent Site or Location which is a hierarchical lookup to another Document Location until eventually, this lookup will point to a Sharepoint Site.

Let’s first talk about the other Document Locations: All those hold a relative URL as well, so if you go up from the leaf with URL “abc” to parent “def” and from there to another parent “ghi” these elements will result in a path “ghi/def/abc”.

And the Sharepoint Site has an Absolute URL. So if we assume that the “ghi” location looks up to the site “https://mycompany.sharepoint.com/sites/CRMDev" the final full URL to the Sharepoint folder would be “https://mycompany.sharepoint.com/sites/CRMDev/ghi/def/abc". The sites can also be hierarchical. You could use this if you are going to integrate a lot of sites, making “https://mycompany.sharepoint.com/sites" the base and then adding on child sites with the concrete relative URL.

Why am I telling you all this? Dynamics is creating the sites for me when setting up the Sharepoint Integration and the locations are automatically created when I open the documents tab. Because we might want to create our own locations! Or find out the URL of an existing location. Important things when you want to do some information with something like a flow.

Common path patterns

The easiest is just {site}/{library}/{folder}. This is the default when no hierarchy is enabled. Dynamics creates a library for the entity with the entitylogicalname as URL and then the folders below it. In this situation, you can assume there are exactly two parents, one location that is not regarding any record and the site. This setup in three pictures:

With hierarchical its a bit more complicated: {site}/{library}/{folderParent}/{logicalname}/{folderChild}. So for example below the site we have the libary “account”, then the URL of the account record folder, then another folder with a logicalname, e.g. “incident” and finally our folder regarding the concrete record. At the latest in this setup it’s the best to think recursive: Step up to the parent until there is no parent left. Then combine the paths backward to get the full URL.

When is a folder created

Dynamics only checks for the presence of a Document Location which is Regarding the current record when opening the Documents Tab. If one is present no folder or location is created, no matter if the existing location is valid!

But when a folder is created the Relative URL is interesting: It is the primary field of the record (the “name” field) where it replaces some illegal characters, e.g. a dot (.) is replaced with an underscore (_). Then follows an underscore and then the Guid of the record in all uppercase and without dashes (-). In my sample “a16b3f4b-1be7-e611-8101-e0071b6af231” becomes “A16B3F4B1BE7E6118101E0071B6AF231”.

I think even if you are creating your folders, you should obey this scheme. It avoids some concurrency problems (the user opening the Documents tab while you are creating the folder) and it makes a lot of sense: The primary field is easy to identify for regular users while the Guid is unique, making sure there are no conflicts with identical folder names. Think about the contact here, it’s quite common for people to have the same first and last name, leading to an identical fullname without actually having a duplicate. This situation should have 2 different folders for the 2 records, therefore it’s a good idea to always include the Guid.

When something happens in Sharepoint

So it’s a bad idea to rename folders in Sharepoint. Because it is not reflected in the locations in Dynamics. It’s a one-way integration: Dynamics can create folders, write files, request a listing of files and download a file. All these operations are performed by the front-end component of Dynamics, no backend integration will sync back changes from Sharepoint.

But if it happened you can fix it: Find out in the Office 365 Compliance Center Audit Log what was the original and new path of the renamed folder, find the document location with the original path element and change it to the new path. If some user has shortened my sample folders’ name from “A Datum Corporation_A16B3F4B1BE7E6118101E0071B6AF231” to “A Datum Corporation” I just need to reflect that in the location record to fix the displayed error there is no folder with the relative URL “A Datum Corporation_A16B3F4B1BE7E6118101E0071B6AF231”.

Summary

The components of the integration are easy to understand, having the Sharepoint Site as a base and then a variable amount of hierarchy in the Document Location. To get an effective URL you need to traverse the parents and combine the relative URLs backward. The grouping folders of the entities are named like the logical name of the entity and the actual folders for the records have a combination of the primary field and the records Guid to ensure uniqueness. The last important note is that Dynamics does not react to changes in Sharepoint. This is no problem when you upload a new file or create an additional folder, but renaming folders is a delicate matter that needs to be covered in your workflow. Or you simply agree to not rename them once created.

Sharepoint Integration (Standard) 3: Customizing

Sun, 16 Jul 2023 00:00:00 +0000

If you are not entirely happy with the default functionality shown in the previous post, there are some options to tailor it. This article will discuss some customization options available to people and projects not willing to build extensive PCF controls or something similar.

Showing Metadata

The Documents Tab shows a grid and you can customize it. The entity is called Sharepoint Document (sharepointdocument) and has the “Document Associated Grid” which is shown by default and the “All Sharepoint Documents” is shown when you select to show all locations.

You can choose one of the predefined columns, maybe something like “Folder Child Count” might help the end users’ experience. But you can also create custom columns. To do this, create a column in Sharepoint, then create it with the same Display Name and type. Just for Choice, I noticed that I needed to create it as a Single Line of Text in Dynamics. Then you can add the new field to one of the views, displaying it to the user.

One note though: You can’t edit these columns in Dynamics, you will have to switch over to Sharepoint with the Open Location button.

Displaying the view more prominent

You can add the Documents grid to other tabs as well, not requiring the user to visit the Documents Tab. It even works with Quick View Forms if you for example want to display the documents of the parent account at the child contacts. However please note, that displaying this grid won’t create a location automatically like it happens in the Documents Tab, the user will have to visit it once to create the folder. Or they use the Add Location button to create it.

To add the grid to an existing tab, in the Form editor select “Add Subgrid”. In the dialog, select “Show Related Records” and then the relationship to display is “Documents”.

Customizing the Ribbon

Another customizing option can be realized via the RibbonWorkBench of the XrmToolbox. First, you need to create a new solution. Then add the Sharepoint Document entity without any subcomponents. Now you can load the Solution into the RibbonWorkBench and start customizing.

For demonstration, I used the Hide action on the Flow Button which did not work for me in the previous post and published the solution to apply the changes.

Of course, you can also add new buttons or change Display/Enable Rules on existing commands.

Document Location

There is also the entity “Document Location” (documentlocation). It is not directly shown in the grid, but the records of this entity hold the information where the actual Sharepoint folder is and is shown in some parts of the grid. The display name is shown in the breadcrumbs of the navigation and the flyouts for the “Location” buttons of the ribbon.

Since the default name is “Documents on Default Site 1” I can imagine users wanting that to change. They can of course via Edit Location, but if you can agree on a standard naming, an automation like a Flow could do that. But keep in mind that there might be multiple locations if users add an additional location, having them all named the same might lead to a nightmare finding the correct folder.

Summary

While there are many fixtures with this integration, Microsoft has left room for us to customize the experience we have interacting with Sharepoint. You can add the Sharepoint view to other tabs and manipulate the columns shown. You can also add custom columns and buttons to the view. You can also manipulate existing buttons to focus the user on his current task. Lastly, there are also some options to change the names on the locations, allowing easier sorting when having multiple.

In the next post, we will discuss more about the internals of the Sharepoint integration, which might help you to create more advanced modifications and extensions.

Sharepoint Integration (Standard) 2: OOTB Functionality

Sun, 09 Jul 2023 00:00:00 +0000

In the previous post we set up the Sharepoint integration for our instance, what can we do now?

The Documents Tab

On the entities where you enabled the Integration in the wizard, you should be able to access the Documents Tab. This is the main hub for interacting with Sharepoint. I will be working with the Account for this post as I enabled this entity when setting up the integration.

New/Upload/Preview/Download

With the + New button you can create new documents, but only subfolders and some of the most common Office formats. For everything else, you would use the Upload button which displays a dialog to select a file from your computer.

Once you created/uploaded a file you can just double-click it to preview or download it in case there is no previewer in the browser like for the .step file in the image above.

If you double-click a folder you will navigate the grid inside the folder and the breadcrumbs will extend, you can use them to navigate up again.

Check-In/Out/Edit/Delete

When you single-click a file (or mark the checkbox on the left) the ribbon changes. It now shows buttons for Check in/Check out, a feature to lock files for editing. In my experience, this is not used that much anymore since the office documents do support multiple users editing at the same time but maybe you will find this helpful when working with formats that do not support collaboration.

The Edit button is something you won’t need, it’s the same as double click! Delete should explain itself. A little bit more interesting is Edit Properties as the name suggests that it allows editing the metadata columns. However, only the filename and title are available in the dialog, making it kind of a “Rename” button.

Another potentially interesting button is the Flow button which usually lets you execute a Flow on the selected record, allowing admins to define Flows like “Send file for approval”. However, in my demo environment creating a Flow from here does not work! If you made it work somehow, let me know and I will happily update the article.

Location Actions

There are several buttons for the “location”, which means the folder that is connected to Dynamics. Let’s first talk about Add Location. While Dynamics created a folder for you when you entered the Documents Tab this does not mean it needs to be the only folder! With add location you can add a second location (and more) and they do not necessarily need to be on the same site!

When multiple Locations are created, the Document Location Flyout comes in handy: Of course, now there are 2 different folders to check and you can use this flyout to switch between the folders. Or use All Locations to display everything to gain an overview. It also helps that this view flattens all subfolders, displaying a path, very helpful when looking for items in more crowded structures. In this mode, you can’t upload a file because the grid wouldn’t know where to put the file.

You can also use Edit Location to change things about the location. In the screenshots, you already saw that I changed the display name from its default “Documents on Default Page 1” to “Folder for: 234234”. You can also change the foldername in Sharepoint here, but maybe unexpectedly that does not move the folder, instead, it creates a new one and leaves the already created content behind. It’s still useful though: When a foldername is changed in Sharepoint this does not translate to the location in Dynamics, but with this function, you can move the location to the new foldername as well.

And finally: Open Location. This is the single most used button by me. It opens the folder in Sharepoint, giving full access to the Sharepoint features. I already documented that Edit Properties does not let you edit custom metadata columns, but of course, in Sharepoint, we can!

Summary

The OOTB functionality of the Sharepoint integration is great for the average users’ interactions: Upload, Edit and Download documents. Organize in folders and find files in the overview via All Locations. Whenever the views in Dynamics are not sufficient, you can always head over to Sharepoint with just 2 clicks.

Everything is nicely connected to the structured data in the Dynamics record with the possibility to create more private secondary locations etc. So all in all in my humble opinion the OOTB view already provides a great experience working with documents. It might lack automation options and interaction with metadata, but we will discuss these topics in future articles in this series!

Sharepoint Integration (Standard) 1: Setup

Sat, 01 Jul 2023 00:00:00 +0000

Well, ordering is broken now, but as I wanted to write more about Sharepoint integration with Dynamics CE I asked myself “Shouldn’t we talk about the standard integration first?”

After all, Microsoft thinks it’s sufficient for most customers so why shouldn’t you get happy with it? Also, I am always relying on the standard experience for the frontend when automation is required.

Setting up a Sharepoint site

This is pretty straightforward, I only want to share two considerations here. First, use one site per environment, sharing the site between multiple environments just leads to confusion and compromises the separation in security and after all, Sharepoint is billed by capacity and not per site. Second, there can be only one “Default Site”. That’s the site where Dynamics will auto-create folders when a user visits the Documents Tab of a record, so you should consider which site shall be your default site when you are planning to integrate with multiple sites.

So first head to https://{tenant-domain}-admin.sharepoint.com/ where you replace {tenant-domain} with the domain of your Azure Active Directory tenant.

NOTE: You can also find the Sharepoint Admin Center via the quick links on the left menu at https://admin.microsoft.com/.

Head to Sites -> Active Sites and select + Create at the top. We need a Team Site.

Then give the site a name that shows its purpose well, maybe reference it being used for Dynamics CE and set yourself as owner. Check the Advanced Settings here as well, making sure settings like the timezone are correct.

On the last screen you can already add members to the site, they will be added to an Office 365 group that was created alongside the site.

Authorizing Dynamics

In the Advanced Settings (accessed from the cog symbol on the top right) choose Document Management and Enable Server-Based SharePoint Integration.

NOTE: This menu point vanishes after being performed.

Step through the wizard, if you are on an online Sharepoint site like described earlier, you can leave the standard settings until it asks for the URL, here you enter the URL of the site you created earlier.

Connecting Dynamics

Next, we need Document Management Settings.

On the first screen, we need to enter the URL again and select the entities. Please note that some entities are preselected for you! You probably want to use the “select/deselect all” check box and then select only the entities you want to enable. For me, this will be the account.

On the next page, you can optionally enable a hierarchical folder structure which is interesting if you for example think all documents of an account should reside under this folder, for example, all documents on the related cases, opportunities, orders and so on. Of course, this might make it a little harder to find the documents when searching in the Sharepoint structure, but might make for a great view from the CRM side of things. I unselected this option here because it does not make sense for me only enabling account for the integration.

And then the wizard will create document libraries in Sharepoint for each entity.

Testing it

We are ready to go! Select an account in Dynamics and under Related, select Documents.

I’ve used the Upload button here already and for the next step, use Open Location to ensure that the document seen in the grid is actually in Sharepoint.

Summary

Setting up the standard Sharepoint Integration for Dynamics CE is pretty straightforward and can be done in less than 30 minutes if you have enough privileges to execute the wizards on Sharepoint and Dynamics side.

First, we created a site on Sharepoint. Then we enabled the server-based integration from Dynamics to Sharepoint. After this we can connect the site to Dynamics, in this step we will also enable entities and optionally define a hierarchy. After that the integration is ready for the users, they can upload, preview or download documents, organize in subfolders and some more things.

In my experience, this works very well for most of the direct user interaction scenarios, so your users are hopefully already quite happy with these features, giving them quick access to documents through their Dynamics interface, all well organized within the records created by them.

Check out the next post for a deeper dive into the OOTB functionality of this integration.

Sharepoint Integration (Extended) 1: AppRegistration

Sun, 25 Jun 2023 00:00:00 +0000

As this blog focuses on everything around Dataverse and how to integrate it, it’s now time to talk about Sharepoint.

Dynamics CE has a Sharepoint integration, but it lacks. It works well with everything a user does manually but fails as soon as the requirements want the system to do something for the user. “Create a default folder structure”, “We need folders for all the records in the table”, “Automatically upload a generated file” and so on.

In this post, we will create an AppRegistration that will resemble a service user for talking to Sharepoint. This is done for integrating with Sharepoint via backend code like C#. You can also do this integration with Power Automate, but having done this for a customer who prefers Power Automate my humble opinion is that it’s not worth it. Determining the folder position alone is too complex and by the amount of actions executed, the Flows become quite slow.

The Portal Way

So if you like to point and click, we can set up a service user via the Azure Portal. All you need is an active Subscription, the cost will be minimal. First, we need a KeyVault, maybe you already have one, otherwise search for KeyVault in the search box at the top, select the KeyVault and + Create to start the creation process. The standard SKU is enough and for the name you need to be globally unique. For my name that’s quite easy, I’ve added a -dev here just in case I will use the KeyVault for anything else in the future, in this case, it is important to create separate KeyVaults for different stages and topics because once you give some application access to the contents it has access to all the secrets of this KeyVault. The other settings can stay as default for this tutorial, you can skip the other tabs and directly create the KeyVault.

Next head to the Certificates section on the left menu and Create a Certificate. But even though I am the owner of the subscription I cannot access the KeyVault:

But as I am the owner of the KeyVault Azure Resource I can simply add appropriate permissions for myself. Under Access Control (IAM), select Add role assignment. For my purposes I chose the Key Vault Administrator role (although Key Vault Certificates Officer would have been sufficient for today) and my account of course.

So after a full reload of the page I can now add a Certificate. I like to name them as I want to name the App Registration. So here I am creating it for the Dataverse <-> Sharepoint Integration and the development instance. Because it’s not that easy to differentiate the environments with the auto-generated names of my demos, I also add the domain name of the instance here. You could also handle that via tags, or you don’t need it at all because you named the environments correctly in the first place. The subject will be the same as the name, just with a prepended CN=. I do change the Lifetime Action with these because the Certificate will need to be handled manually anyway to email me instead of auto-renew.

After creating the certificate, select it and then its only version. From here you can download it as CER (the public part of it) and as PFX (the private part). We will need the CER for the AppRegistration and the PFX for the actual Application as kind of a password (although this technically works differently).

Now we will create the App Registration. You can use the search box again to search for “App registrations” and select them. Then + New Registration to create a new one and we will name it like we named the certificate. So for me DataverseCE-SharepointIntegration-dev-org… Everything else stays as default.

Next switch to Certificates & Secrets, and Upload a Certificate, as shown in the picture below.

After this step, the application we will build in the next post will be able to authenticate against our Active Directory. However, it is not authorized for Sharepoint yet. This is done in the section API permissions. Select Add a permission, in the Tab Microsoft APIs find Sharepoint. Here we are looking for Application Permissions and then theoretically we would like to use Sites.Selected, so that the Application can only interact with certain sites. But the problem is: There is no GUI for selecting the sites on the Portal or Sharepoint, this has to be done via Powershell Modules and that’s something we will explore further down. So in this case we will have to go with Sites.ReadWrite.All.

The last thing now is to grant admin consent. As shown below this is a button that just needs to be pressed to grant the permissions. Well, at least if you have that kind of access. In a corporate environment, you might not be that privileged and might have to ask an administrator for assistance, but in this demo tenant of course I won’t need this.

And that’s it, the App Registration is now granted permissions and we can use it as an identity to integrate with Sharepoint!

The Powershell Way

But especially in the aforementioned corporate environment the Sites.ReadWrite.All Permission is far too powerful. What you want here is the Sites.Selected and then enable the App for individual sites. This can be done with the Powershell command Grant-PnPAzureADAppSitePermission from the PnP.PowerShell module.

But since we are using Powershell here anyway, let’s do the whole thing with Powershell.

Install the module: Install-Module -Name PnP.PowerShell -SkipPublisherCheck -Scope CurrentUser (-SkipPublisherCheck is technically not needed but helps with unattended scripts since you don’t need to confirm the download.)
Connect to your Sharepoint Site, $sharepointUrl stores the full URL here, e.g. https://crm123456.sharepoint.com/sites/Contoso: Connect-PnPOnline -Url "$sharepointUrl" -Interactive
Next, we are going to create the AppRegistration. $tenantDomain holds the domain name of the tenant, in this case crm123456.onmicrosoft.com and $appName is the name of the app, so we can use something like DataverseCE-SharepointIntegration-dev again: $appRegistration = Register-PnPAzureADApp -ApplicationName "$appName" -Tenant "$tenantDomain" -Store CurrentUser -SharePointApplicationPermissions "Sites.Selected" -Interactive Please note that this action also creates the Certificate. Both the PFX and CER are dropped to the folder where you execute the command. It also uploads the CER to the AppRegistration and sets the Permission - Sites.Selected. So a lot of the steps we executed by hand earlier, making the Powershell command far less error-prone. You might want to upload the PFX to a KeyVault anyway to store it safely.
For Grant-PnPAzureADAppSitePermission we need the ClientId, we will save it from the returned information of Register-PnPAzureADApp: $clientId = $appRegistration."AzureAppId/ClientId";
Next we will grant Read/Write permissions to our AppRegistration:$permission = Grant-PnPAzureADAppSitePermission -Permissions "Write" -Site $sharepointUrl -AppId $clientId -DisplayName $appName
As needed: We saved the ID of the Permission to be able to manipulate it, there are 4 levels of permission, Read, Write, Manage and FullControl but the latter two you cannot use with the Grant-PnPAzureADAppSitePermission, you will have to use this command: Set-PnPAzureADAppSitePermission -Permissions "FullControl" -PermissionId $permission.Id As said this is optional because you might simply be fine with Read or Write.

To elaborate on point 6: Manage will be needed to for example manipulate metadata columns, so not the content, but the schema around. So needing to add metadata columns to a list will require the Manage privilege while just setting a value to an existing column only requires Write. FullControl is for things like circumventing the bin, or not creating a new history version with an update of a document. So it is more of a rare use case, but I have needed this for a tool migrating documents together with metadata since setting the metadata after the upload created a new version of the file, essentially doubling the occupied space.

If you need to enable the app for a second Sharepoint later, you can look up the client id in the Overview section of the AppRegistration in the Azure portal and then start at point 4 by setting the $clientId = "6ba7b810-9dad-11d1-80b4-00c04fd430c8".

Here is the consolidated full script:

$sp = Read-Host -Prompt "Enter the Url of the Sharepoint Site you want to use the principle with, e.g. https://crm123456.sharepoint.com/sites/Contoso"
$appName = Read-Host -Prompt "Enter the Display Name of the Application in AAD, e.g. DataverseCE-SharepointIntegration-dev"
$tenantDomain = Read-Host -Prompt "Enter the AAD Tenants Primary Domain, e.g. crm123456.onmicrosoft.com"

Install-Module -Name PnP.PowerShell -SkipPublisherCheck -Scope CurrentUser

Connect-PnPOnline -Url "$sharepointUrl" -Interactive

$appRegistration = Register-PnPAzureADApp -ApplicationName "$appName" -Tenant "$tenantDomain" -Store CurrentUser -SharePointApplicationPermissions "Sites.Selected" -Interactive
$clientId = $appRegistration."AzureAppId/ClientId";

$permission = Grant-PnPAzureADAppSitePermission -Permissions "Write" -Site $sharepointUrl -AppId $clientId -DisplayName $appName
Set-PnPAzureADAppSitePermission -Permissions "FullControl" -PermissionId $permission.Id

Summary

So while creating the Sharepoint AppRegistration via the Portal is a good exercise for understanding how the components work together, doing it with the Powershell is a lot more fit for purpose. It reduces human error, can grant more granular permissions and once the script is set up, it’s much faster. Therefore I will always lean towards the 10 lines of code to create a service user for Sharepoint.

In the next post, we will use the service user to interact with our site.

Links

https://docs.microsoft.com/en-us/sharepoint/dev/solution-guidance/security-apponly-azuread

https://docs.microsoft.com/en-us/powershell/sharepoint/sharepoint-pnp/sharepoint-pnp-cmdlets

http://johnliu.net/blog/2019/2/flowninja-hack-78-modifying-modified-by-and-modified-time-with-microsoft-flow

My First Shot at External Tables with SQL

Sat, 17 Jun 2023 00:00:00 +0000

So this week I’ve looked into the “Virtual Entities”, or as they are now called “External Tables” again. The problem the first time around was that it worked with the OData connector if you did everything right, but any minor mistake in configuring the attributes immediately broke the whole interface and debug information was not present. And in mistake I mean something like the server defines a string attribute and you create that as an optional string field in Dynamics; it needs to be required because it is not nullable…

Nevertheless, there is a beautiful new interface for configuring this now and it should also map the fields automatically, theoretically eliminating the human error here.

The Server

The new interface has only Sharepoint and SQL Server on offer for now. And Sharepoint lists needing to be integrated frankly just has not happened to me yet, so I went with the SQL Server. It is interesting because it can handle big amounts of data better than Dynamics (e.g. mass inserts) and a lot of applications can already write an SQL Database. Furthermore, there are synchronization features to OnPremise Servers and you can even integrate External Tables to the SQL Server as well, making it kind of a gateway to other databases.

In Azure, I created an SQL Server and an SQL Database on the server. For the pricing tier, I chose serverless, cranked everything to its bare minimum and set auto-pause to one hour to reduce the cost to an absolute minimum. I always have that server running for SQL experiments and with its low usage and only a couple MB of occupied storage, it cost me less than one Euro last month. This is of course no advice on pricing, you would have to calculate that here, but it gives you at least an idea of how low the cost for a PoC can be.

With SSMS I created a new table, according to the requirements for being integrated as an external table.

Table Requirements

I did not find direct requirements for the SQL tables, only the somewhat vague general limitations for external tables and the docs for OData tables. But with the variety of field types those were not a problem, with SQL I could imagine that you can have something with the bigger integer types that would not work.

But the real requirement is that you need a Guid column. Often other data sources do not have this, they use an integer key or something similar. You can use those as alternate keys but the primary key for Dynamics is still the Guid, you need it. Fortunately, you can let the SQL Server generate that Guid for you, here is an example: ALTER TABLE [dbo].[Products] ADD CONSTRAINT [DF_Products_Id] DEFAULT (newid()) FOR [Id] where Id is defined as [Id] [uniqueidentifier] NOT NULL. This can be integrated into any table and it will be fit for purpose.

But consider this: What if this table is not the source of the data but it’s rather copied there from somewhere else? Maybe as a straight copy or as an enriched dataset. No matter, you could get into a situation where you want to empty the table and fill it again from the source, but that will regenerate the Guids! All existing relationships with Lookups to the external table and all N:N relationships to it will be broken. So make sure to generate the Guid in the “real source” already. The other option to prevent this is to make an extra table with the Guid and the alternate key and then join them in a view. If you drop and reload the real table this matching table will persist and thus the Guids persist. But this adds overhead to manage the second table, so it might also be an option to only use this as a measure for the drop: Generate this helper table before you need to drop the main data table, then reimport the data and overwrite the newly generated Guids with the saved Guids from the helper table, matching by the alternate key.

For reference, this is my table for tests:

CREATE TABLE [dbo].[Products](
	[Name] [nvarchar](50) NULL,
	[EAN] [int] IDENTITY(1,1) NOT NULL,
	[Description] [varchar](50) NULL,
	[Id] [uniqueidentifier] NOT NULL,
	[LastModified] [datetime] NOT NULL,
 CONSTRAINT [PK_Products] PRIMARY KEY CLUSTERED 
(
	[Id] ASC
)WITH (STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, OPTIMIZE_FOR_SEQUENTIAL_KEY = OFF) ON [PRIMARY]
) ON [PRIMARY]
GO

ALTER TABLE [dbo].[Products] ADD  CONSTRAINT [DF_Products_Id]  DEFAULT (newid()) FOR [Id]
GO

Creating The External Table

Some pictures say more than a thousand words, let them speak and we will discuss the problems I’ve encountered afterwards.

The Learnings

My experiment did not go that smoothly of course. The first issue was that I tried the Service Principle authentication method. Creating the connection went pretty fine and the connection showed as connected, but no matter how often I tried and how many refreshes I did, it would never show up as an existing connection in the wizard.

That was not too problematic for me in this case, since I had no security department in my neck. I’ve simply created a local login for the SQL Server Authentication. This is the script to do it:

-- In the master database
CREATE LOGIN MyUserName   
    WITH PASSWORD = 'MyPassword123!';  
GO  

CREATE USER MyUserName FOR LOGIN MyUserName;  
GO  

-- In the database that has the data you want to connect to
EXEC sp_addrolemember 'db_owner', MyUserName
GO

And that showed up as seen on the screenshots above.

But there was another error:

Googling around I then found this thread and simply setting the Manually Manage Connection Reference from the Advanced Options in the first step of the wizard was enough to fix the issue (that’s step 2 of the solution from the thread).

This little trick just needs to be known I guess, while the first issue might be more problematic in bigger corporations where the SQL Server Login might raise security concerns.

Summary

So in total, I think Microsoft made a good step forward in easing the integration of external data with the new experience of external tables. The whole feature is not quite there yet, it’s not as easy as using something like a Power Automate Dataverse Connector or creating a regular table but the new wizard is a leap forward and we can see that MS cares about this feature and is willing to push it forward.

My First Shot at Plugin Packages (Dependent Assembly Plugins)

Sat, 10 Jun 2023 00:00:00 +0000

I recently noticed in a project that needs certificate authentication that Microsoft.IdentityModel.Clients.ActiveDirectory is deprecated. But this NuGet was particularly practical as it was loaded to the Dynamics 365 Sandboxes, letting me use it from plugin code. In contrast the new Microsoft.Identity.Client is not in CRM and therefore traditionally would need ILMerge to be deployed.

However, Microsoft has a new preview feature for Dynamics CRM called “Dependent Assembly Plugins”. This allows you to upload a .nupkg file and since a .nupkg is just a .zip file in the end, this means we can include multiple .dlls including ones from other NuGets.

Prerequisites

We are going to need the latest version of the PAC CLI. A simple way to get it is via the Power Platform Tools of VSCode since I assume most of you will have VSCode already installed. For deploying the package the latest version of the Plugin Registration Tool is advisable, a simple solution is to include the Microsoft.CrmSdk.XrmTooling.PluginRegistrationTool NuGet to your Project, after building the project you will find the PluginRegistration.exe in your package folder. You might also want to install the NuGet Package Explorer to inspect the contents of the packages quickly.

Initializing a project

So for my use case, I already have a plugin project generating an assembly that is already uploaded to my Dynamics CRM instance. This previously had no dependencies on assemblies that are not loaded within the Sandbox. To transform the project to a Plugin Package, the pac plugin init was used. Since I want to transform an existing project I first made a new Folder (simply left the default name, it does not matter) and executed the command inside that folder with the name of the original plugin project. I want to keep the namespaces etc the same here but obviously I can’t run the command in the “correct” folder since the files are already there.

Next, I only took the .csproj from this newly created project and copied it back to my existing project. Since I chose the Namespace to be identical this overwrites the existing project.

Of course, if you starting fresh you can simply run pac plugin init in the root folder and start implementing from there!

Fixing up the project

So before we include any new dependencies now, let’s try to build! And of course that does not work anymore, who would have guessed? In my case, the older .csproj style of the existing project meant that some Assembly Attributes were duplicated, which was easy to fix. Also, all the Assembly references are not included in the new project, they can be copied over from the old .csproj file when running a git diff, but I took the opportunity here to do some housekeeping and went through the build errors, only adding the references needed by the current code. Finally, with the newer project style, there was also a class included in the project which I intentionally did not include in the old one, with the new style I had to explicitly exclude it.

After that, the code was building and already I found a .nupkg file in my bin/debug folder, cool!

Integrating a dependency

Next up, integrating a dependency. A no-brainer would be something like Newtonsoft.Json, but for my take Microsoft.Identity.Client was already set. This comes with another dependency on Microsoft.IdentityModel.Abstractions. The amount of other dependencies is critical since the Sandboxes still do not allow unmanaged code, so any dependency using it can kill your dreams of a helper library. So I uninstalled Microsoft.IdentityModel.Clients.ActiveDirectory from my project, installed Microsoft.Identity.Client and then built to work through the errors. In these situations, the “Separation of concerns” is a blessing since that meant that I only needed to adapt the CertificateCredentialClient built for getting an access token from a certificate.

Naturally, after a rebuild you want to know whether everything is in the .nupkg as expected. This is where the NuGet Package Explorer is handy since you can just drag and drop the .nupkg to the application window and it will show you the contents.

That worked nicely, I can even see that System.Web.Extensions was included which is technically not needed, so I could remove it from the package by setting the dependency to not Copy Local.

NOTE: I’ve noticed here that the NuGet is not updated on regular build unless you increase the package version, however a rebuild always packs a new .nupkg.

Registering the package

With our package ready from the development side now, open the Plugin Registration Tool and connect to your instance.

The catch

No, the last screenshot already shows the steps and images. However, the reality is that your old assembly now has a “copy” and will only contain the types, but nothing else. So I migrated all the steps from the old assembly over to the one included in the package and then unregistered the old assembly with the same name. This was feasible for this assembly, but for larger projects, this will be a bigger effort. It would be much easier if regular tools like SPKL could interpret packages and register the steps. So for larger assemblies, you want to wait for such a feature (or include it yourself) to then just run the full registration on the new package and then unregister the old assembly.

Summary

“Dependent Assembly Plugins” is a great addition to Dataverse. It offers a supported way to practice modern development by relying on helper libraries and splitting your code into multiple libraries. The PAC CLI offers an easy way to initialize such a project but for existing implementations, you should keep in mind that this feature ~~is still in preview~~ and that the community tooling has not yet caught up with it (it’s released now, so keep an eye out for updates). Therefore you might want to wait with it before developing production code with it and rather resort to experimenting with the new possibilities this feature will enable you to deliver in the future.

eForms with C# 4: Publishing a notice

Sat, 03 Jun 2023 00:00:00 +0000

Oh, you’re back! So this means you’ve progressed with the validation from the last article so much, that you are ready to publish a first notice. Well, at least to the preview environment.

Generating a client

So again, new API, same game, let’s use NSwag Studio to generate a client. I do assume you have read the last article, so you are already familiar with the options of NSwag. The settings are quite similar here, so you can start with a copy of your old config and just change the Specification Url, Namespace, Class Name and Output file path. To recall, the swagger is found here and the specification URL is https://enotices2.preview.ted.europa.eu/esenders/api/v2/notice/v3/api-docs/public.

You can also work off the configuration of the sample app, of course, it is found here.

But no matter how much we fiddle with the settings there is always a problem with the output. Again NSwag can’t interpret the description correctly, it renders the metadata property which is specified as part of the body as well as the parameter in the OpenApi specification twice… Seems like those APIs don’t like to be generated, I wonder whether the specifications were created by hand or if it’s just NSwag simply being buggy here. In this instance, I have edited the resulting client by hand since only four function signatures need to be edited. But of course, this is a nuisance since it needs to be done every time we regenerate the client.

So then there is also a difference to the Validation API in that the API Key is not a parameter but shall be passed as the Authorization header. Again weird, that it’s not consistent between the APIs, but it’s not a problem, we can simply set the header like this: PublicationHttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", ApiKey);. And here the ClientFactory that did nothing much for the Validation API is very handy because it alleviates the program code from worrying about the Authorization header, it is already injected when the client is generated!

Calling the API

Now let’s take our notice XML and publish the notice. You probably want to double-check your url to contain a .preview. now to not accidentally publish something to the real platform.

var publicationClient = factory.GetPublicationClient();
var metadata = new Metadata
{
    NoticeAuthorEmail = "sam@ple.app",
    NoticeAuthorLocale = "en",
};
var notice = new FileParameter(new MemoryStream(serializedNotice), $"{mappedNotice.ID.Value}.xml", "text/xml");
var publicationResponse = await publicationClient.SubmitNoticeAsync(notice, metadata);

So with the generated client straight forward again, this time instead of a byte array a File Parameter is requested, but the transformation can be achieved quickly with a MemoryStream. What you get back is a success indicator and a URL with the validation result. So even if you have previously used the Validation API, the Publication API will still check your notice and you can use the URL for the Validation Report endpoint to double-check the results. They will be also emailed to you.

NOTE: For my testing I have created an account with the EU in the introduction article. This one does receive 403 errors when trying to publish a notice. Even on the preview instance! For publishing notices you need to pass an authorization process with the EU first, so for the screenshot I had to resort to an API Key from the project.

Summary

It’s done! A notice published and may it be only to the preview environment! So let’s recap, in the beginning, we started by finding the API specifications and created an account with the EU. Then, with the help of the eForms SDK, we created our first notice XMLs. After that, we refined our output with the Validation API. Finally, in this article, we generated a client for the Publication API, fixed the errors from the auto-generation and uploaded our validated notice to the service.

With this the series comes to an end, I hope the read was helpful for your journey with eForms and thanks for stopping by!

You will find all the code of this series in the repository of the sample app, happy browsing there as well.

eForms with C# 3: Validating a notice

Sun, 28 May 2023 00:00:00 +0000

In the last post, we’ve generated and serialized a notice. In the introduction, we’ve also already discussed that there is an API for formally validating notices. So let’s see what our mapping is missing!

Generating a client

For interacting with an API that already has an open API definition (here provided by Swagger) I like to use NSwag Studio to generate a client. In the studio, you enter the URL of the definition and then set the checkbox for CSharp Client and then click Generate Outputs to see the resulting Client class. From here the output usually needs some tuning. In the pictures below you can see what settings I have changed personally to fix the namespace, switch the serializer, combining all operations into one client and so on. When the output holds to the eyes I like to save the .nswag to the folder where I’d like to have the .cs in the end. This makes it easy to reload the file and tweak settings or simply reproduce the output for a newer version of the API. Finally, specify the file name as a relative path and finally, click Generate Outputs to generate the output as .cs.

So then I like to also build a small factory around it. That lets me manipulate the underlying HttpClient easily to add things like required headers. You can find the reference here. For the sample app, I’ve inserted the baseUrl via app settings and let the user insert the API Key manually via the console as this is a secret that I don’t want to upload to the repository. If possible, consider Azure Key Vault for storing secrets like this.

Calling the CVS

Next up: Calling the Validation API - or Central Validation Service (CVS).

var factory = new ClientFactory(config, apiKey);
var client = factory.GetValidationClient();

var request = new InputNoticeValidation
{
    EFormsSdkVersion = mappedNotice.CustomizationID.Value,
    Language = "en",
    ValidationMode = InputNoticeValidationValidationMode.Static,
    Notice = serializedNotice
};
var response = await client.V1NoticesValidationAsync(factory.ApiKey, request);

Interpreting the response

With a pre-generated client, this is quite straightforward to make the API call. However, the response is an XML file and as with the upload, this is untyped. As I did not find a matching schema right away in the SDK I used the Paste XML As Classes feature of Visual Studio (Edit -> Paste Special) to generate something that is deserializable.

NOTE: Depending on how much you have mapped at this stage you might get 400 responses from the service which will pop up as ApiExceptions. It is important to note that the definition of the API states that this is caused by the parameters like Language and Version, which is also printed to the Exception Message. But make sure to check the Result as well, here the real response from the service is noted, in the picture below you can see that the actual error is regarding the XML itsel! It is missing required properties.

Sadly there is another problem: The definition of the API which returns an application/xml content is not interpreted by NSwag as an XML File being returned because there is no schema given for this. I had to edit the return value here:

return new FileResponse(status_, headers_, new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(await response_.Content.ReadAsStringAsync())), client_, response_);

Now we can read the response and with a simple XML deserialization against our Paste XML As Classes class we can also check the result for validation errors (schematronoutputFailedassert) and output those in a structured way. The sample app uses extension methods here to provide a small footprint in the main logic.

var schematronoutput = response.DeserializeAsShematron();

if (schematronoutput.HasErrors())
{
    Console.WriteLine("Validation Errrors:");
    Console.WriteLine(schematronoutput.BuildErrorString());
}
else
    Console.WriteLine("No Validation Errors!");

Fixing up the mapping

Now this part I have to leave up to you of course, but the response does provide guidance. The validation errors do have a description and where to find the element that failed validation. Often you will also find things like Regexes that need to be matched and so on.

So while I can’t tell you what your notices will need and exploring all subtypes would take quite some time the Validation results can be mapped easily to the elements being failed and allowing for mostly easy fixes. Unless of course you simply do not have the data being required like a NUTS3 code that might need to be passed but is not entered by your user nor can be hard coded.

Just one thing I can offer as a little help (at least it helped me): The SDK contains some examples here, maybe something matches your needs or by chance, there is a sample for your subtype?

Summary

In this post, we generated a client, called the validation API with our previously generated and serialized XML, fixed the response output and finally filtered and interpreted errors.

At this stage, you probably have a lot to do because I don’t expect your initial mapping to hold up against the Central Validation Service (CVS). In the next post we will publish a notice (at least to the preview stage), but until then we should have our mapping sorted out!

eForms with C# 2: Generating XML

Sun, 21 May 2023 00:00:00 +0000

In the first post of this series, we already explored the swaggers of the eForms APIs. But when exploring the functions you probably quickly came to the point “ok, but what do I upload here now?”. While the swagger documents the parameters of the APIs it does not document the content of the files(/base64) to upload.

Classes from schema

But eForms SDK to the rescue: It contains the folder schemas which, as the name suggests, contains the schema in the form of xsd files. For generating C# classes there is the xsd.exe which was installed for you with Visual Studio. First, copy the schemas into your project, then right-click the folder and select Open in Terminal and then we can use something like xsd /c xyz.xsd to generate the classes for this schema. If you now try this with a file of the schemas you will quickly notice that this does not work because the .xsd of eForms (/maindoc) reference xsds of UBL in the /common folder and xsd.exe cant resolve this. You can however pass multiple files to xsd.exe so we could simply pass all the .xsd in the schema subfolders, that gives us a rather long statement in the console which is hard to repeat should the schema change in the future. But luckily you can also define a parameters file that holds the options for us so we can simply execute xsd /c /p:parameters.xml to generate the classes for a dozen xsds. The parameters.xml looks something like this:

<xsd xmlns='http://microsoft.com/dotnet/tools/xsd/'>
	<generateClasses language='CS' namespace='myNameSpace.Schemas'>
		<schema>.\maindoc\UBL-ContractNotice-2.3.xsd</schema>
		<schema>.\common\UBL-CommonBasicComponents-2.3.xsd</schema> 
		<schema>.\common\UBL-CommonExtensionComponents-2.3.xsd</schema> 
		<schema>.\common\UBL-ExtensionContentDataType-2.3.xsd</schema> 
        ...
	</generateClasses>
</xsd>

One missing feature of xsd for me: It will always name the resulting .cs like the last .xsd file, which is not very descriptive since the file will contain a multitude of classes, so I like to rename it.

Sample repo

Of course, this series of articles comes with a repository to store the full code. For example, the parameters.xml of which there is only an extract in this article. You might also find further tricks like the GenerateModels.ps1 which also renames the resulting file accordingly.

Building a model

When you want to publish a notice there are three root types that we want to instantiate: ContractNoticeType for announcing tenders, ContractAwardNoticeType for announcing the winner and maybe PriorInformationNoticeType for pre-announcing a tender. We can simply write new ContractNoticeType() now and then start to fill in the data from what the user entered into our actual app. For the sample repository, this will be static data from a NoticeModel. One advice here: Due to the XML structure with UBL, the mapping will be quite verbose. Therefore do not start to map like this:

var notice = new ContractNoticeType 
{ 
    UBLExtensions = new UBLExtensionType[]
    {
        new UBLExtensionType
        {
            ExtensionContent = new ExtensionContentType
            {
                Item = new EformsExtension 
                {
                    NoticeSubType = new NoticeSubTypeType
                    {
                        SubTypeCode = new SubTypeCodeType
                        {
                            listName = "notice-subtype",
                            Value = $"{(int)model.NoticeType}"
                        }
                    }
                }
            }
        }
    }
};

Instead, try to make functions that split up the mapping to reduce your Christmas tree. In the sample code above, the notice-subtype specifies what type of tender it is, e.g. a concession, a regular contract or a military contract. Each subtype has its requirements of fields, so it does not make much sense here to go over the mandatory fields I explored in my project since they might be very different for you. But let me at least point you to the notice-types folder of the SDK which contains a JSON definition for the fields of each subtype form. These are quite long but might be helpful. A larger application could parse those JSONs to render forms. Or the descriptions can be used to determine what a “Field BT-702(b) missing” message from the Validation API means (“Notice Official Language”).

Aside from that, we will at least need UBLVersionID = new UBLVersionIDType { Value = "2.3" } and CustomizationID = new CustomizationIDType { Value = "eforms-sdk-1.6" } (of course the versions might have changed by the time you read this).

Serializing

So now that we have a draft of what we think is a notice but we cannot pass our model to eForms directly. Instead, we need to pass it as serialized XML. For that C# offers the XmlSerializer class. There is just one trick I want to show you here: By default, the element will contain the namespace of the element but we can make these namespaces known globally like this.

var ns = new XmlSerializerNamespaces();
ns.Add("cbc", "urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2");
...
var serx = new XmlSerializer(eform.GetType());
serx.Serialize(stringWriter, eform, ns);

With that everything of the CommonBasicComponents will just have the prefix cbc. And that’s it, because of the namespace fuzz I encapsulated the serialization in its own service in the sample which returns a byte array that can be saved to a local file for viewing for now.

NOTE: You might run into an issue with the AppealStatusType which is a two dimensional array. This is not generated correctly in my version of xsd, resulting in weird errors like “Serializing JavaScript is not supported”, just adding [] to the XmlArrayAttributes type was enough to fix this.

Summary

To get an XML we first transformed the schema files (.xsd) of the eForms SDK into a .cs file with all the classes necessary to build a notice, award or prior information. Then we mapped our application model to the models of eForms and finally serialized the model into an XML file.

Next up will be to validate that model for which we will use the Validation API of eForms. But that’s the topic of the next post!

eForms with C# 1: Introduction

Sat, 13 May 2023 00:00:00 +0000

If you are doing a major tender within the EU, you also need to publish the tender on a European level. The eForms 2 interface allows you to do this programmatically, an important feature for organizations that publish tenders regularly. For everyone else, a subject matter expert will just enter the data manually into the web interface.

eForms with C#

Despite the title, the best option to interact with eForms programmatically is probably with Java. Simply because the EU also publishes an SDK for eForms in Java. But in fact, what we need to do to publish a notice is generate some XML and push that to one or two REST interfaces. Should be doable in C# as well. Spoiler alert: Of course it is! But when doing something by foot without an SDK there is always a struggle and this series of articles shall help you get started and concentrate more on the actual business problems rather than spending time on finding out how the interface works.

So whatever your reason is to stick to C#, we will make it work. My reasons are simple: This blog is mainly about Dynamcis Integration, Dynamics only takes C# for its plugins and my task was to integrate Dynamics with eForms. Simple task, but the execution was not that easy due to the lack of information on the internet.

Important references

First and foremost there is the TED Developer Docs. While we won’t use the eForms SDK and the information around the TED API is quite sparse at the time of writing there is still the search! And this was quite useful for me, for example with the codelists. I need to specify a language but DE (German) is not accepted. Searching for the codelist name eforms-language clarifies that I need to specify it as DEU.

Then there are two APIs for publishing the notices. The first one is technically optional, the Validation API only makes sure the uploaded XML is valid. Valid here means schematically correct. The schematrons of the API do check quite some plausibility but that does not mean it’s legally valid as well. I can specify the address of my organization to be Test 123 in 9999 Testcity, Testcountry, it’s a complete address but obviously incorrect information. The API has a Swagger documentation as well, find the preview environment here.

The second one is for actually publishing a notice. This is the Publication API. It will also run validation on the notice and you can retrieve the results after the upload. However since it has already saved your notice, you cannot upload a corrected XML with the same ID again. This is why I prefer to check my notices first and then “fire and forget” the notice since I’m sure it will work. The API has a Swagger documentation as well, find the preview environment here.

There are 2 more APIs present: The Search API and the Visualisation API. These are for finding and “printing” existing notices. This might be interesting for you if you are not coming from the producer side of notices but from the consumer side and need your application to be able to search and display tenders.

Testing an eForms Swagger

The fact that the APIs have Swaggers allows us to try out such APIs quickly. For example, if we would have generated an XML file we can push them by hand for testing even if we have not yet implemented clients for interfacing with the API.

For that, we will need an account at the Developer Portal. Click Login at the top right and create an account. That account can have any email, even private ones! But this email will be used to send you validation reports when publishing a notice. After confirming the email you will want to log in and select the menu point Manage API Keys. Generate a new key and head to the swagger of the Validation API (CVS).

When we use the /notices/validation endpoint with the default values and our API key the result message should be something like ‘The notice is an invalid XML file; it cannot be parsed’ because the default value is of course not valid, but that’s fine for now. One thing I’d like to mention with the version: The default values use eforms-sdk-1.0 but looking at my results, it seems like the validation was greatly changed between that and version 1.6, so check the version-range endpoint for the newest available version when checking with a real XML.

The Publication API works a little differently in terms of authentication. There is no simple header in the swagger that you can fill, instead, you will need to use the Authorize Button on the top right and enter your API key, Authorize and Close. Then you can use an endpoint like /notice/notices/{business-id}/validation-report with the default values to try out the API.

Summary

So this article was an introduction. It detailed that using C# for eForms should be a conscious decision, providing links to the documentation and a short overview of the associated APIs. Last we generated an API key for the preview environment of eForms and used it to explore the APIs. In the next post, we will take a deeper dive into the actual programming, generating an XML for a notice.

Special Thanks

To Şevket Çokay and Florian Unterberger for supporting me with subject matter expertise and contacts in implementing eForms integration!

Plugin Self Registration 4: When to use it

Sun, 07 May 2023 00:00:00 +0000

After we’ve explored the use of self-registering logic in the context of the generic name combination in the previous post, there is certainly the question “Should we use this everywhere now?” Certainly not!

When to use it and when not

The added plugin(s) for registering the logic are extra effort that we will try to avoid whenever possible. Think about this requirement: “We want to validate IBANs on incoming orders and mark invalid ones for review”. If this was done in the frontend you can easily provide a PCF control (Power Component Framework) to perform the check for any entity. However, if the orders are inserted via the backend - e.g. via integration with a shop system - this would mean that someone has to open every single order to check the result. Therefore a backend solution like a plugin or Flow might be preferred. And then again, if this is regular project work we will just create a regular plugin. If it has to work on several entities, we will implement it generically and just register it manually to the required entities. When it should work on an additional entity we will simply add another registration. However this of course stops working as soon as we’d like to turn this into some sort of ISV solution, we cannot know the entities to register the plugin to in our development environment.

But in this case, we have a different option to avoid self-registration: Making a custom entity for “IBAN”. The customer will then add a relationship (e.g. lookup) to their entity instead of a string field and our validation logic can run on creating and updating the IBAN entity. Since we know this entity and its fields in the development environment the registration is static and easily done.

So we should always look out first for an option to make the registration static before we resort to the dynamic registration explored in this series. This will be most of the time! But now you are prepared for the other few times as well where you a situation that allows for static registration is not feasible. The sample of name combinations we’ve explored came to this situation because it was highly tied to the primary field of custom entities, something we can’t bend to a fixed set of entities, unfortunately.

Conclusion

With this, the series comes to an end. From the initial idea, we moved on to a solution to ease the process and make it more feasible to implement. Then we looked into a practical use case where plugin self-registration allows us to implement something that is otherwise pretty unthinkable. Finally, I’ve used this post to calm down my own and your mind a bit to not run out and implement everything with this new possibility and rather use it sensibly.

Cheers, and see you in the next series!

Plugin Self Registration 3: Putting it into practice

Sun, 30 Apr 2023 00:00:00 +0000

If you are a developer you probably have done a naming plugin some time in your career. It is a common requirement for custom entities where the users can’t easily pick a name. Instead, it should maybe be a combination of fields, just like the fullname of the contact entity. This is particularly common with the primary field as you can not make it calculated and Business Rules can only be a solution in very simple cases. But you may face requirements for combined string fields of course. However the requirement, you have multiple solutions:

Business Rules are quite limited.
Real-Time Workflows might work, but are not the most efficient and their future is anybody’s guess.
Flows (PowerAutomate) are very flexible, allowing to cover many requirements, however, they are not synchronous, leaving the field empty after saving. For a primary field, the user will then see “New CustomEntity” at the top of the form after he saved the new record.
A plugin has none of these shortcomings and is therefore often the preferred way of the customer. However I can’t count how many times I was requested by customers and business analysts to create such a plugin with trivial requirements and every time a “coding monkey” was needed.

Now it’s easy to come up with the idea “Let’s just create something generic that can create strings from a template and let the non-coders fill it”. However, the problem lies in the plugin registration of Dynamics which does not allow for a global registration for that logic.

And this is where the solution from the previous post comes in. When someone fills out the template in the configuration entity, we can register on create and update of the targeted entity and then execute the generic logic.

Configuration Samples

So the template orientates on format strings of C# - I’m a techy after all. We write something like {0} - {1} and then specify that 0 shall be Field A and 1 Field B. Now specify the entity and which field the result should be written to and we are golden.

Let’s first look at some configuration samples before we dive into the inner workings. So here we combine a regular string field with an optionset. The optionset of course contains a number as the value which would be part of the string, but with a C#-like modifier we can print it as the English label. The result looks like this:

Similar things are also possible with Money fields which are transformed to their decimal value allowing you to specify the standard C# formats as well as custom ones.

Lookups will by default print like this: transactioncurrency(b5f9a0f3-7db9-ed11-9886-000d3ab6ddad). But we can use the modifiers Name, Id and LogicalName to print something different or specify the logicalname of a field at the entity behind the lookup. And this is even chainable with a semicolon! But let’s look at some simple samples in this post to not overcomplicate the matter. After all, this is designed to cover the most basic requirements of name generation and not fancy pants stuff where it’s absolutely ok to let someone code that.

That in itself is quite cool, but for me the real magic here is that this is possible on any entity, registering this to the most common entities like account, contact, opportunity, incident, … would be no problem, but it works anywhere.

The Inner Workings

If you have read the last post you already know where this is going, of course we are going to generate records of the mwo_pluginstepregistration entity. To be precise, two records, one for Create and one for Update. And for that, we won’t need a whole lot of code, creation and update of the mwo_namecombination is handled with a mere 160 lines of code (at the time of writing) and deletions were handled in a separate class with 35 lines of code. It even covers checks for whether the fields exist and translates a deactivation of the name combination to a deactivation of the step and vice versa. Why is it so short? We simply create or update another entity if our configuration entity is created or updated. By the way: The triggers on mwo_namecombination of course use SPKL for registering the plugin because we absolutely know which entity and fields we want to trigger for.

But back to the registration, when you create a similar mechanism the heart of the registration will be a mapping to the registration, so let’s add a (shortened) extract of this code:

var step = new mwo_PluginStepRegistration
{
    mwo_EventHandler = typeof(NameCombiner).FullName,
    mwo_EventHandlerType = mwo_EventHandlerType.PluginType,
    mwo_Name = $"{nameof(NameCombiner)}_{subject.mwo_Table}_{subject.mwo_Column}_{message}",
    mwo_Managed = true,
    mwo_SDKMessage = message,
    mwo_PrimaryEntity = subject.mwo_Table,
    mwo_PluginStepStage = mwo_PluginStage.PreOperation,
    mwo_Asynchronous = false,
    mwo_StepConfiguration = subject.Id.ToString(),
    mwo_FilteringAttributes = filters, 
    mwo_ImageType = isUpdate ? mwo_ImageType.PreImage : mwo_ImageType.None,
    mwo_ImageName = "Default",
    StateCode = isActive ? mwo_PluginStepRegistrationState.Active : mwo_PluginStepRegistrationState.Inactive,
    StatusCode = isActive ? mwo_PluginStepRegistration_StatusCode.Active : mwo_PluginStepRegistration_StatusCode.Inactive,
};

So with the design of the configuration entity, we made sure that we know the target entity (mwo_table) and the filters (here a combination of the fields {0} to {9}) and the rest is either static or semi-dynamic, based on statecode and the fact that we are registering to Create and Update. In this case, I do pass the ID of the name combination as configuration for the step. This is not needed, the logic could just query for name combinations registered to the target entity, but this would mean if two combinations are registered to the same entity, both combinations would be executed twice since there would be two registrations as well.

Conclusion

What’s left to do now? Of course to implement all those cool ideas for generic logic that came to your mind while reading through the series! There will be one more post out soon elaborating more on the topic of strategies in self-registration and how you can get around it sometimes. Needless to say: While the D365NameCombiner served as an example for your self-registration ideas here it is of course a working solution with actual use! Check out its Wiki for more samples. In the next and last post of this series, we will take a look at when to use this - and when not.

Special Thanks

To Lukas Leitzinger for contributing to this repository with ideas and code!

Plugin Self Registration 2: The Managed Solution

Mon, 24 Apr 2023 00:00:00 +0000

In the last post, we dived into the idea that one plugin could register a second plugin to allow for more flexible registration of plugins. But we’ve ended with the caveat that a lot of entities are involved and no relationships are allowed.

My proposed solution to ease the process of self-registration is to introduce an abstraction layer in form another entity. As this will be a regular custom entity, we can relate to it as much as we like.

The Repository

Here you will find the public repository of this solution. If you want to use it, simply download and install the managed solution to your instance.

The Mapping

If you’re familiar with registering Plugins in Dynamics 365 using the traditional Plugin Registration Tool (PRT), understanding the mapping to the new Plugin Step Registration (mwo_pluginstepregistration) entity can be helpful. In this section, we will explore how the Plugin Step Registration entity maps to the entities in the PRT, and how you can leverage it for registering steps.

Plugin Type in the Plugin Step Registration entity corresponds to Plugin (plugintype) in the PRT. However, it’s important to note that you cannot create a new Plugin with the Plugin Step Registration entity - the Plugin must already exist! What you are creating here is a Step (sdkmessageprocessingstep). In the images below, you can see further mappings, they are straightforward. Filtering attributes can be specified using commas as separators. It’s worth mentioning that Secure Configuration and User Context are currently not supported. Delete AsyncOperation will be set to “Yes” if you select Stage PostOperation & Async = “Yes”.

The image configuration tab allows you to configure an Image (sdkmessageprocessingstepimage) for the Step. The mapping is straightforward, but it’s important to remember that, for example, you cannot register a PreImage to the Message “Create”.

The Step is now managed by the Plugin Step Registration record. This means that if you update the record, the Step will be updated as well. Similarly, if you deactivate the record, the Step will be deactivated, and if you delete the record, the Step will be deleted too. However, you can untie this one-way connection between the record and the actual Step by setting the field Managed to “No”. This allows you to delete the record while leaving the Step untouched. If you’re not sure which record manages which Step, you can check the Plugin Step ID against the ID of the Step in the PRT.

Service Endpoints

Additionally, it’s also possible to have Service Endpoints as Event Handlers (formerly known as Plugin Type Name). You can reference them by name in the Plugin Event Handler entity and then select them in the Event Handler Lookup on the Plugin Step Registration. However, it’s important to note that by their nature, Service Endpoints can only handle asynchronous steps, and attempting to register a synchronous step will fail.

The physical relation

As mentioned before we cannot store the actual step (sdkmessageprocessingstep) in a relationship like a lookup. Therefore the Plugin Step Registration saves the guid of the step to a string field and parses it back from there. This is of course rather unelegant, but this is why we will use this abstraction for our regular code, we will never need to worry about this again and can simply relate to the Plugin Step Registration.

Next steps

Now that we know roughly how it works, how do we put this into practice? This is exactly the topic of the next post, where we will use this to register a “naming plugin” to any entity.

Links

Also, check out this Wiki article detailing how the entity maps to the plugin registration tool.

Special Thanks

To Lukas Leitzinger for contributing to this repository with ideas and code!

Legal Notice

Wed, 19 Apr 2023 00:00:00 +0000

Marius Wodtke

Contact: marius.wodtke@outlook.com
Address: Marktgasse 21-23/27, 1090 Vienna, Austria

Guarantees

This is a private website, there is no associated company. Especially my employer cannot be held liable for the content published here.

The author tries to serve the information on this website with his best conscience. However he cannot guarantee the correctness of the information and will not be held liable for damage from using the information provided here.

Even though I check my content as well as linked content when preparing posts, I cannot guarantee external content. This is especially true if the external content changes after I publish a post. Liability for linked content is only provided by the operator of the external website.

Plugin Self Registration 1: The Concept

Wed, 19 Apr 2023 00:00:00 +0000

Tools like spkl do a great job at registering plugins. But did you ever have to turn down an idea due to the reasoning “I can’t determine on which entities this would need to run when I implement this”? While most of the time you can determine quite well at the design time which entities and fields need to be part of the trigger, sometimes, especially in very generic or configured logic you run into the problem of design time registrations.

Unfavorable requirements

Let’s take a look at some requirements that are problematic: “We need to export all changes to certain entities in a specific format, we want to configure the entities and fields on the fly because we can’t determine a complete list now.”
“We have a specific pattern of how to build the primary fields for our custom entities, implement that pattern for us so our admin can apply it to the new entities.”

If you had a generic logic that can run on any entity of course you could just deliver the plugin to the production and then tell the key user/admin/whomever to use the plugin registration tool to add a step to your plugin type, but lets be honest here, the audience for that is quite small. Something like a configuration entity would be beneficial for those scenarios. Even a key user would know the entity and field name to create a record in CRM, but creating a plugin step is a whole different story.

And if we think about highly configurable logic that you might want to release to multiple customers as an ISV solution: It becomes unfeasible to train them on the Plugin Registration Tool and at the same time it is impossible to preconfigure the solution in development because you don’t have the customers custom entities and fields to register to.

The idea

So for this problem, let me pose an idea to you: What if we just create a regular entity for configuring your logic? Then we create a plugin reacting to changes in your configuration entity and that will handle the registration of a plugin step for the real logic based on what someone just did at the configuration entity. Of course we will then always have two plugins, one with the actual logic and one that will make sure that the logic is triggered at the right moment.

To come up with a more visual representation of this idea: “Let’s transform a configuration entity into a spkl-CrmPluginRegistration at runtime”.

The problem

That sounds quite simple actually, but the devil lies in the detail: For registering a plugin step you will need to interface the following entities: sdkmessage sdkmessagefilter plugintype (serviceendpoint) sdkmessageprocessingstep sdkmessageprocessingstepimage (sdkmessageprocessingstepsecureconfig)

What’s next

That’s quite something, right? On top of that you cannot create relationships from or to these entities, so you cannot simply link your configuration and will have to somehow keep the connection to your sdkmessageprocessingstep as well. But fear not and stay tuned for the next post in this series where I will show you some help to simplify the process to only managing one regular entity so that you can focus on translating your configuration entity into a plugin step!

Free Tools

Mon, 01 Jan 0001 00:00:00 +0000

Power Pages

[Archived] PowerPagesClientAPI tries to replicate the ClientAPI of Model Driven Apps in order to streamline development.
Archived due to Microsoft publishing an official Power Pages Client API.
Read more
PowerPagesTemplate is a starting point for anyone who needs to do more than just a little bit of JS for their Site. Supports Typescript and Bundling for more complex projects.
Read more
[Archived] PowerPagesActions is an Adapter to directly call CustomAPIs from Power Pages.
Archived due to Microsoft enabling this in Power Pages Server Logic. The capabilities of this addition are shown here and here.
Read more

XrmToolbox & Power Platform Toolbox

Teams Integration Enabler helps you to integrate custom entities with Teams Channels.
Read more It is also available for the Power Platform Toolbox. Read more

Dataverse (Low-Code)

D365RibbonHelpers is a set of command and rules to enhance the possibilities with the ribbon without coding. Or simply a reference for anyone who is into high-code. Read more
D365NameCombiner uses D365LivePluginRegistration to enable synchronously generated naming of records without the need of writing a single piece of code.
Read more
Contributed to VATNumberValidator to fix it after the old CORS proxy changed its licensing scheme.
Read more

Dataverse (High-Code)

TimelineCustomConnector contains samples to help getting started with this feature.
Read more
D365ServiceBusProcessors contains samples to help getting started with consuming messages produced by the Service Bus Integration of Dataverse.
Read more
D365LivePluginRegistration enables programmers to register plugins dynamically at runtime. Read more

OT

eForms C# Sample I had to integrate with Tender Electronics Daily (TED) an EU service for publishing tenders in Dataverse Plugins. And although this service is mandatory for bigger tenders, the information around integration and all of it was for Java. I hate those gaps in the internet, so I felt like filling it with this sample code.
Read more

Links

Mon, 01 Jan 0001 00:00:00 +0000

Microsoft Docs Contributions

Mon, 01 Jan 0001 00:00:00 +0000

Self-awareness page for collecting my requests/suggestions for the docs.

2024-07-26 - 4 Fixes on Calling Cloud Flows from Power Pages
2024-06-29 - Microsoft Authentication Provider - Client Secret correction
2024-06-25 - Custom Connector for Timeline documentation - Icon numbers
2024-06-08 - Add limitation for dataflows with administration mode
2024-03-04 - Enable enhanced experience for email attachments - Configuration wording
2024-03-04 - File Behavior in new designer
2024-01-17 - Add Refresh step to Post configuration for custom entity
2024-01-11 - Create and use dataflows in Power Apps - ALM link
2024-01-11 - Dataflows Solution Awareness - Limitation additions
2023-08-10 - Add reference to timeline pin setting
2023-09-28 - More information regarding the certificate
2022-09-22 - addOnPostSave in wrong hierarchy
2022-09-14 - Breaking Changes in PnP.Framework
2022-09-14 - [17.3.0] You must install or update .NET to run this application.

Search

Mon, 01 Jan 0001 00:00:00 +0000