Hi guys,

I wanted to share with everyone a pretty bad surprise when I tried to install a brand new Dynamics v9.0 instance OnPremise for a client.
I know that installing an OnPremise instance is not something you do everyday now but ...

Besides all steps which were fine, I started to struggle when I had to install the Reporting Extensions (which is a requirement to full fil the installation).

Here is the issue :

Don't get me wrong, I've tried to access the link, looked for the error message, it was all about the SSDT which was already installed along with the Visual Studio instance.
And of course, before I installed the SSRS on the right server.

After discussing with a colleague who faced the issue with another client (this was a known issue by MS), we figured this out.

Here are the steps to fix the installation :

1. You should have the installer from that url : https://www.microsoft.com/en-us/download/details.aspx?id=57478
2. Extract it using the following command line :
   ./CRM9.0-Server-ENU-amd64.exe /extract:C:\YourPath9.0 This will create a folder with all necessary files.
3. Next step is to download the 0.3 update here : https://www.microsoft.com/en-us/download/details.aspx?id=58153
4. Download the CRM9.0-Srs-KB4490599-ENU-Amd64.exe file
5. Extract it using :
   ./CRM9.0-Srs-KB4490599-ENU-Amd64.exe extract:C:\YourPath0.3
6. Get back to your "C:\YourPath9.0" folder and edit the file install-config.xml in the SrsDataConnector directory
7. Replace <patch update="false"></patch> by <patch update="true">C:\YourPath0.3\Srs_KB4490599_amd64_1033.msp</patch>
8. Run the Reporting Extensions install again and this should be fine !
   

I hope this helped you.
Cheers,
Clément

PS : you do have several step by step guides :

• https://butenko.pro/2019/01/09/d365ce90stepbystep_installation/
• https://www.blog.allandecastro.com/installing-dynamics-365-v9-on-premise/
• https://learn.microsoft.com/en-us/dynamics365/customerengagement/on-premises/deploy/install-or-upgrade-microsoft-dynamics-365-server?view=op-9-0

Hello everyone,

Intro

Today, I want to share my findings regarding the creation of an autonomous agent in Copilot Studio (CS).
What I missed and spent too much time figuring out, the pre-requisites and so on.

As you know, we can build agents in Copilot Studio using Topics, Generative Answers, Orchestration, Generative Actions.
Those capabilities are awesome but this need to be used using a chat to discuss with the agent.

At the end of last year (October 2024), Microsoft announce the autonomous capability which can help to change the "agent game" (details).

Use cases

Basically in few words, an autonomous agent is an agent as you know it with the trigger to automatically trigger it with a cloud flow.
Of course, this is way beyond a cloud flow.

From my point of view, the main difference and advantage of the autonomous agent compare to a cloud flow is the Orchestration side of the agent.
Having the capability to automatically trigger the right topic or action based on an input is a must have. In a Cloud flow, you would need to define all branches of your processes to know where to route a request.

My very simple use case for the following was to leverage the capabilities of the autonomous agent, to grab the information from a devops ticket with a timeframe in order to reflect it in Outlook calendar automatically.

I create a DevOps ticket assigned to me with the time slot, I want to see this in my outlook.

How to configure it

Few steps :

1. Activate the orchestration (for english agents only for now and in preview)
2. Define your trigger with Power Automate
3. Test your trigger and the orchestration in Copilot Studio
4. Deploy

I feel like there is no need to paraphrase the documentation, you can find details here

You have 2 ways to test your autonomous agent :

• Trigger at least once your trigger flow and reuse it in Copilot Studio using :
  
• Trigger the flow and "wait" for the automated run of the agent

How to debug !

That's a real pain point for now on Copilot studio, the lack of information when building and debugging an agent.

To follow all run of your agent, you do have the "Activity tab", there you will find something like :
Quick explanation here :

• Complete : well done, all good !
• Waiting for user : this relates mainly to the fact that connections are missing or need to be reconfigured
• In Progress : something went wrong, argh ...

Let's focus on the In Progress mainly for now.

Something went wrong but where ? what ? how ? why ?

When tested the agent directly within Copilot Studio everything was fine !

You can click on each run in order to find more details :
This displays the activity map of all actions / topics triggered automatically using the orchestration.
By checking the screen, all seems fine, but no !
The golden ticket is not far away but you need to find it the first time :

This will lead you with (obviously) the transcript of this run, and for example here, I can see that I do have a datetime format issue which prevent my Outlook creation of event fail.

Therefore, I now know where to check and test in order to fix this.

The behavior between the test in CS and the direct trigger are different

One other point to be aware of is how the agent works between CS and autonomously.
As soon as you know it, it makes perfect sens but ...

In Copilot Studio, every changes on your agent are directly reflected.
However, when using it with the "real" trigger, this will trigger the latest version of the agent published.

Be sure to publish your agent as soon as you are done or fixed thing to prevent you some time wasted sadly (my story)

Connection issue in the actions

For now, make sure that all actions are using the Copilot Author connection, that's the only way it can work for now.

This means that if you go for an autonomous agent right now (besides the fact that it's in preview), you can't use ootb the context of the user who are using the agent.

Conclusion

I have to admit that I struggled a bit with these 3 points and wanted to share it before people would waste time like I did because I missed important part.

Hope this can help you,
Cheers,

Hello everyone,

Today I'm going to discuss about a quick tips.
The other I was building a canvas app for a client, nothing fancy so far.
One need was around the usage of a multiselect Combo box control (old or modern one)

I struggled few minutes about the auto-selection of default value.

Let's explain the situation with an sample :

• I do have a list of items for this control, like : "Item 1; Item 2; Item 3; Item 4"
• My data source record contains "Item 1;Item 4" as text value (yes I'm using a SharePoint List in this case !)

In the first place, I will simply pass as input parameter in my DefaultSelectedItems (expecting an array of items) property the following :

Split(First(colSource).val)  

(colSource being a local collection of my SharePoint list and the val property the column which contains the textual values of my combo box)

The result is the following :
As you can see, the legacy and modern controls seem.

The main problem (let's say it this way), has yet to come.
Visually speaking the values are selected but once I want to select manually, nothing seems to be mapped properly.

I'm still able to select the Item 1 and Item 4 from the list like nothing was already selected.
This seems to be related to the fact that mapping using only the "text value" of the property doesn't seems to be enough.

The workaround that did it is to retrieve from the options list the related record such as :

Filter(ComboBoxSample, Value1 in Split(First(colSource).val, ";"))  

The idea here is to retrieve the complete record related to a selected value in order to make the control aware of the data selected.

Result now is :

Quick tip of the day !

Enjoy and have fun with your Canvas Apps !

Hello everyone,

Today, I had an interesting challenge from one of my client.
Here is the use case :

"We want to keep using the Word template provided by the Dataverse because it's easy to configure the data mapping between the Tables and the word template. But we also want to integrate values from another system", and the solution must be as integrated as it is today for the enduser.

Basically, the challenge here is to "recreate" the selection screen of a template and use a Power Automate flow to make all the job.
In details this will give something like :

1. Create a custom page opened by a click in the ribbon (here is how to do it : https://learn.microsoft.com/en-us/power-apps/developer/model-driven-apps/clientapi/navigate-to-custom-page-examples?WT.mc_id=BA-MVP-5003014)
2. Retrieve all templates (word is the example) related to the selected record's table
3. Select the whished Template
4. Generate the document via Power Automate

We will focus on the step 4 as this is the most fun part 🙂.

Prerequiste :

In order to make this work, you need upfront to add your extra tags in the word template which will be uploaded to the Dataverse.

Detailed Schema of step 4 :

Step 2) I decided to use the HTTP with Microsoft Entra ID (preauthorized) connector to ease the POC. Of course for the step, you could go with a Custom connector on top of the Dataverse API. Reason for not using the standard Dataverse connector is that this action is not "exposed".

This will give you something like :

URL : /api/data/v9.2/ExportWordDocument  
BODY :  
{
   "EntityTypeCode": 2
   },
   "SelectedTemplate": {
      "@odata.type": "Microsoft.Dynamics.CRM.documenttemplate",
      "documenttemplateid": "GUID HERE"
   },
   "SelectedRecords": "[\"GUID HERE\"]"
}

Parameters :

• You can find all EntityTypeCode here.
• The SelectedTemplate corresponding to the Document Template ID selected.
• The SelectedRecords corresponding to an array of the records you want to generate the word document for.

Step 3) Using a compose will allow you to prepare the file content we will use to create the document on SharePoint in the next step :

{
  "$content-type": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
  "$content": @{body('ExportWordDocument_Action')?['WordFile']}
}

Here we define the content type for a word file and keeping the property "WordFile" only from the ExportWordDocument action.

Step 6) We now have our document generated from the dataverse in SharePoint, we can now fill it with the external data we retrieved from the previous step : On the above screenshot, we can see the placeholder which are used by the Dataverse word template generation, our focus is about the ones in the red rectangle which will be used for our extra data.
All you need to do here is to map those fields with the data you extracted.

Step 7) Here the File Content property will be filled with the body of the previous action, ie @{body('Populate_a_Microsoft_Word_template')}.

Wrap up :

We created a dedicated process to keep using the word template generation from Dataverse to ease the data mapping for the end user update.
We extended it with external data and put the final file on SharePoint (it could be send by email, send back the file content to the Custom Page to directly download it or whatever way you want 😋).

Hope this can help you some times.
Enjoy,
Cheers

PS - Possible improvement on this POC :

• Use a Service Principal with the Entra ID connector otherwise your users will be lost or use a Custom Connector on the top of the Dataverse API or use a provided connection with the "Run only user" section of your flow.

Hello everyone,

Let's see what can we do with Dynamics 365 CRM & some AI/ML today.

What are we talking about ?

Artificial intelligence (AI) and machine learning (ML) are revolutionizing the way organizations operate and interact with their customers. These technologies have the potential to greatly improve customer engagement, streamline operations, and provide valuable insights into customer behavior and preferences. Dynamics 365 CRM is one platform that is at the forefront of this revolution, offering a suite of AI and ML capabilities that are designed to help organizations better understand their customers and improve their overall customer experience.

In this blog post, we will explore the latest AI and ML capabilities in Dynamics 365 CRM, including how to implement these features in your organization and real-world use cases.

Understanding the AI and Machine Learning Capabilities in Dynamics 365 CRM : Dynamics 365 CRM offers a variety of AI and ML capabilities that are designed to help organizations better understand their customers and improve their overall customer experience. Some of the key AI and ML capabilities in Dynamics 365 CRM include:

• Customer insights: This feature uses AI to analyze customer behavior and preferences, providing valuable insights into customer behavior and preferences. This information can be used to create targeted marketing campaigns, personalize the customer experience, and improve customer engagement.

• Sales insights: This feature uses ML algorithms to analyze sales data, providing valuable insights into sales trends, customer behavior, and market trends. This information can be used to optimize sales processes, improve sales forecasting, and increase sales productivity.

• Customer service insights: This feature uses AI to analyze customer service data, providing valuable insights into customer behavior and preferences. This information can be used to improve customer service processes, optimize customer support, and increase customer satisfaction.

Implementing AI and Machine Learning Capabilities in Dynamics 365 CRM

Implementing AI and ML capabilities in Dynamics 365 CRM is a straightforward process that can be done in just a few steps. Here is a step-by-step guide to implementing these capabilities:

Determine your AI and ML needs: Before implementing AI and ML capabilities in Dynamics 365 CRM, it is important to determine your organization's specific needs. This will help you determine which capabilities are most relevant to your organization and which features are most important to prioritize.

Choose the right AI and ML capabilities: Once you have determined your AI and ML needs, you can choose the right capabilities to implement. For example, if you need to analyze customer behavior and preferences, you may choose to implement the customer insights feature.

Set up the AI and ML capabilities: Setting up the AI and ML capabilities in Dynamics 365 CRM is a straightforward process that involves configuring the relevant settings and connecting to the necessary data sources.

Use the AI and ML capabilities: Once you have set up the AI and ML capabilities in Dynamics 365 CRM, you can start using them to analyze customer behavior and preferences, improve sales processes, and optimize customer support.

Real-World Use Cases for AI and Machine Learning Capabilities in Dynamics 365 CRM

Here are a few real-world use cases for AI and ML capabilities in Dynamics 365 CRM:

• Customer insights: A retail organization uses customer insights to analyze customer behavior and preferences, providing valuable insights into customer behavior and preferences. This information is used to create targeted marketing campaigns, personalize the customer experience, and improve customer engagement.

• Sales insights: A sales organization uses sales insights to analyze sales data, providing valuable insights into sales trends, customer behavior, and market trends. This information is used.

Enjoy,
Cheers

disclaimer : storing pictures on external hosting might not scale. Depending on your usage. https://docs.glideapps.com/all/courses/quick-starts/getting-started/adding-images#external-hosting

2021-nov-16 update : updated with data flushing preventing parallel execution creating duplicates.

Glideapps is really a convenient tool which I use for numerous personal usages: it uses google sheets into mobile application in minutes.

Beside being a developer, I appreciate the ease and rapidity to make small mobile applications. Moveover, having a google sheet as a database allows this to be shared to other people and supports bulk operations.

I even use it for my cooking recipies :)

Free limitations are enough for personal recreative usages

• 500 lines (shared accross all your sheets)
• 1000 sheet edits
• 100 MB of images & files (if uploaded on glideapps)

One incredible feature is the capacity to easily upload any pictures, files or mobile camera photos and store it in your app.

Incredible to upload pictures in 2021 from a mobile phone ? In 5 minutes effort and already published in your hand, yes.

Unfortunately this leads to one major limitation of glideapp free version. With recent phone pictures quality, each file around 3MB, 100MB limitation will be reached quickly.

Hopefuly, there is a workaround

• glideapps calculates storage only for picture hosted on their infrastructure and linked in google sheet
• glideapp supports pictures from anywhere on internet

Writing an `apps script' tied to google sheet could

1. download pictures
2. resize it, for my needs, 3MB pictures aren't necessary and slow down loading time. (Done by https://github.com/tanaikech/ImgApp, instructions for setup : https://github.com/tanaikech/ImgApp#how-to-install)
3. store them in a public google drive folder
4. finally replace links into cells

To be configured

• range where script should perform replaces
• google drive folder id

Associated with a trigger onChange, it would be transparent.

Enjoy cooking.

Hello,

During project, we often have the need to implement some complex criteria's handling for approval processes for example.
Redevelop this when we are talking about simple conditions if fine.
As soon as we want to be able to manage criteria's like :

Field1 = Value1 && Field2 = Value2 || Field3 != Value3

This is starting to be funnier to develop and especially when you don't want to hardcode anything but keep it flexible.
And if you don't want to rely on the developer as soon as you want to update those conditions, well ...

Why Dataverse Views ?

A friend of mine told me once :
"Clément, what if we use the views definition to handle those criterias with a standard functionality of the Dataverse ?", Fabien Camous.

Sometimes when we have an idea in mind, we stick to it while there are really simpler solution in front of you. Developing the flexible criteria's matrix with json as input VS using the Dataverse Views was a quick choice.
I started to dig into that direction and this was really the great idea.

You are already working with Dataverse so it's open to your usage without extra development and especially the capability of a functional consultant or a key user is "enough" to update the criterias.

Goal ?

Our goal on that project and in the examples which follow was to make sure that a record was matching some criterias or not and based on that result set some fields values.

How to ?

The first step will be obviously to create the view :

You can see with the following that we have several criteria's with AND / OR conditions which can be quite complex to implement programmatically from scratch but it took 2 min to do it be the view definition of Dataverse.

As you can see, we have a field called Opportunity ID in that sample, this allow use to make sure that we catch the unique Opportunity record, it's a dedicated field with autonumbering but the same thing could be done with the GUID field of the entity.
This Opportunity ID value is set to 9999999 by default to easily replace it with the special record value you are targeting.

Then the next step will be to grab the view GUID in order to use it in your plugin / CWA or wherever you need it.

Here are the snippet code to perform the magic :

1- Retrieve the view definition

For one view at a time : (savedquery for system views and userquery for personal views)

var fetchXmlQuery = _service.Retrieve("savedquery", new Guid("VIEWQGUID"), new ColumnSet("fetchxml"));  

For multiple views at a time :

var views = ["VIEWGUID1", "VIEWGUID2", "..."]; // could come from somewhere else

var fetchXmlQueries = _service.RetrieveMultiple(new QueryExpression()  
{
    EntityName = "savedquery",
    ColumnSet = new ColumnSet("fetchxml"),
    Criteria =
    {
        Conditions =
        {
            new ConditionExpression("savedqueryid", ConditionOperator.In, views)
        }
    }
});

2- Use the fetchXML definition to dynamically update it and execute it

foreach (var view in fetchXmlQueries.Entities)  
{
    var fetchXML = view.GetAttributeValue<string>("fetchxml");

    fetchXML = fetchXML.Replace("999999999", oppId);
    var result = this._service.RetrieveMultiple(new FetchExpression(fetchXML)).Entities;

    if (result.Count > 0)
    {
        // Record passing the criterias
        // Perform action
    }               
    else
    {
        // Record NOT passing the criterias
        // Perform action
    }
}

In that part, we modify the previous value we setup "9999999" into the value of the actual record we want to compare with.
Then executing the updated fetchXML allows us to make sure that we do have a complex valid query.

If we do have a result, it means that the record match the criterias.
If we do not have a result, the criterias are not matching the record value.

Based on the following result you can then perform a specific action and continue your record process.

Where to use it ?

The above example is about plugin directly.
You could imagine having the same approach with an Action which could be called via a Flow from a Canvas App.
Using this in an Azure Function to get the return result then.
There are a lot of possible scenario with it which is not "stick" to the classic plugin.

Conclusion

As you can see, we defined a "complex" with its limits of the Dataverse views capacity (which are still quite good) and implemented the logic within a plugin in few minutes when with a complete new logic it could take hours or days !

One recommandation from my side, it is to at most try to execute this in async mode to make sure that you are not slowing the UI during the process if you have many records / views to check. This is a recommandation since we make sure to perform only one request to grab all views definition but you can't get rid of the RetrieveMultiple request for each fetchXML.

Let's say that in that particular project, it was clearly a quick win and hope that quick win can be useful to some of you :

Enjoy,
Cheers

Hello everyone,

Today's question is around the triggering a flow from an access team.
Seems simple as it is but you need to dig a bit more to perform the full process.

Scenario

My business requirement was to send an email (without code) when user was added to an access team.

Main limitation/problem so far is the fact that a flow using the Trigger "When a record is created, updated or deleted" on the TeamMemberShip entity will never be fired.
Reason ? Unknows so far ...

As I wanted / had to have the process working, after few research I ended up with the solution :

1. Create your flow with a Http request trigger
2. Create a WebHook from the CRM/CDS instance linked to your flow
3. Add a step on the AddUserToRecordTeam message (teamtemplate entity)
4. Configure the flow

Process

Flow creation + Webhook configuration

It's not needed to rewrite what was nicely explained by other nice people, you can go to Stefan's blog post and check this out

And come back right after ! :)

Step configuration on the Plugin Registration Tool

Our goal was to trigger the workflow when user was added to an Access Team.
Good point is that there is a dedicated message for that : AddUserToRecordTeam but this message can't be linked to the entity where the access team is used (ie : Opportunity or Account).
Nevermind, we will deal with it later !

Configure the Flow

Here is the interesting part !

First step:

As the flow receive the Plugin context as JSON is to properly parse it.
(This is the most tricky part or not).

What I needed in my use case as information were :

• GUID of added user
• Record Id where the user was added (for the email content)
• Entity LogicalName to make sure, the flow was processing a record I was interested in.

As soon as you ran your first run of a flow, you will receive the payload of the Plugin Context you are familiar with, should look like that :

{
  "BusinessUnitId": "cdddddf5-1d81-ea11-a813-000d3a4b2ac6",
  "CorrelationId": "69b8ac32-688c-4c80-9c93-5d6342178db9",
  "Depth": 1,
  "InitiatingUserAzureActiveDirectoryObjectId": "00000000-0000-0000-0000-000000000000",
  "InitiatingUserId": "9b781be7-d176-404b-9d2f-1d830dae011f",
  "InputParameters": [
    {
      "key": "Record",
      "value": {
        "__type": "EntityReference:http://schemas.microsoft.com/xrm/2011/Contracts",
        "Id": "c6dd5426-XXXX-XXXX-XXXX-d40c7fac5a8e",
        "KeyAttributes": [],
        "LogicalName": "opportunity",
        "Name": null,
        "RowVersion": null
      }
    },
    {
      "key": "TeamTemplateId",
      "value": "d7c67ce4-XXXX-XXXX-XXXX-000d3a2109c9"
    },
    {
      "key": "SystemUserId",
      "value": "b5a6d14b-XXXX-XXXX-XXXX-000d3a210496"
    }
  ],
  "IsExecutingOffline": false,
  "IsInTransaction": true,
  "IsOfflinePlayback": false,
  "IsolationMode": 1,
  "MessageName": "AddUserToRecordTeam",
  "Mode": 0,
  "OperationCreatedOn": "/Date(1589897514394)/",
  "OperationId": "bf9e6242-XXXX-XXXX-XXXX-e052a4653443",
  "OrganizationId": "8f82a087-XXXX-XXXX-XXXX-dad71fee1361",
  "OrganizationName": "org6b6c11a7",
  "OutputParameters": [
    {
      "key": "AccessTeamId",
      "value": "db4e02ac-XXXX-XXXX-XXXX-000d3a2109c9"
    }
  ],
  "OwningExtension": {
    "Id": "813ac1d5-XXXX-XXXX-XXXX-000d3a2109c9",
    "KeyAttributes": [],
    "LogicalName": "sdkmessageprocessingstep",
    "Name": "Access Team: AddUserToRecordTeam of teamtemplate",
    "RowVersion": null
  },
  "ParentContext": null,
  "PostEntityImages": [],
  "PreEntityImages": [],
  "PrimaryEntityId": "00000000-0000-0000-0000-000000000000",
  "PrimaryEntityName": "teamtemplate",
  "RequestId": "bf9e6242-XXXX-XXXX-XXXX-e052a4653443",
  "SecondaryEntityName": "none",
  "SharedVariables": [
    {
      "key": "IsAutoTransact",
      "value": true
    },
    {
      "key": "ChangedEntityTypes",
      "value": [
        {
          "__type": "KeyValuePairOfstringstring:#System.Collections.Generic",
          "key": "team",
          "value": "Update"
        },
        {
          "__type": "KeyValuePairOfstringstring:#System.Collections.Generic",
          "key": "principalobjectaccess",
          "value": "Update"
        },
        {
          "__type": "KeyValuePairOfstringstring:#System.Collections.Generic",
          "key": "teammembership",
          "value": "Update"
        },
        {
          "__type": "KeyValuePairOfstringstring:#System.Collections.Generic",
          "key": "systemuserprincipals",
          "value": "Create"
        }
      ]
    },
    {
      "key": "POADistributionChanged",
      "value": 10117
    }
  ],
  "Stage": 40,
  "UserAzureActiveDirectoryObjectId": "00000000-0000-0000-0000-000000000000",
  "UserId": "9b781be7-XXXX-XXXX-XXXX-1d830dae011f"
}

And from that JSON schema, I generated the following Parse schema :

{
    "type": "object",
    "properties": {
        "BusinessUnitId": {
            "type": "string"
        },
        "CorrelationId": {
            "type": "string"
        },
        "Depth": {
            "type": "integer"
        },
        "InitiatingUserAzureActiveDirectoryObjectId": {
            "type": "string"
        },
        "InitiatingUserId": {
            "type": "string"
        },
        "InputParameters": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "key": {
                        "type": "string"
                    },
                    "value": {
                        "type": "object",
                        "properties": {
                            "__type": {
                                "type": "string"
                            },
                            "Id": {
                                "type": "string"
                            },
                            "KeyAttributes": {
                                "type": "array"
                            },
                            "LogicalName": {
                                "type": "string"
                            },
                            "Name": {},
                            "RowVersion": {}
                        }
                    }
                },
                "required": [
                    "key",
                    "value"
                ]
            }
        },
        "IsExecutingOffline": {
            "type": "boolean"
        },
        "IsInTransaction": {
            "type": "boolean"
        },
        "IsOfflinePlayback": {
            "type": "boolean"
        },
        "IsolationMode": {
            "type": "integer"
        },
        "MessageName": {
            "type": "string"
        },
        "Mode": {
            "type": "integer"
        },
        "OperationCreatedOn": {
            "type": "string"
        },
        "OperationId": {
            "type": "string"
        },
        "OrganizationId": {
            "type": "string"
        },
        "OrganizationName": {
            "type": "string"
        },
        "OutputParameters": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "key": {
                        "type": "string"
                    },
                    "value": {
                        "type": "string"
                    }
                },
                "required": [
                    "key",
                    "value"
                ]
            }
        },
        "OwningExtension": {
            "type": "object",
            "properties": {
                "Id": {
                    "type": "string"
                },
                "KeyAttributes": {
                    "type": "array"
                },
                "LogicalName": {
                    "type": "string"
                },
                "Name": {
                    "type": "string"
                },
                "RowVersion": {}
            }
        },
        "ParentContext": {},
        "PostEntityImages": {
            "type": "array"
        },
        "PreEntityImages": {
            "type": "array"
        },
        "PrimaryEntityId": {
            "type": "string"
        },
        "PrimaryEntityName": {
            "type": "string"
        },
        "RequestId": {
            "type": "string"
        },
        "SecondaryEntityName": {
            "type": "string"
        },
        "SharedVariables": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "key": {
                        "type": "string"
                    },
                    "value": {
                        "type": "boolean"
                    }
                },
                "required": [
                    "key",
                    "value"
                ]
            }
        },
        "Stage": {
            "type": "integer"
        },
        "UserAzureActiveDirectoryObjectId": {
            "type": "string"
        },
        "UserId": {
            "type": "string"
        }
    }
}

This will not work 100% of the time like it is, because based on the data you got when you generated the schema, the value properties of the InputParameters can vary.
And of course, you can clean the properties you will never use to keep only the necessary !

The trick here is just to remove the types of those ones in order to tell the parser that they are not all mandatory and it should accept what he receives. No ideal in other cases but here we know what we receive anyway.

From that standpoint, we do have access to all properties of our PluginContext from the flow. Awesome !

Second step:

Making sure that the flow is triggered for Opportunity entity :

If LogicalName eq 'opportunity' then we continue else we terminate the flow.

This step is not mandatory if you wish to create a webhook per entity for example and save Flow execution !

Third step:

Based on the properties of the InputParameters, grab what you need.

You can see that here the idea is to loop on the InputParameters properties and use a simple switch to process the one you want.
Again in my case, the Added User Id & the Record Id placed in a variable to be used later on.

These are my 2 cents about the :
Triggering a flow when user is added to access team in order to send him an email

Enjoy,
Cheers

Hello everyone,

Today's PCF control will be about the Composite Fields !
As you may saw, with the Unified Interface layout, the composite fields more or less disappeared. By this, I mean that if you add a composite field such as FullName or Address on your form, this will be replaced by all fields which are in the composite field itself.

Example:

For some user interface experience, it was really nice to have those composite fields available, that's why I've tried to develop one which is flexible !

Demo

Where can I get that awesome control ?

Jump to my github repo for the source code or just use the below button to access the managed or unmanaged solutions :

List of capabilities :

• You have the choice to return the composite value to the control field holder or not.
• You can map up to 8 fields to compose whatever data you want. No limitation in terms of combination. Available fields to be mapped are text, email and phone ones.

• You can define your own separator which will be displayed between each values of the composite field

  A tiny special case has to be handled for the "space" as separator, a simple " " as parameter is not working so you will have to enter "%20" as separator in the configuration panel.

• Locking the control field holder will set all fields as "Read Only" mode from the composite control

• Setting a mapped field as "Read Only" mode on your form will set independently as "Read Only" mode the field on the composite control while the others will be still available and editable.

• The control will get the latest value of any mapped field (even if it's updated outside of the control itself).

Limitation

If you set fields to Read Only mode using Business Rules or JavaScript, it won't reflect into the PCF control.
The control can't be attached to an existing Composite field (ie : fullname, address_composite,...)
To use address fields in the control as parameter, please check the following blog post

Wrap-up

By sharing this control, I hope it can help the user experience on the UCI. This can clearly save space on your form without loosing interesting data.

Enjoy this one !
Cheers,

Hello everyone,

Today, I'm really pleased to announce my latest PCF control.
You know the Quick View Form which are used to display data from a related lookup, but unfortunately, you can't handle the rendering and it's only a read-only rendering.

Those limitations are now OVER !

What is the Quick Edit Form ?

The Quick Edit Form PCF control will allow you to reuse a Quick View Form definition to display the related form and allow you or your user to edit this related record directly within the parent one.

Where can I get that awesome control ?

Jump to my github repo for the source code or just use the below button to access the managed or unmanaged solutions :

List of capabilities :

• Save Data from your Lookup
• Handling 12 languages so far
• Display dedicated message while the mapped Lookup field is empty
• Display the form even if the record is in read only mode
• Advised Users, when enabling the option "UseTextFieldAsLookup" and displaying the binded field, you can reload the record on the fly

Save Data from your Lookup

Of course, this is the most important capability of the PCF control.
Giving you the ability to modify the values from the mapped lookup record.

Handling languages

So far, we are dealing with two languages in the PCF for the "static" display such as : Refresh, Save, the messages, ...
It's open to any languages you want, I would just need some help for the translation in the others :)

Available translations so far :

Empty Lookup message

When the lookup field which is mapped to the PCF control is empty, we display a message explaining why nothing is rendered. That way, the user is aware that it's not an issue with the control but a missing data on the record.

Record in Read Only mode

It can happen that the record mapped with the PCF can be deactivated or in any other state than "active". In this case, the control is still able to render the data but in a read only mode. This will allow the users to at least see the related data.

Reload dynamically the record with GUID record

The primary use of the control is to render the data from a related lookup field on the record. But for easier rendering or even data check as example, it's also possible to load dynamically records based on their GUIDs.
By enabling a property in the PCF control configuration, you can use the text field which the PCF control is attached to and just copy/paste the guid of the record you want to display in it.
Of course all the capabilities explained above are still working.

Fields supported :

• Text field
• Money field
• Textarea field
• Lookup field
• Boolean field
• Date/datetime field
• Optionset field
• Multiselect-optionset field
• Customer field
• Regarding field
• Owner Field
• StatusCode / StateCode Field

Configuration and parameters

• FieldToAttachControl : Field to attach the control (required)
• QuickVIewFormId : Guid of the Quick View Form you want to use to display the fields (required)
• LookupFieldMapped : This is the technical name of the lookup field used as reference - ex : _primarycontactid_value (for a contact from an account) (required)
• UseTextFieldAsLookup : Give the ability to the control to dynamically load data based on the GUID put in the mapped field, skipping the value from the lookup except if the field value is empty (required)

Limitation

You have to know one thing using this control. There will be no "extra logic" applied to the fields displayed.
By Extra logics, I mean Javascripts, Business Rules (form level).

Wrap-up

I really hope that control can be useful for anyone. I know that it can be frustrating to see related data on a form and not having the possibility to edit it in an other way than opening the record.
It was a great challenge for me as well to develop that PCF as I'm quite new with the Power Apps component Framework and it allowed me to discover the real use of Fluent UI controls (UI Fabric) and the react technology to interact with those, which is amazing!

A next blog post will come later on with the technical details of that control.

Enjoy this one !
Cheers,

Supporting & maintaining Azure Service Bus routing rules could be tricky to design without regressions and unexpected behaviors.

MockServiceBus with help of TSQL.Parser provides solution to unit test your subscriptions routing.

Install-Package MockServiceBus

Basic example

A brokered message with custom property flag=1 to be correctly transfered for subscription1 and ignored for subscription2.

NameSpace.AssertRouting(String topicname, Message message, Dictionary expectedResults)

will return green test result

• changing the flag value without changing expected outcome

            var message = new Message
            {
                CustomProperties = new Dictionary<string, object>
                {
                    { "flag", "2" },
                }
            };

Assert.AreEqual failed. Expected:<Transfered>. Actual:<Ignored>. subscription1

• not declaring expected output for a specific subscription

            servicebus.AssertRouting("topic", message, new Dictionary<string, MessageState> {
                { "subscription1", MessageState.Transfered }
            });

Assert.Fail failed. unexpected subscribers subscription2

Casting numbers

MockServiceBus needs a litle help for number types with prefixing with {Int32} fieldname. space is important

Switching from flag='1' to flag=1

            var subscription1 = new Subscription { Name = "subscription1", Rules = new List<Rule> { new Rule { Filter = "{Int32} flag=1" } } };

            var message = new Message
            {
                CustomProperties = new Dictionary<string, object>
                {
                    { "flag", 1 },
                }
            };

Supported features

Full list not available now, but complex queries are supported

NOT EXISTS([forcedestination]) AND NOT EXISTS([subitem]) AND [fromsystem] != '{system}' AND [reference.crmguid] != 'null' AND {Int32} [contract.active] = 1 AND (NOT EXISTS([startdelta]) OR {Int32} [startdelta] >= 0) AND ([fromsystem] != 'sap'

Next ?

• whole structure of topics and subscriptions (+ rules) can be loaded from json file
• re-using same structure files & unit test for automatically updating subscriptions rules in Azure Service Bus

Hello everyone,

As you may know, Microsoft is currently deploying a new type of field on your favorite CDS environments : the Files !

Currently, you have the possibility to create the fields and use them on Flow or Canvas App, there is no current possibility to use them on a model driven app form. That's where this control comes into the light !

There are 2 possibilities to use the control :

• with fields on the same entity (you can upload one file per field) - Left side on the demo
• with fields which are on a sub entity (you can upload as many files as you want !) - Right side on the demo

Demo :

Details

You can find the source code and the details of the control on my GitHub repo
You have the WebApi available calls to manage files.

In quick words, here is the process to upload the files to the File Field :

1. Create the record hosting the file(s) (if it's not done yet)
2. Choose the File from the input button
3. Convert this file into Base64 format
4. To Patch the record with the file, you need : FileName + FileContent into an ArrayBuffer
5. Your data is available !

Configuration sample :

1. For file in the same entity :

In that sample, my entity is carfup_entitywithfile and my file field name is : carfup_primaryfile

1. For files in a sub entity:
   In that sample, my parent entity is carfup_entitywithfile, my sub entity hosting the files is carfup_customattachment and my file field name is : carfup_file

Download

In order to download the package, you can go to the release tab of the repo.
You will find the unmanaged/managed version of the solution and the source code too if you want to improve the control !

I hope you will like it and enjoy the work.
I wish you a great end of the year 2019.

Cheers,
Clément

Hello everyone,

Let's talk about quite complex/surprising subjects around Canvas apps.
The main one will be around offline management in canvas apps, for a client we have a requirement to manage offline capabilities on our latest PowerApps Canvas application. But I will talk about other things which are good to know when you create your projects around that application.

We know that the offline capability exist on canvas apps : offline documentation, so what's the big deal you would say ?

Unfortunately we faced some unexpected issues and found out some interesting tips and tricks to have in mind when you will have to implement such a thing.

Here is the offline scenario we had to build with offline possibilites :

• Usage of the entire app offline with possibility to load/save data from/to the CDS instance on the first and last screen.
• Manage records with local collections
• Link records from various collection between them
• Load all data from an entity (not only the basic fields such as : text, int, date, ...) ie : Lookups

Let's give you some tips & tricks around the Canvas apps and also Offline capabilities

Tips and tricks :

For the following points, let's use this entities structure in the CDS:

1. Load related lookup values in local collection (offline)

Starting from the fact that you have a Car records with N Wheel records linked to a car.

When working on local collections, you have to be aware that a simple :
ClearCollect(WheelCollection, Wheels); won't load all related records (ie : car lookup) by default.

In order to make sure that you have loaded these data when you retrieve everything from the CDS, you have to make sure that at least one screen is using the attribute.
Using the attribute in a query won't be enough.

Quite dirty but efficient solution I used :
Create a dummy screen with label controls using the lookups i'm looking for such as First(WheelCollection).Car.Name. That line will make sure that when you retrieve the Wheel collection, the Car lookup will be loaded by default as well.

Last point here, make sure that the "core" entity and the related entities are connected to the same environment. If you have the entity Car on the CDS (current environment) and the Wheels on the CDS Dev instance, it won't work.

2. Multiple levels of expansion are not supported

It's possible that you face that Notification error while using the application on your mobile or tablet device.

This would simply be caused by a call on a screen control like :
First(BrandCollection).Car.Wheel.Name this will use 2 levels of linked entity which is not allowed when querying data from the WebApi (which is doing the canvas app in the background when querying data).

To spot it

You can simply follow the application scenario from your favorite browser with a develop tool opened. When you will end on the screen with the issue, you can see the network call with the exact webapi call which is falling and in the details you can see the entity and field causing the issue in it.

To fix it

In that case, you have to use the Lookup function to load the first row of data then retrieving the wanted attribute.

IE : Lookup(Cars, Car.Car = First(WheelCollection).Car, Brand).Name
This will return the brand name of a car which is filtered by a wheel property.

3. Creating new records on local Collection (offline)

When using local collections to manage your data (without internet in our case), you will use collections and add/update/remove record actions in it.

I will focus on the add action here.
Here is our process :

As you can see based on the picture above, when creating a record with specified fields, each fields not included on the creation CAN'T be updated later on. You have to be carefull to initialize the record with all data needed in the first place.

In this example, you would make sure that during the creation you specify the name AND the Car lookup even if it's with a blank value.

Solution :

4. Optimize the screens loading

When opening a screen from an other, you have several options.
Indeed, opening a screen with heavy logic or a lot of controls can take a while and this is not user friendly.

To optimize that you have an easy improvement : the screen LoadingSpinner property

• LoadingSpinner.Controls : show a loader while all controls are loading properly
• LoadingSpinner.Data : show a loader while all data are loaded properly

Here is a sample in video :
credit : Nicolas Kirrmann

5. Local collections (with lookups) to CDS (offline)

When exclusively working with local collections (including lookups) in your app you have to deal with an issue :
How will you link the new records without the generated GUID from your data source ?.

In order to link our records : Cars and Wheels, we need to have the Car GUID to link a wheel with a car obviously.

Good point is that when you use the Patch function, you can specify any property added to the object you are creating using the Defaults(entity) function.

Here is a sample to illustrate the above explanation

// Preparing our 2 collections
ClearCollect(CarCollection, Cars);  
ClearCollect(WheelCollection, Wheels);

/* Create a new Car record in the collection locally (only) 
   forcing the GUID of the record */
Patch(CarCollection, Defaults(Cars), {  
    carfup_carid : GUID(),
    carfup_name : "New Car"
});

/* Create a new Wheel record in the collection locally (only)
   forcing the GUID of the record and using the forced
   car GUID to link them together. */
Patch(WheelCollection, Defaults(Wheels), {  
    carfup_wheelid : GUID(),
    carfup_name : "New Wheel",
    carfup_Car: Last(CarCollection)
});

Result :

So far, we have records on our local collection with links between the Cars and the Wheels.

The next step would be to Patch the datasource with our local collections.

a. Upload the "core" records

By "core" records, I mean the records which are used as parent in your entity architecture (ie : brands or cars here).

For Entities with no lookups you can simply use the following line of code : Patch(Cars, CarCollection); the good thing with that is that it will generate a new record in the CDS with the forced GUID. That way you have the possibility to keep the local GUID which match the CDS GUID.

! Attention ! : this works as seen but according to Microsoft, they do not recommand to force the GUID and use it to push the value to your datasource. At your own risk !

Indeed the fact that you could force the GUID when it's supposed to be the datasource can break the GUID generation logic and the indexes on your datasource.

b. Upload the "related" records

By "related" records, I mean the records which contains lookups with your "core" records.

The above way to create records won't work when you have to specify custom lookups within your patch.
You will get the following as answer from the server :

The following error message tells you that the Patch function tries to update an existing record while you are trying to create one. Since the record doesn't exist in the target source yet, the messsage makes sense.
Also one really important thing you need to make sure before trying to push related records to your CDS, you HAVE TO load your core records in the datasource before even if you have those locally.
Of course when you will push the related records to CDS, it will try to link an existing core records in the CDS with your newly created related record.

In order to create your related records, you will have to avoid the forced GUID and then retrieve it from your datasource to have consistent data in your local app.

Here is our approach on that scenario :

Regarding the steps 1, 2 and 3, follow the instructions detailled above.

We will now focus the point 4 on the scenario, here is a piece of code :

// Get the wheels from the CDS
Collect(WheelCollection, Wheels);

// Add 2 new records to our local collection of wheels (with lookup to a Car)
Patch(WheelCollection, Defaults(Wheels),  
    {
        Wheel : GUID(),
        Name: "New local Wheel",
        Car: Last(CarCollection)
    }
);
Patch(WheelCollection, Defaults(Wheels),  
    {
        Wheel : GUID(),
        Name: "New local Wheel 2",
        Car: Last(CarCollection)
    }
);
// For each wheel in the collection, we push it to the CDS without forced GUID
// We removed the Wheel : GUID() line here.
ForAll(  
    WheelCollection,
    Patch(Wheels, Defaults(Wheels),
        {
            Name: WheelCollection[@Name],
            Car: WheelCollection[@Car]
        }
    )
);

// We refresh our local collection with the new values from the CDS
ClearCollect(WheelCollection, Wheels);  

To clear what we've just done with the code above :

1. We get the values from our CDS instance for the wheels entity into a local collection
2. We add 2 records on our local collection with forced GUID which could be use to link records or query it.
3. For each record with forced GUID in our collection, we Patch it to our CDS instance without the GUID (as we want the CDS to generate it).
4. We retrieve the values from CDS in our local collection so we have the latest data in our collection.

And tada, you're now able to manage local collections with local records and push them to your datasource without bad surprises.

I hope all these will help you create the best apps for your customer.

Happy Power Platform'in,
Clément

Thanks to Michel for his help on that topic !

We use several pure json file git repositories in devops for storing & tracking configuration.
Some of these files are directly used by underlying systems (not critical mission tools, but still painful when failing) by web services querying git json files through devops API

Beside taking care of what we commit, error is human, without an automatic check, you can't ensure that there was no typo or incorrect schema used for pushed json. Even worse, you realize later bringing un-necessary stress & confusion.

Addressing this point shouldn't be un-doable, plenty solutions for validating json & jsonschema exists, and pre-commit hook are supported by git, sounds good, as described in this good article.

Unfortunately, I try to bring json file edition to poweruser (and not IT people) and this solution seems overkill and server side hook in devops aren't supported.

stackoverflow suggests using branch policy and external validation service, but again overkill for my needs.

OK ! let's do it in devops build pipeline. Ok, what should we used for being as simple as possible to setup & maintains and where I had some experience.

• nodejs/javascript ajv package, but will require extra work to create & build a project
• C# NjsonSchema for C# ecosystem, but same situation as nodejs one

Seeing the amount of extra work & possible future maintenance, I tried another approach on something already supported by devops pipeline : typed json schema powershell in a search engine. And it was a pretty good idea.

Test-Json cmdlet introduced in powershel core 6.1 allows schema validation. As Microsoft devops supports inline powershell, seems the best no brainer approach .

My pre-requisites

• All json files are in the same folder
• Schema file (one for all) is located in the same folder
• Validation should scan all json files per default & support exclusion
• All errors should be printed out and not stopped on first one

In a devops build task, add a powershell task and ensure to select Use PowerShell Core. If you are managing yourself, your build agent, you might have to install powershell core binaries for supporting Test-Json cmdlet.

Below script supports 2 environment variables

• schema : filename of json schema file
• exclude_json (comma separated array) : json file excluded from validation

output if validation fails

pure json parsing error
schema error

msteams notification

using msteams devops connector on a channel, close to real time, you could notify of a build failure