How to use Power Apps Cards for Dataverse notifications with Power Automate and Microsoft Teams

In 2021, I had the honour of being a speaker for the Zero to Hero learning program that’s run by Victor Dantas. I presented two sessions and in one of the sessions I covered Adaptive Cards. The use case was to create a notification using Power Automate cloud flows whenever a new insurance claim was created in Dataverse. The Adaptive Card would be posted to a Microsoft Teams channel with details of the insurance claim. It also included hyperlinks to view the insurance claim and the member’s insurance policy in the model-driven app.

Fast forward to today, there’s now Power Apps Cards in preview. Power Apps Cards is the next step up from Adaptive Cards and you can use them with Power Automate cloud flows. In this WTF episode I’ll share how to open model-driven app forms and views from Power Apps Cards. 

If you want to learn more about Power Apps Cards, I recommend watching a couple of videos. 

1. The Microsoft 365 & Power Platform community call in November of 2022 with Matt MacLaurin 
2. The Power CAT Live episode in April of 2023 with Matt MacLaurin and Anthony Uitz

Use Case

I’m going to use the same use case in the last WTF episode. Whenever a new Challenge is created in Dataverse, post a Card into a Microsoft Teams channel with two hyperlinks to open the model-driven app form and view.

What I'll cover

1. Create a Power Apps Card
2. How to reference environment variables using PowerFx in Cards
3. Using the Card in Power Automate cloud flow

Create a new Power Apps Card

The starting point is similar to when you build a Canvas App, Cards can be created from make.powerapps.com.

Now initially, you may think that you can create a card inside a solution by clicking on +New, select More, select Other and then select Card.

However when you do this, you end up with the below, which isn’t correct. 

Keep in mind that this is the current experience when filming this WTF episode, it could change in the future.

What you need to do is click on More in the left-hand side menu pane, and you’ll see Cards. You can then pin it and it will display permanently in the menu.

When you select Cards form the menu, you will first see your cards, and the next tab will display both yours and your team’s cards.

Click on New Card or Create a Card, followed by entering a Name and Description for your Card.

After you click on create, the Power Apps Card designer will appear. It will look familiar because it’s similar to the Power Apps studio user interface. You have,

1. The tree view to see your screens and elements.
2. There’s the drag and drop UI elements, such as adding inputs and changing the layout. There are some UI elements that aren’t available compared to the ones available in Power Apps studio so keep that in mind.
3. You also have the same ability of adding data sources.
4. There’s variables, which I’ll cover shortly.

1. Add data source

The first thing to do is add your data source. As of when this WTF episode was filmed, Dataverse is the only connection available, but the product team will be enabling other connections in future updates.

Since we’re applying the same technique from the last WTF episode of using environment variables to build URLs for model-driven apps, we'll need to reference the relevant tables using the Dataverse connector. Add the following Dataverse tables,

1. Environment Variable Definition - This is the table that contains the Environment Variables that have been created in a solution.
2. Environment Variables Value - This is the table that contains the current value of an Environment Variable.

2. Create variables

The second thing to do is create variables for the cloud flow. These variables will become input values in the Power Apps Cards action in the cloud flow.

Several variables are required to be created. First, there's variables that will be used on the interface of the card, I’ll refer to these as visible variables. Secondly, the other variable will be one that won’t be used in the interface of the card, but in the background. I’ll refer to this as an invisible variable.

For the visible variables, they will be the values from the table columns of the newly created Challenge in Dataverse. I’ll display the following from Dataverse,

1. Name of the Challenge
2. Description of the Challenge 
3. Owner of the Challenge

I’ll create a variable for the Name of the challenge by selecting Variables in the menu and click on + New variable.

This is the variable for the Name of the challenge,

I'll explain what some of the fields are.

Type

For the Type dropdown field I’ll keep it as Text.

Default Value

The Default Value field implies what you want the value to be when the Power Apps Card is created. It’s optional and for my use case, I want to leave it blank since it will be populated by the cloud flow.

Value settings - Persistence

Next, there’s two options on whether the value of the variable is either reset each time the card is opened or is left as-is. For my use case I will be using the Permanent option.

Value settings - Customization

Now the next couple of checkboxes were confusing initially. I reached out to Matt Maclaurin and Anthony Uitz in the Power Apps product team. 

For the When sending this card, this value can be cutsomized checkbox, this will turn the variable into an input for the card. 

For the Customization is required checkbox, the value of the variable is required, in other words mandatory, to be set by the cloud flow, power virtual agent bot or from the Cards play page. The play page is when you are copying and pasting the link to send through a Microsoft Teams message. Since the variables will be populated through the cloud flow, I’ll tick these two checkboxes.

Additional variable information

When you expand the additional variable information, Title and Description appears. These will be visible in cloud flows and in bots for Power Virtual Agents.

Repeat the above to create the rest of the visible variables, Description and Owner, and for the invisible variable, the GUID of the challenge.

3. Add controls to the Card

After the data source has been added and the variables have been created, it's time to create the Card.

By default, there will be a couple of controls already added to the screen of the card.

For the first control,

1. I updated the name of the Text Label where I've followed Matt Devaney's Power Apps coding standards for canvas apps when naming controls. Highly recommend you check out this free resource when building your apps or cards.
2. I also updated the text to be the title of the card. For a bit of fun, I inserted the lightbulb 💡 emoji.
3. I then updated the style by making the text larger.

I'll next update the second control,

1. I updated the name of the text label
2. I updated the text as the Name of the Challenge
3. I also updated the style by making it bolder

Next, I added a few more controls. 

1. Under the Name text label, I added another text label with a name of txt_varChallengeName
2. For the text property, this is set to the varChallengeName variable. This will be populated through the cloud flow. 
• 
  
  
  
  
3. The spacing of the text label was updated to none.

This will be the structure I apply to mimic key-value pairs like in Adaptive Cards where I have one text label acting as the key, and the other acting as the value.

I’ll repeat the steps for the two other visible variables of Description and Owner. I’ll have a text label that acts as the key, and another text label that will be the value which will reference the input variables created earlier in this episode.

The last two controls are the buttons that a user can click/tap on to open the challenge form in the model-driven app, or view all Active Challenges in the model-driven app. This will be the same functionality as you saw in my previous WTF episode where a user will click on the hyperlink, and it will open either the form or the view in the model-driven app. 

Add the button control and name the button, followed by entering a title for the button.

As a reminder the following are the query parameters when opening a form in model-driven apps. 

1. You need the Dataverse or Dynamics 365 environment URL. 
2. The appid or appname query parameter.
3. The value of the appid or appname query parameter.
4. The pagetype query parameter where the parameter value is entityrecord.
5. The etn query parameter which is the logical name of the table.
6. And the ID of the challenge.

For opening a system view in model-driven apps, it’s the same except the pagetype query parameter is entitylist, the viewid is the id of the view, and the viewType is 1039 which is the definition for system views.

I covered the above previously in my last WTF episode.

The URL is going to be built within the property of the button using PowerFx. The formula will be very similar to what I showed in the last episode where I shared how to build deep links to open model-driven apps in Power Apps mobile. Environment Variables will be referenced again using PowerFx. I’ll be using the same environment variables in a solution that you saw from the last WTF episode.

If you’re familiar with canvas apps, the launch function can be used to direct a user to a browser and load the URL which I showed you in the last episode. However, in Power Apps Cards, if you try entering the Launch function in the On Select property of the button control, you’ll come across this error message because it’s currently not supported in Power Apps cards. 

There’s a list of PowerFx functions that are supported in the Microsoft Learn documentation.

So, what can we use since the launch function is not currently supported? Well, we can switch the Type over to Open Url, and then use PowerFx to build the URLs.  

Shout out again to Anthony Uitz for answering my question when I was scratching my head over why I couldn’t use the launch function and he guided me towards this. One thing to be aware of is that the URL string must start with https, colon, and forward slashes (https://) otherwise it won’t work.

To build the URLs, I’ll be concatenating strings again as seen from the last two episodes. I’ll use string interpolation rather than the concatenate function or the ampersand operation. I’ll refer you again to Matt Devaney’s blog post, where he explains how to use the string interpolation method in detail. 

The following is the PowerFx expression for the View Challenge button.

$"{LookUp(
    'Environment Variable Values',
    'Environment Variable Definition'.'Schema Name' = "ben_DataverseEnvironmentURL",
    Value
)}/main.aspx?appname={LookUp(
    'Environment Variable Values',
    'Environment Variable Definition'.'Schema Name' = "ben_InnovationChallengeapp",
    Value
)}&pagetype=entityrecord&etn={LookUp(
    'Environment Variable Values',
    'Environment Variable Definition'.'Schema Name' = "ben_Challengestable",
    Value
)}&id={varChallengeGUID}"

Tip: Currently the PowerFx bar in Power Apps Cards doesn't have formatting or the ability to drag the bar to expand it, like in Power Apps studio. What I like to do is build my expression in Power Apps studio, format it, and then copy it over.

Note: You'll also see yellow squiggly lines which is a delegation warning that you can safely ignore. Delegation in PowerFx cards doesn’t have the same support as delegation in canvas apps but because the expression is only performing a string comparison on a single field, it’s fine. 

The following is the PowerFx expression for the View Active Challenges button.

$"{LookUp(
    'Environment Variable Values',
    'Environment Variable Definition'.'Schema Name' = "ben_DataverseEnvironmentURL",
    Value
)}/main.aspx?appname={LookUp(
    'Environment Variable Values',
    'Environment Variable Definition'.'Schema Name' = "ben_InnovationChallengeapp",
    Value
)}&pagetype=entitylist&etn={LookUp(
    'Environment Variable Values',
    'Environment Variable Definition'.'Schema Name' = "ben_Challengestable",
    Value
)}&viewid={LookUp(
    'Environment Variable Values',
    'Environment Variable Definition'.'Schema Name' = "ben_ActiveChallengessystemview",
    Value
)}&viewType=1039"

4. Play Power Apps Card

Now, the cool thing about Power Apps Cards is that you can preview your card in real-time with the data which you can’t do in Adaptive Cards. This is through the Play button. A new browser tab will open, and you’ll first be prompted to enter the values for the required input variables. You can copy and paste the values from a row/record in your model-driven app.

The Card will then load, and you can see the data.

This Send button will generate a link that you can copy and paste into a Microsoft Teams message. Since this card will be populated by a Power Automate cloud flow, we won’t be using this feature. Let’s next learn how to pass values from cloud flow to the input variables in the card.

Building the cloud flow

In my cloud flow I have my trigger which is when a new Challenge is created in Dataverse, followed by an action that will retrieve the user details of the Owner associated to the Challenge.

To call the Power Apps Card, add a new step and search for Cards for Power Apps and select the connector. You’ll see two actions and the one to select is Create card instance. In the dropdown field, select the card that you want to create.

You’ll then see the input variables as input values for the action. This is the title and the description of the input variables from the Card.  

• I’ll use dynamic content from the trigger to as the input values for the Challenge Name, Description, and Challenge ID. 
• For the Owner, I’ll use dynamic content from the previous action to reference the full name from the User table.

Next, add a new step and search for the action, Post card in a chat or channel. In the Post as dropdown field, select Power Apps. Then select where you want to post the card to. I’m posting to a Channel, and I’ll select the Team and the channel. Lastly, select the Card input value as dynamic content. And that’s it, save the cloud flow and it’s ready to be triggered.

Card in action

I create a new Challenge in Dataverse in the Innovation Challenges model-driven app, this will trigger the cloud flow. The cloud flow will then create a Power Apps Card and using the dynamic content from the trigger and previous action, it will populate the input variables of the card. The Power Apps Card will then be posted to a channel in Microsoft Teams.

Summary

Power Apps Cards allows you to create reusable cards that can be saved in the Power Apps maker portal which makes it easier to maintain compared to Adaptive Cards. You can also create variables in cards, and use them as visible or invisible variables which can be populated by a cloud flow or a bot in Power Virtual Agents.

Power Apps Cards is one method that you can use to create Dataverse notifications for users by making use of

• variables to display data from Dataverse through a cloud flow
• embed hyperlinks in the buttons using PowerFx that reference Environment variables in a solution

All of this is achieved without code with Power Platform 😊

Hope you learnt something new and thanks for stopping by 👋🏻

Read More

Open model-driven app forms and views from canvas apps in Power Apps mobile

In the last WTF episode I shared how to build URLs to open forms and views in model-driven apps using environment variables.

Now I did say that I would next cover Power Apps Cards towards the end of the WTF episode but I came across a bug 😓 which I reported and the fix is going to be rolled out (maybe by the time this blog post is published). I had to pivot and brought this episode forward.

This time round, I’ll share how to open model-driven app forms and views from a canvas app in a model-driven app within Power Apps mobile. Switching from canvas apps to model-driven apps in Power Apps mobile is so simple. This is achieved by using deep links inside buttons in canvas apps using Environment Variables. There can be use cases where you want to direct users from a canvas app, to the data in a model-driven app form or view.

The technique is similar to what I shared in the last WTF episode except this time, the Environment Variables are being referenced in PowerFx, rather than cloud flow expressions.

Breaking down deep links for model-driven app forms or views in Power Apps mobile

As per the Microsoft Learn documentation, the following is what the deep link should start with.

ms-apps://<org-url>_<app-id>?tenantId=<tenant-id>&isShortcut=true&appType=AppModule&openApp=true&restartApp=true&forceOfflineDataSync=true

The base query parameters are similar to what I shared in the last episode with minor differences. All of these base query parameters can be created as Environment Variables in a solution.

1. The first query parameter is targeted-app.

To load any model-driven app, the query parameter value is ms-apps as outlined in the Microsoft Learn documentation. Create an environment variable with ms-apps as the current value.

2. The second query parameter is org-url. 

This is the Dataverse environment URL without the https, colon and forward slashes (://)

Create an environment variable with the Dataverse environment URL as the current value.

3. The third query parameter is the appid.

In a solution create an environment variable for the app-id query parameter value.

You can find the appids of your model-driven apps by using the GET request I showed you in the previous WTF episode and copy the appmoduleid value and paste it into the environment variable.

The fourth query parameter is the tenant id of the environment where your model-driven app lives in.

In a solution create an environment variable for the tenant id. The tenant id can be found by navigating to make.powerapps.com, click on settings on the top right and select session details. Copy the tenant id and paste the copied tenant id into the environment variable.

Putting it all together with the form or view query parameters - it’s the same as what I covered in the last WTF episode. For a form it’s the following where the pagetype is entityrecord and the query parameters of the Challenges table logical name and ID of the challenge are included.

For a view it’s the following where the pagetype is entitylist and the query parameters of the Challenges table logical name, view id and viewtype are included.

Building deep links in Power Apps studio

Next, let’s understand how to build the deep links for the Power Apps mobile app in Power Apps studio. First, make sure you have the Dataverse tables of Environment Variable Definition and Environment Variables Values added as data sources.

To keep it simple for this episode, I’m using two screens and the design is very basic. The first screen is a gallery that displays all active challenges from Dataverse.

The second screen displays some data from the Challenge selected in the gallery. 

There are two buttons in this screen which is the same as the two hyperlink I showed you in the last WTF episode.

• The first button, Edit Challenges, will open the form for the selected Challenge.
• The second button, View Active Challenges, will open the view for the Active Challenges system view in the model-driven app. 

Several expressions and functions used in PowerFx

In the OnSelect property of the button, by default it will be false. I’ll use PowerFx to build the URL to open the form and view in the Power Apps mobile app for the model-driven app. 

There's several expressions and functions I'm going to apply in PowerFx.

String interpolation

What I’m going to do is concatenate the Environment Variables and string values to build the deep link. I’ll use string interpolation that came into support in April 2022 instead of using the concatenate function or ampersand character in PowerFx.

As per the Microsoft Learn documentation, "Prefix the text string with a dollar sign $ and enclose the formula to be embedded with curly braces { }."

This is what will be applied in PowerFx to create the address for the Launch function.

➡️ If you want to learn how to use string interpolation, check out this awesome blog post by Matthew Devaney, another Microsoft MVP in our community who covers it in detail.

Launch function

To open model-driven apps in Power Apps mobile, use the Launch function for the deep link. There’s three parts to the function, 

• address which is mandatory
• parameters and target is optional

I’ve found that parameters is not needed in the function as the query parameters for model-driven app forms and views are part of the address.

I also found that target is also not needed in the function as it’ll open the model-driven app in the Power Apps mobile app without providing a target. So address is the only one I’m using in PowerFx to build the URL.

LookUp function

To reference Environment Variables in PowerFx, the key thing to understand is to

1. Retrieve the Environment Current Value
2. Where the parent record equals the Environment Variable you're after

Underneath the hood in Dataverse, there's two tables in Dataverse.

1. Environment Variable Values - this is where the current value of an Environment Variable lives
2. Environment Variable Definitions - this is the "parent record"

For example, for the first parameter of targeted-app, the Environment Variable current value needs to be retrieved. To achieve this, retrieve the current value from the Environment Variable Value table that is associated to the Environment Variable Definition that equals the target-app parameter.

We can use logic in PowerFx to retrieve the current value where the Environment Variable Definition equals the target app Environment Variable.

You can watch this part of my video where I explain this in detail for your understanding.

What the PowerFx formula looks like

Open model-driven app form

For the OnSelect property of the Edit Challenges button in the canvas app, the following is what the PowerFx formula will look like for opening a model-driven app form in Power Apps mobile.

Launch(
    $"{LookUp(
        'Environment Variable Values',
        'Environment Variable Definition'.'Schema Name' = "ben_targetedappPowerApps",
        Value
    )}://{LookUp(
        'Environment Variable Values',
        'Environment Variable Definition'.'Schema Name' = "ben_DataverseEnvironmentURL",
        Value
    )}_{LookUp(
        'Environment Variable Values',
        'Environment Variable Definition'.'Schema Name' = "ben_appidInnovationChallenge",
        Value
    )}?tenantId={LookUp(
        'Environment Variable Values',
        'Environment Variable Definition'.'Schema Name' = "ben_tenantid",
        Value
    )}&isShortcut=true&appType=AppModule&openApp=true&restartApp=true&forceOfflineDataSync=true&pagetype=entityrecord&etn={LookUp(
        'Environment Variable Values',
        'Environment Variable Definition'.'Schema Name' = "ben_Challengestable",
        Value
    )}&id={gal_Home_Challenges.Selected.Challenge}"
)

The Launch function is first referenced, followed by string interpolation, which starts with the dollar sign character and double quote, followed by the functions and formulas being delineated by curly braces. To complete the string interpolation, use a double quote. Then, to complete the Launch function, use a closing bracket.

This is similar to what I covered in the last WTF episode, and in this episode the Environment Variables are being referenced in PowerFx, rather than cloud flow expressions.

The minor difference in PowerFx when referencing the ID (Dataverse GUID) of the Challenge row is to use an expression that retrieves the ID from the selected Challenge in the gallery (from the first screen in the app).

Open model-driven app view

For the OnSelect property of the View Active Challenges button in the canvas app, the following is what the PowerFx formula will look like for opening a model-driven app system view in Power Apps mobile from a button in canvas apps.

Launch(
    $"{LookUp(
        'Environment Variable Values',
        'Environment Variable Definition'.'Schema Name' = "ben_targetedappPowerApps",
        Value
    )}://{LookUp(
        'Environment Variable Values',
        'Environment Variable Definition'.'Schema Name' = "ben_DataverseEnvironmentURL",
        Value
    )}_{LookUp(
        'Environment Variable Values',
        'Environment Variable Definition'.'Schema Name' = "ben_appidInnovationChallenge",
        Value
    )}?tenantId={LookUp(
        'Environment Variable Values',
        'Environment Variable Definition'.'Schema Name' = "ben_tenantid",
        Value
    )}&isShortcut=true&appType=AppModule&openApp=true&restartApp=true&forceOfflineDataSync=true&pagetype=entitylist&etn={LookUp(
        'Environment Variable Values',
        'Environment Variable Definition'.'Schema Name' = "ben_Challengestable",
        Value
    )}&viewid={LookUp('Environment Variable Values','Environment Variable Definition'.'Schema Name' = "ben_ActiveChallengessystemview", Value)}&viewType=1039"
)

It’s mostly the same with the only difference of changing the pagetype to entitylist and referencing the viewid environment variable along with providing the viewType definition of 1039 for system view. As a reminder, I did cover this in my last WTF episode so check out that episode if you haven’t already done so.

And action!🎬 Open the form or view in model-driven apps from canvas apps in Power Apps mobile

I'll open the canvas app on my mobile phone, and select a Challenge from a gallery.

After the Challenge loads, I'll tap on the Edit Challenges button in canvas apps and it'll open the Challenge in the model-driven app in Power Apps mobile. Awesome sauce!

I'll go back to the canvas app, select a Challenge from the gallery again, and tap on the View Active Challenges button. It'll once again open the Challenge in the model-driven app in Power Apps mobile. Pretty cool 😎

Summary

In canvas apps, you can use Environment Variables in PowerFx to build deep links to open forms or views in model-driven apps within Power Apps mobile. This allows users to switch from canvas apps to model-driven apps with one tap/a single tap 🤳🏻

Hope you learnt something new 😊 and stay tuned for the next episode where I'll cover how to do the same in Power Apps Cards - pending bug being fixed 🤞🏼

Read More

Open forms and views in model-driven apps with Environment Variables and Power Automate

In 2020 I published a WTF episode that shared how to create a dynamic record URL for a model-driven app. This was to replicate the built-in functionality of classic workflows of creating a Record URL. It's typically used in use cases where you require a user to click on a hyperlink to load a row or view in a model-driven app. 

The flaw with the method I shared is that it's using the Dataverse List Rows action to retrieve the appid query parameter value from the table called "Model-driven apps." This meant that the action needed to be included in all cloud flows that required a dynamic record URL for Dataverse or Dynamics 365. Not ideal as each action consumes an API call. Check out Jerry Weinstock's blog post that briefly covers what counts as an API call. Otherwise refer to the Microsoft Learn documenation.

Use Environment Variables instead

Environment Variables is a Power Platform feature that can be referenced in Power Apps and Power Automate cloud flows. They allow you to store and manage multiple values that can be used within your cloud flows as dynamic content inputs.

For reusable URL inputs, this is where Environment Variables are used rather than hard coding your URLs. 

• They enable you to move your configuration data from one environment to another with solutions. 
• If the value is different in another environment, simply change it one place in the Environment Variable.

These are two of many reasons as to why Environment Variables are useful when you need to dynamically create a URL for Dataverse or Dynamics 365 in your cloud flows.

In this WTF episode I share how you can use Environment Variables to build a URL to open forms and views in model-driven apps with the help of Power Automate cloud flows.

Model-driven app URL deconstructed

Let’s breakdown what parameters are used in a model-driven app URL.

For forms

URL for a form when using the appname query parameter. This is used in this WTF episode.

1. The Organisation URI which is the Dataverse or Dynamics 365 environment organization URL.

2. To open a specific model-driven app, use the query parameter of either appid or appname.

URL for a form when using the appid query parameter.

The appid is the ID of the app.

The appname is the Unique Name of the app. This is defined when the model-driven app is created and you can find it in the settings of the app. 

You can use either as the query parameter however please note that when using the appid query parameter, the value will need to be updated in the environment variable with the ID in the target Dataverse or Dynamics 365 environment after deploying the solution with the environment variable. This is because the ID will be unique in each Dataverse environment.

For this reason, I’ll stick with appname as the query parameter and the uniquename value will be used in my URL. The appname remains the same in each Dataverse environment.

3. The value of the appid or appname query parameter. 

The easiest way to retrieve these values is to query the Dataverse web API by using the following GET request.

[Organization URI]/api/data/v9.2/appmodules?$select=name,appmoduleid,uniquename

You can perform this request directly in your browser and the values for the appid and appname parameters will display in the response. Note: based on your signed in user account, you will only see apps you have access to as defined by your security role.

In this WTF episode, I will be using appname as the query parameter.

4. The pagetype query parameter which defines whether to load a form for a row in a table, or a view of a table. For a form, the pagetype query parameter value is entityrecord.

5. The query parameter of etn which is the logical name of the table. 

You can find this by browsing to make.powerapps.com, view the table in your solution, navigate to Tools under Table properties and select copy logical name. The copied value can then be pasted into a current value of an environment variable.

6. The GUID of the row in Dataverse or Dynamics 365. If you’re opening a form, the query parameter of id is required which is the GUID of the row in Dataverse.

7. An optional query parameter is the formid of the form in the scenario where you have more than one form for the table. 

This can be found in the Form configuration settings within the table in a solution.

For this WTF episode, there’s only one main form for the Challenges table so I won’t be providing this parameter value.

For views

If you’re opening a view, the difference is that for number 4, the pagetype query parameter value will be entitylist.

For number 6, there’s the query parameter of viewid which will be the id of the view. 

You can find this by navigating to the view in the model-driven app and copy the viewid value in the URL.

And lastly number 7, the viewType query parameter defines the type of view to open. The parameter value can either be 1039 for a system view or 4230 for a personal view.

Create environment variables in a solution

Now that we know the different components of the model-driven app URL, I'll next share how to create environment variables in a solution.

In a solution, create four new Environment Variables where the data type is text and the values are stored as a Current Value.

1. Organisation URI

The first environment variables is for the Organisation URI. To create an environment variable in your solution, 

• Click New and select more and then select Environment Variable. 
• Enter a Name for the Environment Variable and a description. 
• In the Data Type dropdown field, select Text. 
• Next add a current value which will be the Dataverse or Dynamics 365 environment URL. 
• Then click Save. The environment variable is now created.

2. appname query parameter value

The second environment variable is for the appname parameter value with a current value of the appname for the model-driven app.  In my use case it's the Innovation Challenges model-driven app.

As a reminder, for this WTF I am using the uniquename value of the app which you can find through the GET API request I shared with you earlier in this blog post.

3. etn query parameter value

This is the logical name of the table. In my use case it's the Challenges table.

This will be the copied value from the table properties I shared with you earlier in this blog post.

4. viewid query parameter value

This is the id of the view. In my use case it's the Active Challenges system view.

🗒️Side note: use default or current value? 

Some of you may be wondering, which method to use for storing a value in Environment Variables - Default or Current Value? 🤔

Here's a great discussion thread with Kent Weare and Microsoft MVP Tomasz Poszytek.

In my experience, current value has been used in projects because before Environment Variables came along, us consultants (or implementors - whatever you want to call us 😉) have become accustomed to having variables as "configuration records" with the value (such as GUID of a row) in target environments. The concept of a default value didn't exist beforehand and is different to the deployment pattern we've followed as part of solution deployment.

However there's nothing wrong in using the default value field in the Production/Live environment or using it across several environments AS LONG as the value is the SAME across all environment.

Please also keep in mind that each time you perform an export of a solution with the environment variables from a source environment (such as Development environment), you do need to remove the current value from the solution first. So this would be a pre-deployment task.

Build the URL in a cloud flow to open a form

The use case is when a new challenge is created in Dataverse, post a notification in the app and post message to a channel in Microsoft Teams that allows the user to view the newly created challenge record in the model-driven app or the active challenges system view.

In my cloud flow I have the add a new row Dataverse action for the Notifications table to create the in-app notification and I’m referencing the environment variables in the URLs for the actions. If you want to know how to create in-app notifications, refer to this WTF episode.

The other action is the Post a message to a channel in Microsoft Teams which has two hyperlinks, view challenge and view active challenges. When a user clicks on either of the hyperlinks, it will open the form or the system view based on the URLs. I'll next cover through the steps on how to build the URLs using the environment variables.

In the Microsoft Teams action, select the edit HTML button. This will switch it to the HTML editor.

For the View Challenge hyperlink, I’ll replace the placeholder URL value and build the URL using environment variables, followed by selecting the Dataverse environment URL environment variable.

Then select the Innovation Challenge app environment variable for the appname query parameter. 

Next, enter the pagetype query parameter of entityrecord, followed by the Challenges logical name environment variable for the etn query parameter.

Finally, select Challenge as dynamic content from the trigger for the value of the id parameter. This will be the GUID of the row created.

Build the URL in a cloud flow to open a view

The first two steps are the same building a model-driven app view URL, the differences are

• the pagetype query parameter is entitylist
• the viewid query parameter is required which is the id of the view
• the viewtype query parameter which is the definition of the view - either a system view which is 1039 or a personal view which is 4230

Save the cloud flow and it's ready to be triggered.

Demo

To trigger the cloud flow, I create a new row/record for Challenges in the Innovation Challenge model-driven app.

The in-app notification will appear in the model-driven app, and the hyperlinks when clicked on will direct the user to the Challenge form to view the newly created Challenge, or the Active Challenges system view.

The same experience is encountered when viewing the message posted in the Microsoft Teams channel.

Summary

Environment Variables are incredibly useful for automating processes where you need to build URLs through out your cloud flows to open a specific form or view to enter or update data in your model-driven apps. Create them once, and reference it anywhere in a cloud flow. However you do need to remember the following when using Environment Variables:

1. Add a current value in the target environment after deploying the solution
2. Remove the current values from Environment Variables prior to deploying the solution

Stay tuned for the next WTF episode as I'll share how to build URLs in Power Apps Cards - the next evolutionary step for "adaptive cards" 😎

Read More