Power Community

Power Community

Canvas Apps

Power Fx: Introducing Named Formulas

I am thrilled to introduce you to an old concept. A powerful concept that has been in Excel for a very long time, that we are now bringing to Power Fx. With it, you can simplify your app’s initialization, reduce app load time, reuse logic, and improve the maintainability of your apps. Welcome Named Formulas. A funny name, that derives from how this feature appears in Excel, in the “Name Manager.” In Excel, you can name any cell and refer to that name throughout the workbook. It adds a level of indirection that allows you to move that cell reference by name rather than by location. And inspiring the introduction into Power Fx, it also allows you to bind a name to a formula that isn’t in a cell. Today in Power Fx, you write formulas for the properties of the controls in your app. You can refer to those properties from other formulas to reuse the result of calculation. But you are limited by the controls and their properties. What if you could effectively create your own properties, create your own points of reuse? Advantages of Named Formulas Enough theoretical preamble, what if you could write this in an App.Formulas property: UserEmail = User().Email; UserInfo = LookUp( Users, 'Primary Email' = User().Email ); UserTitle = UserInfo.Title; UserPhone = Switch( UserInfo.'Preferred Phone', 'Preferred Phone (Users)'.'Mobile Phone', UserInfo.'Mobile Phone', UserInfo.'Main Phone' ); These are formulas in the truest sense of the word. They express how to calculate the UserEmail, UserInfo, UserTitle, and UserPhone from other values, much like F = m * a in Physics calculates force. This logic is now encapsulated and can be used throughout the app and can be updated in this one location. It can be changed from using the Dataverse Users table to using the Office 365 connector without needing to change formulas in the rest of the app. These formulas don’t say anything about when these should be calculated or how these should be calculated. They are truly declarative. They provide a recipe only. Ok, you are probably wondering, why use this? Why not just use Set in App.OnStart to accomplish the same thing? You certainly can and we have no intention to ever take that ability away. State variables and Set will always have their place. Named formulas have advantages: The formula’s value is always available.  There is no timing dependency, no App.OnStart that must run first before the value is set, no time in which the formula’s value is incorrect.  Named formulas can refer to each other in any order, so long as they don’t create a circular reference.  They can be calculated in parallel. The formula’s value is always up to date.  The formula can perform a calculation that is dependent on control properties or database records, and as they change, the formula’s value automatically updates.  You don’t need to manually update the value as you do with a variable.   The formula’s definition is immutable.  The definition in App.Formulas is the single source of truth and the value can’t be changed somewhere else in the app.  With variables, it is possible that some code unexpectedly changes a value, but this is not possible with named formulas. That doesn’t mean a formula’s value needs to be static – it can change – but only if dependencies change. The formula’s calculation can be deferred.  Because its value it immutable, it can always be calculated when needed, which means it need not actually be calculated until it is actually needed. If the value is never used, the formula need never be calculated.  Formula values that aren’t used until screen2 of an app is displayed need not be calculated until screen screen2 is visible.  This can dramatically improve app load time.  Named formulas are declarative and provide opportunities like this for the system to optimize how and when they are computed. Named formulas is an Excel concept. Power Fx leverages Excel concepts where possible since so many people know Excel well.  Named formulas are the equivalent of named cells and named formulas in Excel, managed with the Name Manager.  They recalc automatically like a spreadsheet, just like control properties do. Implications for OnStart Last year, we introduced the App.StartScreen property as a declarative alternative to using Navigate in App.OnStart. It has been very successful, today App.StartScreen is used much more than the old pattern. At the time, I explained that there are three main reasons for using OnStart: Indiciating which screen should be first. Setting up global variables. Prefetching and caching data. With the named formulas, we are now addressing the second item on this list. The third item is still being worked on and the subject of a future discussion. People love to use Set in their OnStart. A recent study showed that when App.Onstart is used, 84% of the properties includes a Set. I get it. I personally use it. I championed the addition of Set years ago. Until now, this has been the only way to setup a value to be reused across your app. For example, I’ve written a chess app that heavily uses App.OnStart: Many of the Set calls are to setup simple constants. The Board is represented as a string with metadata at the end, an unpacked form of chess FEN notation. Set( BoardSize, 70); Set( BoardLight, RGBA(240,217,181, 1) ); Set( BoardDark, RGBA(181,136,99, 1) ); Set( BoardSelect, RGBA(34,177,76,1) ); Set( BoardRowWidth, 10 ); // expected 8 plus two guard characters for regular expressions Set( BoardMetadata, 8 * BoardRowWidth + 1 ); // which player is next, have pieces moved for castling rules, etc Set( BoardBlank, "----------------------------------------------------------------_00000000000000" ); Set( BoardClassic, "RNBQKBNR__PPPPPPPP------------------------_--------__pppppppp__rnbqkbnr__0000000000" ); This is easy to translate to named formulas: BoardSize = 70; BoardLight = RGBA(240,217,181, 1); BoardDark = RGBA(181,136,99, 1); BoardSelect = RGBA(34,177,76,1); BoardRowWidth = 10; // expected 8 plus two guard characters for regular expressions BoardMetadata = 8 * BoardRowWidth + 1; // which player is next, have pieces moved for castling rules, etc BoardBlank = "----------------------------------------------------------------_00000000000000"; BoardClassic = "RNBQKBNR__PPPPPPPP------------------------_--------__pppppppp__rnbqkbnr__0000000000"; Note that none of the references to these properties needs to change. You can cut and paste from App.OnStart to App.Formulas, modify the syntax appropriately, and that’s it. Wherever BoardClassic was being used, it can continue to be used as it was before. Also note that the order of these definitions is no longer important, so the definitions of BoardRowWidth and BoardMetadata can now appear in any order. Let’s look at a more advanced case. In App.OnStart I have this imperative logic: If( !IsBlank( Param( "TestPlay" ) ), Set( PlayerId, Lower(Param( "TestPlay" ) )); Set( AdminMode, true ), Set( PlayerId, Lower(Left( User().Email, Find( "@", User().Email )-1 )) ) ); If( !IsBlank( Param( "ReviewGo" ) ), Set( ReviewGo, true ) ); Instead of setting these variables, the formulas for how to calculate them can be specified in App.Formulas. This result is easier to read by decoupling the definitions of PlayerId, AdminMode, and ReviewGo: PlayerId = If( !IsBlank( Param( "TestPlay" ) ), Lower( Param( "TestPlay" ) ), Lower( Left( User().Email, Find( "@", User().Email )-1 ) ) ); AdminMode = !IsBlank( Param( "TestPlay" ) ); ReviewGo = !IsBlank( Param( "ReviewGo" ) ); Finally, no I didn’t implement a chess playing algorithm directly in Power Fx (yet), I instead am using the excellent open-source Stockfish chess engine running on an Azure VM. A custom connector is used to communicate with the VM which also manages the games between the players. In App.OnStart: Set( Players, ChessPHP.Players() ); Set( PlayerName, If( IsBlank( LookUp( Players.players, Lower(player) = Lower(PlayerId) ) ), playerid, LookUp( Players.players, Lower(player) = Lower(playerid) ).name & " (" & playerid & ")" ) ); In App.Formulas: Players = ChessPHP.Players(); PlayerName = If( IsBlank( LookUp( Players.players, Lower(player) = Lower(PlayerId) ) ), PlayerId, LookUp( Players.players, Lower(player) = Lower(PlayerId) ).name & " (" & PlayerId & ")" ); Very similar. But what’s great about this is that, until I actually show PlayerName somewhere, the web service API call for ChessPHP.Players() doesn’t need to happen. The app doesn’t take precious time up front during app load to get this information. Because of the formula, the app knows how to get the needed information when the time is right. I’m still converting my app to fully take advantage of named formulas. Ideally, I will get to a point where I can point to each piece of state and explain why it needs to be mutable and why it can’t be a formula. I expect that to be a handful of items, rather than the hundred or so state variables my app uses today. Named formulas definitely changes how you think about state and code reuse in your app. To reiterate, I’m not anti-state or anti-Set. Mutable state is essential and differentiates Power Fx from Excel. Set is here to stay. But I do believe it should be used more sparingly than it is today. When the Set hammer was our only tool, everything looked like a nail. We now have a new tool to explore and only real world experience will inform us on the best ways to use them both. Experimental for feedback And now it is your turn. Named formulas are an experimental feature in version 3.22091. The App.Formulas property will only appear if the Named formulas experimental feature is enabled in Settings > Upcoming features > Experimental. As an experimental feature, do not use named formulas in production apps. How will you use this new feature? What could be improved before it is enabled by default? As always, your feedback is very valuable to us. Please let us know what you think in the Power Apps experimental features community forum. What’s next If you follow Excel, you will know that they added the Lambda function a few years ago. A colossal step forward for Excel, it enables user defined functions to be written directly in the formula language. And they used the named formulas concept to do it. For example, here are a set of functions that recursively walk a tree of employees and their reports in Excel, using the Advanced Formula Environment add in for authoring: This is essentially named formulas with parameters, which become user defined functions. Or, alternatively, you can think of named formulas as user defined functions that have no parameters. We plan to do something similar. In fact, there is an early prototype version of it running in our Power Fx open source GitHub repo at https://github.com/microsoft/power-fx. They logic looks different because we prefer to have the parameters on the left hand side of the =, we are strongly typed which we have added similar to how TypeScript added types to JavaScript, and we have lambdas built in to many of our functions like Sum. We are experimenting, this all may change. But the structure of how this works is consistent with what Excel is doing: How does this relate to canvas components? Canvas components can provide pure functions today with experimental enhanced component properties feature. We are working to move this out of experimental, after having made canvas components generally available earlier this summer. Canvas components are great and support sharing across apps through a component library. However, they were designed primarily for a different use case, as a user defined control. Functions written in this way must be instanced as an object, appear as methods on that object, need to be placed on a UI canvas, and they are heavy weight to define using builder UI in Studio. Named formulas, and a future user defined functions, are much lighter weight, easier to create, and can be more easily copied from other apps, documentation, or web examples. They can also be leveraged across all Power Fx hosts with no canvas required. We have no firm dates on when this will become available in Power Apps but we know code reuse is very much on your minds, and so it on our minds too.

Power Fx: Introducing ParseJSON

We are pleased to announce the experimental release of our ParseJSON function, which can parse JSON strings into Power Fx objects and types. This new function dramatically simplifies working with JSON in Canvas apps. For example, we recently worked with a customer who needed to extract information from a relatively simple JSON string stored in a Dataverse table: [    {         "PredictionID": "e438ec93-dee2-4a6c-92d1-8c9e87a1b1d3",       "CustomerID": "2c9c3dae-5113-4b6b-9cc5-ad25b955b463", "id": "b8cf0ea6-b6f5-46c3-9fc2-5403fb7fdd2d",       "Score": 0.7848321,         "ProductID": "628065",     "ProductName": "Large Widget" }, {     "PredictionID": "5ac7b6aa-d069-4c2d-b593-bda5bf3e2f56",       "CustomerID": "2c9c3dae-5113-4b6b-9cc5-ad25b955b463"         "id": "b8cf0ea6-b6f5-46c3-9fc2-5403fb7fdd2d",         "Score": 0.82974886, "ProductID": "527174",   "ProductName": "Small Widget"    }, ... Their first solution was to use a Microsoft Power Automate flow to do the parsing which has excellent JSON support. However, the volume and latency of these calls didn’t work for their scenario. So, like many of you, we turned to regular expression matching using this formula: MatchAll( ProductRecommendationsJSON, """Score""s*:s*(?[^,]*)s*,s*" & """ProductID""s*:s*""(?[^""]*)""s*,s*" & """ProductName""s*:s*""(?[^""]*)""", MatchOptions.Multiline ) This works and is what the customer shipped their app with. However, it is hard to write and verify with that complex regular expression syntax and is fragile, for example it will break if the order of the JSON fields is changed or another field inserted. A better answer is a dedicated JSON parser, a highly requested feature on our community ideas forum. With the new ParseJSON function, this can be written as: ForAll( Table( ParseJSON( ProductRecommendationsJSON ) ), { Score: Value( Value.Score ), ProductID: Text( Value.ProductID ), ProductName: Text( Value.ProductName ) } ) This is both easier to read and more robust, tolerating reordered and additional fields. We have plans to further simplify this with better untyped object array support and casting as a whole via a schema rather than field by field. But this will get you started and will continue to be supported with those enhancements. Note that this is an experimental feature. This functionality will change. We are releasing it now for your feedback and for use in proof-of-concept, non-production situations. To use this functionality, you must opt-in to the feature under Settings > Upcoming features > Experimental. Please post your feedback in our experimental features forum. To learn more, keep reading, and check out our Working with JSON documentation. JSON and Power Apps The JSON format has seen widespread adoption in serializing application objects for systems communications and saving of state. Many services today offer RESTful services that communicate via JSON payloads, including services such as SharePoint and Azure DevOps. Power Apps provides a large amount of out of the box connectors, many of which talk to services via JSON and provide Power Fx types as input and output. But there are cases where either a service can provide very dynamic JSON payloads, or the data is provided as text but in practice contains JSON objects. In 2020 we released an experimental feature called Dynamic Schema which addresses specific scenarios such as custom fields on Azure DevOps work items. The standard connector for Azure DevOps can only know about standard Azure DevOps fields, but a “capture schema” feature allows a maker to have Power Apps capture the output of the connector call and adapt the schema based on what the output provides. A maker can subsequently work with the connector in Power Fx as if the fields were always part of the connector’s schema. This is a fairly static “update” to the schema that can be made when authoring the app. Today’s experimental release of ParseJSON addresses the other end of the spectrum, and provides an important base in the Power Fx language and runtime to bridge the areas in between. Untyped Object To handle the most dynamic scenarios with a JSON string, we need to address the fact that Power Fx is a strongly-typed language. The JSON format, in comparison, offers very few data types. Additionally, in a scenario where the JSON payload can change when the Power App is run (as opposed to when it is built) we must have the ability to read the JSON and convert into the types we need from the formulas that need them. To support this most dynamic of scenarios, we have introduced a new type called untyped object. It is, in effect, a wrapper for a value or object that can be converted to a concrete Power Fx type at the time the app runs. When authoring the app, makers can use the untyped object to write formulas that make assumptions about the nature of the actual object or value when a user will use the app. This does mean the maker has some knowledge about the incoming data and its structure, as this metadata is not available during authoring and the untyped object cannot provide any help (such as IntelliSense). Untyped objects can contain values (numbers, text, Boolean, dates, etc.), records and tables. To use any underlying values of untyped objects, they have to be cast explicitly to their respective Power Fx types using the type construction functions such as Boolean (a new function), Text, Value, DateTimeValue, etc. ParseJSON The ParseJSON function will be the first (and for now the only) function to return an untyped object. It accepts a text value that is a valid JSON string. For example, assume a custom connector “myConnector” that provides a GetJSONString() function: ParseJSON( myConnector.GetJSONString() ) Now assume the connector returns the following JSON: {    "TextField" : "Hello, World!",    "Version" : 1.1} We can store the untyped object that ParseJSON returns in a variable called “untypedVariable”, and access the individual fields with the regular dot notation: Set( untypedVariable, ParseJSON( myConnector.GetJSONString() ) )untypedVariable.TextFielduntypedVariable.Version However, the fields on the untypedVariable (TextField, Version) are also untyped objects and have to be explicitly converted to a type that can be used in formulas for Power Apps properties. For example, to use the TextField in the text property of a label control, the Text() function has to be used to convert the untyped object value to a text value: Text( untypedVariable.TextField ) Similarly, a JSON array of values or records can be converted to a table directly with the Table function. That will result in a single-column table of untyped objects, requiring each untyped object value or record field in the table to be converted to a proper type. For example, we can parse the following JSON string into an untyped object variable named “untypedVariable”. [    { "IndexField" : 1, "Title" : "One" },    { "IndexField" : 2, "Title" : "Two" }] We can now convert this JSON array of records into a table with the Table function: Table( untypedVariable ) If you wish to use this table in, for example, a collection and gallery, you have two options. Either use the table as-is, and in the gallery convert any property values to specific Power Fx types. Or, convert the table to a typed table with ForAll prior to assigning to the gallery. To create the collection of untyped objects, you can use the following formula: ClearCollect( collection, Table( untypedVariable ) ) Inside the gallery using this collection, each field will need to be converted into the correct Power Fx type: Text( ThisItem.Title ) To convert the untyped object array directly into a typed Power Fx table, you can use ForAll which can return a table: ClearCollect( collection, ForAll( Table(untypedVariable), { IndexField: Value(Value.IndexField), Title: Text(Value.Title) } ) ) Now the gallery can use the collection with an entirely typed record. For more information and examples, see the Working with JSON article on the docs site. What’s Next The ParseJSON function with untyped objects provides a very generic way to handle dynamic incoming JSON through Power Fx formulas. We are considering next steps to bridge the scenarios in between dynamic schema capture during authoring, and untyped objects in formulas. Imagine declaring your own schema through Power Fx formulas or YAML definitions, and having connectors or ParseJSON automatically convert the incoming payload to the Power Fx typed schema you defined. This would provide a broad spectrum of options from capture schema from a sample payload, to defining schemas that can automatically convert, all the way to code-first handling with untyped objects. While we work out what, how, and when we can introduce this spectrum of features, we plan to move the current ParseJSON and untyped object features to preview and GA quickly as we believe the flexibility it provides will allow makers to address their JSON parsing needs. Additionally, untyped objects provide a basis for other potential features and functions that deal with external data structures, such as CSV, XML, etc. As always, we value your feedback and suggestions on the currently released features and future roadmap. Join the discussion in our experimental features forum.

Announcing public preview of Content Security Policy for Power Apps

We’re excited to announce the public preview of Content Security Policy for Power Apps! Power Apps has had Content Security Policy (CSP) support for model-driven apps since the beginning of the year, which was configured by running script as a System Administrator. With these new capabilities, you can now control the CSP header for model-driven as well as canvas apps in the environment in Power Platform Admin Center. CSP can be configured in both enforced and report-only mode. Configuration in Power Platform Admin Center CSP can be configured using the Content security policy settings under the Privacy + Security section of an environment in Power Platform Admin Center. Turning enforcement on will provide protection against clickjacking attacks for apps in that environment. CSP is configured independently for model-driven and canvas apps, except for reporting which applies to both. Reporting and enforcement are disabled by default, and we recommend you turn on enforcement in your production environments only after testing your apps in a sandbox environment with CSP turned on to ensure any intended functionality isn’t blocked due to this change. We also recommend turning reporting-only mode on in production before enforcement to catch any lingering issues before enforcement is enabled. CSP support for canvas apps Model-driven apps have had the ability to send default and custom CSP for some time. With this update we’ll support CSP for canvas apps as well. The default and customizable pieces of the CSP header are the same for both model-driven and canvas, but they are configured independently, allowing you to perform a gradual CSP rollout. Violation reporting As part of the CSP settings, you can also enable reporting and provide a custom reporting endpoint to receive any content security policy violation reports. This capability helps preview what violations would be blocked before turning it on completely. Refer to the Content Security Policy documentation for details on building reporting endpoint. Please review the documentation for more details and as always, we would love to hear from you on how we could keep improving this feature. Please leave your feedback and comments on this post.

Extend modern commands with custom pages and geospatial mapping

Buttons and command bars control the core behavior for any application. Without them, we can’t print the latest report, start our time-sensitive process, or make our hero storm the castle and save the day in our favorite video game. In Power Apps Model-Driven Apps, they are everywhere, and this blog will show you how to leverage geospatial features with modern commands, custom pages, model-driven apps, and a little bit of JavaScript. Use commanding to display a custom control image Walkthrough In this walkthrough, we will be using custom pages, map control, and app notifications for plotting a contact’s address on a map. Map for an individual record image What if you wanted to plan your trip around town to visit clients to be more effective and review the relative locations of your clients? And what if you were asked to do this by your CEO or VP and needed to let them know it was ready to view and where to find this map in your model-driven app?  You could build them a beautiful app that looks something like this. Send notification to CEO or VIP with link to the map image Setup We need to create a custom page with a map control that will read contact data. What ingredients do we need to build all this? A solution, model-driven app, contacts, canvas app, custom page and JavaScript. Prerequisites As an admin, go to the admin center, turn on geospatial controls and turn on Bing Maps. Detailed steps are here  Add geospatial controls to canvas apps and Manage Bing Maps for your organizations Enable maps Let’s start with creating a solution, model-driven app, and contacts From your Power Apps portal, go-to solutions and create a new solutionCreate a new model-driven appOpen the model-driven appAdd the contacts table to your model-driven appGo to contact and enter new contacts with addresses using the main Contact form. Enter City, State/Province, Country/Region For more information Create a model-driven app using the account page Create canvas app Why do we need a canvas app? You can copy and paste controls that aren’t shown on a custom page from a canvas app. In this case, we want the map control From the solution, add a blank canvas app. See Create a blank canvas app from scratchAdd a data table that uses contacts as the data source. See Data table control in Power AppsAdd the map control. See Use an interactive map control in Power AppsEnable the Show current location property and use the formula bar to set the CurrentLocationLongitude and CurrentLocationLatitude So that when the user selects a row, the map highlights the location with a blue circleWhen you’re happy with formatting the data table and map. Select the controls and on your keyboard, use CTRL+C. See Copy and Paste controls across Canvas Apps available Map advanced current latitude and longitude properties image Create a custom page From your solution open the model-driven app.Click the top + Add page button. See Add a custom page to your model-driven appWhile on the custom page use CTRL+V to add the data table and map to your custom page. See Copy and Paste controls across Canvas Apps availableOpen your map from a button From your solution open the model-driven app and navigate to command designer. When prompted leave the default to the Main grid. See Open the app designerWhen prompted select to use JavaScriptFrom the left pane, add a new dropdown using the +New buttonYou will see a group is added by defaultFrom the left pane select the group and using the same +New button create a command button under the groupCreate a local JS file and add the JS script below to open a centered dialog window.Click + Add library linkClick + new web resourceUpload your file and enter all the fields.Select your new libraryEnter the name of the function in this case openCustomPage. See Use commands with custom pages with cloud flowsEnter the custom page logical name as the first param and the page title as the second param. See Use Javascript for actions and Finding the logical name For more information see Create and edit web resources Example code for openCustomPage sample function function openCustomPage(customPageLogicalName, customPageTitle) { // Opens a centered custom page dialog let pageInput = { pageType: "custom", name: customPageLogicalName, }; let navigationOptions = { target: 2, position: 1, width: { value: 50, unit: "%" }, title: customPageTitle, }; Xrm.Navigation.navigateTo(pageInput, navigationOptions) .then(function () { // Called when the dialog closes }) .catch(function (error) { // Handle error }); } Add send notification button To get this working we are going to need to get the system user id. You can use OData to get the system user id quickly using this snippet. As a test, you can use your own system user id before sending it to someone. See User (SystemUser) table/entity reference Example query /api/data/v9.0/systemusers?$select=fullname&$filter=startswith(fullname,’Alfredo C’) While still on the command designer, select the group againAdd another command using the +New button create command buttonAdd the below JS as a web resource just like you did above and this time the function name is sendNotification.Enter the system user id of the person to see the notification as the first param. Enter the page title as the second param and the custom page URL for the third param.When you are done save and publish your changes Example URL  ?appid=0b02a3a4-16da-ec11-bb3b-000d3a33d9bf&ribbondebug=true&pagetype=custom&name=cr1c6_contactslocations_24f66 Example code for send notification function function sendNotification(systemuserid, customPageTitle, customPageUrl) { var notificationRecord = { "title": "Congratulations", "body": "You can review the location of your contacts", "ownerid@odata.bind": "/systemusers(" + systemuserid + ")", "icontype": 100000001, // success "data": JSON.stringify({ "actions": [{ "title": customPageTitle, "data": { "url": customPageUrl } } ] }) } Xrm.WebApi.createRecord("appnotification", notificationRecord). then( function success(result) { console.log("notification created with single action: " + result.id); }, function (error) { console.log(error.message); // handle error conditions }); } 🥳 Congratulations! Now you have your map and a way to notify your CEO or VP that it’s available. The next time they open the app they will see the notification and can click on the link to review the map.  Note that the JS functions are reusable, and can be applied for different tables such as Accounts, Organizations, etc. You can discover your own scenarios. One example is you are planning a conference with different event locations. Team Credits Huge thanks to the commanding engineering team. Alfredo Cerritos LinkedIn, Anshul Jain LinkedIn, Brad Flood LinkedIn, Casey Burke LinkedIn, Prabhat Pandey LinkedIn, Sanket Patadia LinkedIn, Sergio Escalera Costa LinkedIn, Srinivas Dandu LinkedIn Thanks to Scott Durrow LinkedIn, Adrian Orth LinkedIn for collaboration

Introducing the Creator Kit – Efficiently create performant Fluent UI based Power Apps

We’ve gotten a lot of great feedback since our initial release in May, and today we’re excited to be formally introducing the Creator Kit – ready to be used in production applications! The Creator Kit, published by the Microsoft Power CAT team, is a collection of 24+ Fluent UI controls and templates for Power Apps makers to create delightful app experiences more rapidly. What’s included The Creator Kit is distributed in three managed solutions, each containing unique components: All controls and components included in the kit use the Fluent UI framework to help easily create consistent, beautiful, and effective user experiences for custom business applications. Creator Kit (CreatorKitCore) A solution that contains the core components of the Creator Kit: See the control reference for all updated controls and their status. You will notice some components are marked as preview or experimental. Preview is tagged for controls added recently, and experimental is if an underlying platform capability a component depends on is not generally available (e.g., canvas components are not supported in custom pages). Reference Solutions These solutions provide templates and utilities for building with Creator Kit components in canvas apps vs custom pages (embedded in Model Driven apps). CreatorKitReference (MDA)CreatorKitReference (Canvas)Contains references for developing Model Driven apps with custom pages and the Creator Kit components. A standalone Power Platform license is needed to play these assets.Includes the Reference App (shown in the screenshot below) and a custom page template.Contains references for developing canvas apps with the Creator Kit components. A standalone Power Platform license is not needed to play these assets.Includes a Reference App, a canvas template app, and a Fluent Theme Designer app. Creator Kit Reference App (click image for animation) Each reference solution contains a reference application that lets you interact with each component and see the underlying formulas that render it. It’s a great way to quickly learn how the components behave and are implemented. Real world scenarios Custom Outlook Panel The kit components were used created a flyout experience in the Outlook web app using the Panel, Elevation, and Icon controls. Posted by Mats Necker. CoE Starter Kit Environment Management refresh The Environment Creation Request experience to view a request in detail, migrated into a custom page. part of the CoE Starter Kit. Get Started Start using the Creator Kit by reading the setup instructions. Support Report bugs in our GitHub repository issues. Our team will triage issues with the Creator Kit components. See our support documentation for more guidance. Feedback We host our backlog in the GitHub repository to make our roadmap publicly available. We largely depend on community feedback to prioritize feature development and continued investment in the kit. Upvote (👍) backlog items you would like to see in the kit next to help our team determine the demand for each component. Work that is committed will be associated with a specific release. You can also submit a feature request if the backlog does not have the Fluent UI components or capabilities you need. Everyone benefits from the Creator Kit The kit provides many improvements that affect Power Platform makers, users, and admins: Makers can focus efforts on building the problem-solving features of an application. The cohesive Fluent UI design makes it easier to make custom pages look more consistent and like model driven apps. You don’t need to be a front-end prodigy – or have budget for a design team – the kit will help you make stunning apps with the latest and most contemporary designs. Users will interact with the cohesive set of components that are intuitive and familiar (same controls used in all modern Microsoft applications). The components provide a performance boost which also provides a better user experience, which can help users be more productive while using your apps.Administrators who must govern UI consistency within an organization benefit from the modern theming architecture that Fluent UI provides inherently in the kit’s components. The components are developed and supported by dedicated engineering teams at Microsoft, so companies can deploy apps with Creator Kit components into production with confidence. Additional Resources

What’s new: Power Apps August 2022 Feature Update

Clay Wesener, Principal GPM, Power Apps Studio, Wednesday, August 31, 2022 Welcome to the Power Apps monthly feature update! We will use this blog to share a summary of product, community, and learning updates from throughout the month so you can access it in one easy place. A variety of new and highly anticipated features are now available which we are very excited to share: Trust Build apps across multiple tenants with Azure B2B makerImproved Canvas App monitoring with Experimental Application Insights FeaturesESLint rules for Power Apps and Dynamics 365Creating canvas apps as Dataverse solutions by default Maker Productivity Table designer now in preview in the canvas and model-driven app designersAutomatically create a Power App from a REST APIModern command bar in CanvasInstall Apps via Power Platform CLI & Install API Trust Build apps across multiple tenants with Azure B2B maker With the new Power Apps B2B maker preview, working across subsidiaries and partners is easier. Makers can now build apps as a guest in another tenant: apps can be built in the Azure Active Directory tenant it is expected to be hosted. For example, it is now possible for maker@contoso.com to build apps directly in the ContosoSubsidiaryA.com tenant. This reduces the overhead in building and deploying apps in organizations with multiple tenants because of mergers and acquisitions, organizations that use multiple AD tenants for compliance and auditing purposes, e.g. users authenticate in one tenant and access and edit resources in alternate tenants, and organizations that have business partners or contractors working on across tenant boundaries. Learn more with admin documentation and maker documentation.  Improved app monitoring with experimental Application Insights features Two new experimental features are now available for canvas apps connected to Application Insights. The first feature reports unhandled errors experienced by end-users. The second enables correlation tracing across canvas apps and connected custom connectors. Both features can be enabled in the upcoming features menu. Error reporting will pass unhandled errors during runtime, which end-users experience as a red error banner notification, to Application Insights. Error reporting is a powerful feature that enables trend analysis and proactive alerting on errors experienced by app users. No longer do you have to rely on users to report issues with production apps! Correlation tracing is a powerful tool to join telemetry events across apps and connected services. Without any added work you can now see outbound requests to custom connectors. For custom connectors that are instrumented with Application Insights, telemetry associated with a call from an app to the connector can be joined to supply a full picture of the call stack. This can be incredibly helpful in debugging issues. Learn more at Analyze telemetry of a canvas app using Application Insights – Power Apps | Microsoft Docs ESLint rules for Power Apps and Dynamics 365 In 2019, we announced the general availability of Solution Checker. This helped many of you analyze your solutions and packages for any issues in your customizations. We got feedback from you that this is very valuable in finding and addressing issues before deploying to production environments. Today we’re taking a step further and bringing these validations to your development environment to help you find and fix issues in your JavaScript code before being added to a solution. We are excited to announce the public preview of ESLint rules for Power Apps model-driven apps and Dynamics 365 CE. Learn more at the original blog post. Creating canvas apps as Dataverse solutions by default We are excited to announce the release of canvas apps creation as Dataverse solutions by default in public preview. Solutions are used to transport apps, flows, tables and other components from one environment to another and are a key mechanism for implementing healthy application lifecycle management (ALM) in the Power Platform. Unlike model-driven apps and most other objects, makers can optionally create their canvas apps outside of a solution and outside Dataverse. This can lead to unhealthy ALM practices, and create an overhead for DevOps teams and admins as they try to automate their ALM process. With this feature, environment admins will be able to set citizen makers and developers in a healthy ALM ready state from day one by enabling canvas apps as Dataverse solutions by default for one or more environments. Learn more at the original blog post. Maker Productivity Table designer now in preview in the canvas and model-driven app designers We are excited to announce that you can now create new Dataverse tables and edit them using the table designer in the standalone model-driven app designer. This new feature allows you to have a one stop shop for all your table creation and data editing needs by saving you the time it takes moving between designers.  Create a new table – While creating a new Dataverse table is easy to do today, as a user who might have the need to add multiple tables to your app page or even continue from an already existing table, this newly launched experience will allow you to do all of these while still working in the model-driven app designer.  Edit your Dataverse table – Formerly, to create a new Dataverse table you would have to go to the Data sources pane from the model-driven app design to select the actual table needed to be edited which would usually automatically open up in a new tab causing loss of context between the action being taken and the work being done. With this new experience you can now make all your edits in one place, have your changes saved automatically and continue with the order of business.  Learn more about how to work-with-model-driven-app-pages  And this isn’t limited to just model driven apps! Also, for canvas apps, you can now create and edit Dataverse tables in the current Dataverse environment right from the canvas app designer.  You can also add and edit data in those tables right within the canvas studio without leaving the context of your work. Ready to get started? Learn more about creating Dataverse tables in the canvas app designer here. Automatically create a Power App from a REST API Custom connectors exist today to be the bridge between Power Platform and Azure Functions (or other REST APIs). But, there are still many manual steps that must be followed to create a functional Power App once a custom connector is in place. The ‘canvas create’ feature of the PAC CLI gives pro developers an easy way to get up and running by letting them automatically generate a functional Power App directly from a custom connector. With this feature, a single command line function will let developers generate a canvas app from their API definition.  The app can then be imported into Power Apps Studio for further edits or customization. Makers and developers alike can benefit from the productivity of low code and Power Apps to quickly build rich user experiences over their APIs. Learn more at the original blog post. Modern command bar in Canvas The modern command bar is now officially available behind the preview toggle in Settings for canvas page authoring. The new command bar not only has a modern look and feel but is also designed to improve your authoring experience. It allows a seamless customization experience of editing common controls by dynamically displaying the common properties directly within the command bar. This experience can be enabled via ‘Settings’ under ‘Upcoming features’ > ‘Preview’ in canvas web today and will soon be available by default. Learn more at the docs page. Install Apps via Power Platform CLI & Install API This capability enables automation of install and update experiences that are offered only through the Power Platform Admin Center experience today. Installs can also be automated for applications available from AppSource provided at least one such install of the said application has been made to another environment within the tenant. This public API and tools support opens the possibility for Admins and developers to install applications as part of CI/CD automated processes using their tool of choice. We have enabled this capability directly from Power Platform CLI to ease the onboarding effort for our customers; GitHub and Azure DevOps actions support is forthcoming. Enabling this API and associated tooling addresses a major gap in the Application Lifecycle Management (ALM) story for the Power Platform. We expect significant productivity gains for Pro-developers with this investment; they can now provision Dev, Test and Prod environments and install applications of their choice to those environments before importing their solution(s) ensuring the whole process can be fully automated. In many instances, solutions being developed require pre-requisite applications to be installed already in the target environment; this capability makes this achievable. Learn more at the original blog post and the App Install CLI Command, Step-By-Step Tutorial, and API Reference docs pages. Learning and Doc Updates We’ve also released new, and made updates to some of documentation – see a summary before of some of the key updates : We are looking forward to seeing everyone at the Microsoft sponsored Power Platform Conference on September 18-23 in Orlando, Florida. If you haven’t already you can register here. Please continue sending us your feedback on features you would like to see in Power Apps. We hope that you enjoy the update!

Automatically create a Power App from a REST API

Chris Baldwin, Principal Product Manager, Power Apps Studio, Wednesday, August 17, 2022 You’ve deployed a REST API for your new service, and you’ve created a custom connector so that the Power Platform can work with it. Now what? We are excited to announce a new Power Platform CLI command that will create a fully functional canvas Power App that can be used to explore and validate your service with Power Apps. All the controls and Power Fx formulas needed to run the app are generated automatically. This means that for fusion teams, the app can then be handed off to a low-code maker for further customizations in Studio. Along with the recently announced features that facilitate the creation of apps from an image file or a Figma design, this is yet another way that we are making it easier than ever to get started with Power Apps. The generated app will feature a screen for each POST and GET action defined in the custom connector and will have controls on each screen that are appropriate to the types of input and output that are defined by the actions. For example, if the custom connector’s action specifies a list of valid input values, this will be represented by a dropdown control in the app. As another example, if the input type is defined as an array of strings, the appropriate controls will be generated to let the user populate the elements of the array. Underlying each screen will be auto-generated Power Fx formulas that handle the interaction with the custom connector. This feature is surfaced to users as the Power Platform CLI command canvas create. To get started, download and install the Power Platform CLI. You’ll need at least version 1.17.4. More information is available in the Microsoft Power Platform CLI documentation. Using the canvas create command, specify a custom connector within a solution and an output path for the new .msapp file on your local machine: Once imported into Studio, here is what the app generated from the above custom connector looks like. This app has several GET and POST actions, each of which are represented by a screen. You can navigate to one of the actions and interact directly with the API. This example shows the output returned from a basic GET request, displayed in a data table within the app: We’d love to hear your feedback on this feature and to learn about how you plan to use it.  As always, your input will directly influence the direction of this feature in future releases.  Join the Power Apps Community forum to share your thoughts and feedback.

New version of Power Platform Build Tools and a Feature packed update of Power Platform CLI

We are happy to announce a new version of the Power Platform Build Tools (Azure DevOps tasks) and our monthly update to Power Platform CLI. Read on for significant new features coming this month, including: Power Platform Build Tools: Now based on Power Platform CLI New CLI command to assign user New CLI command to automatically generate an App from an API definition New CLI command to sync existing solution from an environment Read on for more details and other new capabilities. Power Platform Build Tools v2.0 Our new version of the Power Platform Build Tools is built on top of the Power Platform CLI, whereas the previous version was based on PowerShell. By aligning these tasks to be based on Power Platform CLI, we can now maintain the same delivery rate of new features as we do with GitHub actions and based on several internal tests with customers these tasks run at 20% to 25% faster than the older version. We had several internal teams try out and use these pipelines. The ALM Accelerator for Power Platform, built by our Power CAT team, was an early adopter of this “re-platforming” effort. As most of us know, the ALM Accelerator is a Power App, that has flows, Connection References, and exercises many of the components of the Power Platform. It’s also used to automate the ALM of the tools the Power CAT team build like the CoE Starter Kit and the Creator Kit.  The Power CAT team has a complex setup, with multiple environments, and pipelines comprised of 40+ yaml files. Each pipeline contains up to 30 tasks and even in this complex setup, we saw a significant impact on the pipeline performance with the new version of the Build Tools. The next monthly release of the ALM Accelerator will be upgraded to the v2.0 tasks, so all customers using the ALM Accelerator who upgrade to the next release will benefit from this. Figure 1: ALM Accelerator setup for deployment using Power Platform Build Tools v2.0 How do you know which version of the task you are using? When creating your pipeline using the pipeline edit make sure to have the following selections in place to use PAC CLI version. Below is an example from my developer instance: Figure 2: Task version selection in Azure DevOps between Power Platform CLI version versus the PowerShell version Once you select a version of the Power Platform Build Tools tasks you cannot mix and match, as the pipeline will not run, as in you cannot have the installer be a different version and the solution import use the PowerShell version. If you do not want to use the Azure DevOps task editor to change the version, you can use the YAML editor in Azure DevOps and change the version number from 0 to 2 Figure 3: Find and replace the version of the task to be used To learn how to edit the yaml files in Azure DevOps, please follow the instructions here. When using Power Platform Build Tools version 2, you will notice that it is also cross platform and can run on both windows and Linux runners in Azure DevOps. Package Deploy task will not work Linux agents and will require windows runners New capabilities in the July Refresh for the Power Platform CLI We are happy to announce an abundance of new features with the July refresh of the Power platform CLI. From cross-platform support perspective, the Power Platform CLI now runs on .NET 6 and uses the generally available version of the Dataverse Service Client (1.0.9). That is just what is under the hood of the command line, but there is more … Changes in the Admin sub command of Power Platform CLI We have introduced a new sub command for pac admin, and it is: Assign-user The assign user capability is one of the most requested features, in the past when an environment was created via a pipeline or via the command line from a service principal account then the newly created environment would be owned by the service principal account. Now you can assign a user to the target environment, so that when solutions that have flows that a particular user owns need to be active, well now that is possible, they will be. The sequence of events would be as follows: Figure 4: Sequence of events in Azure DevOps for assigning user The command line equivalent looks like this Figure 5: pac cli command line for assign user Changes in the auth create command In the last update we started down the path of single sign-on by providing something called the universal auth profile. You can still create admin and dataverse profiles, but those are deprecated now. With the universal auth profile, if your account has admin functions, you can create environments and run other administrative functions in addition to creating solutions etc. In the July update, we have now introduced creating a universal profile against a selected environment by providing –environment, we did this because when you created the universal single sign-on profile, it would create access to your default environment, now with the –environment flag you can change it. Figure 6: when creating universal auth profile it defaults to the default environment Figure 7: creating a universal profile against the selected environment pac auth update The new pac update command now provides the ability to change properties of your authentication profiles. Before you could create an auth profile and select different auth profiles. Now you can rename existing auth profiles including the environment to which the auth profile is associated with. Figure 8: Update authentication property New Command: pac canvas create This is a new command developed from the Power Apps team and contributed to the Power Platform CLI. This new capability allows you to generate an App from an API definition. Pro developers who build Azure Functions or other web APIs can create a custom connector that points to the API, and then use the canvas create command to generate a functional app. The generated app can be used to interact with or validate the API. In fusion teams, a pro developer can run the command to generate the app and then hand it off to a low-code maker to make further customizations in Studio. The generated app will feature a screen for GET and POST actions defined in the custom connector, control layout that is tailored to the input and output types defined in the actions, and auto-generated Power Fx code for interacting with the custom connector. Figure 9: pac canvas create command Updates in the org commands Within the pac org commands we now support selecting a particular org and then support filtering with the list command. Figure 11: The usual pac org list command And now with the filter command And instead of doing and pac auth update, you can now just do a pac org select and change the environment url for the current authentication profile Figure 12: changing the org for the current auth profile Updates in the solution command pac solution sync (preview) this new command (in-preview) is a handy one, especially if you use pac solution clone like me, has it ever happened that you had cloned a solution from your developer environment, and were working on a PowerFx regular expression and only to realize another team mate of yours changed a different screen in the maker studio while you were editing a regular expression, in the past you had to re-clone your solution and then make sure to reintroduce your changes. Now with pac solution sync you don’t have to do that anymore with sync you just get the delta, and you can continue building your own PowerFx regular expression. We have also increased the timeout period to 1 hour for pac solution check, the user community demanded this, and we were incredibly happy to oblige. You can also add a solution component to an unmanaged solution on disk with the command pac solution add-solution-component Updates for packages and plugin development The package command now supports the ability to add F&O packages for deployment with the parameter add-external-package pac plugin push now provides the ability to push updates to an already registered plugin. Updated Power Platform CLI documentation Documentation for Power Platform CLI has also been updated with these new commands and parameters that are being offered. Please check out the new reference page and provide us with feedback. Power Platform Conference in Orlando One last thing, we have the first ever in-person user conference happening in September for Power Platform Please register and if you are coming, we have several sessions happening for Code-first developers. Some sessions of interest are: Looking forward to seeing you there. So, even though we did not release the June refresh, we tried our best to make sure that we made up for it in July. As always, we are excited to bring these capabilities to you. If you have additional feedback, please reach out to us via the following forums ISVFeedback@Microsoft.com or The PowerUsers community. Raise the issue and bugs at the following location in GitHub https://aka.ms/powerplatform-vscode

Creating canvas apps as Dataverse solutions by default (preview)

We are excited to announce the public preview of canvas apps in Dataverse solutions by default. Solutions are used to transport apps and components from one environment to another or to apply a set of customizations to existing apps. A solution can contain one or more apps as well as other objects such as site maps, tables, processes, web resources, choices, flows, and more. A solution and its objects are stored in Microsoft Dataverse. Solutions are also the key mechanism for implementing application lifecycle management (ALM) in the Power Platform. For more information about solutions, see Solutions overview, and application lifecycle management (ALM) guide Unlike model-driven apps and most other objects, makers can optionally create their canvas apps outside of a solution and outside Dataverse. This can lead to unhealthy ALM practices, and create an overhead for DevOps teams and admins as they try to automate their ALM process. With this feature, environment admins will be able to set citizen makers and developers in a healthy ALM ready state from day one by enabling canvas apps as Dataverse solutions by default for one or more environments. Enable canvas apps creation as Dataverse  solutions by default  Canvas apps in solutions by default feature is disabled by default. However, environment admins can enable this feature by going to environment advanced settings, Product Settings, and toggle the feature “Create new canvas apps in Dataverse by default”  to “On” to enable the feature. Default behavior By default, this feature saves all canvas apps to the default solution named Common Data Services  (CDS) Default Solution published by Microsoft Dataverse Default Publisher (see below). As a best practice, we recommend that makers create their canvas apps in custom solutions or move canvas apps created from the default solution to a custom solution to facilitate the management of solutions and establish a common standard across all environments. As always, we would love to hear from you on how we could keep improving this feature. Please leave your feedback and comments on this post so that we can keep track of your comments and requests. For more information about adding canvas apps in solution by default, see Add canvas apps to solution by default (preview). See related: Manage feature settings in a Power Platform environment Implement healthy solution ALM with canvas apps in solution by default

Whats new: Power Apps July 2022 Feature Update

Clay Wesener, Principal GPM, Power Apps Studio, Monday, July 25, 2022 Welcome to the inaugural Power Apps monthly feature update! We will use this blog to share a summary of product, community, and learning updates from throughout the month so you can access it in one easy place. A variety of new and highly anticipated features are now available which we are very excited to share: Trust Simplify and streamline Power Platform governance with Managed Environments Auto updates for Power Apps & Dynamics CE Improve monitoring of Dataverse plugins using Application insights Maker Productivity Find and replace in the Power Apps Studio Review feedback and ratings from your users Customizing forms with even more components End User Productivity Find your business data in Microsoft Search Power Apps on Windows generally available Seamlessly add your apps to Teams Expanded support for NFC, and markup support in MR controls   Trust Simplify and streamline Power Platform governance with Managed Environments This month we announced the preview of Managed Environments, a set of built-in governance capabilities that will simplify and automate IT administration of the Power Platform at scale. Managed Environments offers out-of-the-box simplicity with premium administration capabilities for low-code asset management at scale. It is designed to streamline governance, increase IT trust, and significantly reduce the burden on IT. In this preview release, Managed Environments includes a weekly admin digest that provides proactive adoption insights, such as apps and flows that have not been active for a while and may need to be cleaned up. Sharing controls offer admins a simple way to block makers from sharing with security groups or specify how many people a canvas app can be shared with. Admins can activate Managed Environments in any environment from the Power Platform admin center with just a few clicks and immediately get more visibility, more control, with less effort to manage all their low-code assets. Learn more at the original blog post or Docs Auto updates for Power Apps & Dynamics CE The new feature allows automatic updates of third-party apps installed through AppSource, helping both ISVs and customers keep software up to date in a simple and controlled way, with minimal administrative overhead. Customers can control whether to opt-in to enable the feature and indicate which publishers are permitted to automatically update apps in their environment, providing flexibility to pause auto updates based on their needs. Additionally, ISVs can leverage the analytics in ISV Studio to monitor the customers who have opted into the feature and are on the latest version of their apps. Learn more at Auto App Updates (Preview) – Power Apps | Microsoft Docs | Share feedback. Improve monitoring of Dataverse plugins using Application insights We are excited to announce that Application insights is now Generally Available for Dataverse plugins. We learnt from our customers how important it is to have monitoring available out-of-the-box and to easily get started with samples and recommendations including effective alerts, optimal queries, and customizable reports. To ensure that you can monitor your production workloads anywhere in a trustworthy manner, we have enabled state-of-art monitoring solution built on the Azure Monitor ecosystem designed to help prodevs to diagnose plugin timeouts, create custom alerts and reports, monitor global usage, and automatically detect patterns and anomalies in the telemetry data using the built-in Smart Detection feature, thus helping you to keep it always available, reliable and performant. Learn more at Improve monitoring of Dataverse plugins using Application insights | Microsoft Power Apps Maker Productivity Find and replace in the Power Apps Studio In the past finding and updating things like variables and collections in your canvas apps often meant spending a lot of time digging through individual formulas across multiple controls and screens. In July we introduced the “Replace” capability to the Search Pane, now in  preview. This new addition to the Search Pane means you can now find and replace variables, collections, media, flow, formula content and more. This new pane allows you to be as broad or as granular with your search as you need – find all of the things you’re looking for in your canvas app or exactly the thing you are looking for.   And now you can replace as well! You can include as many or as few search results as you need to make updating your app as easy and efficient as possible. Rename variables and collections, update media references, replace text and formula values and more. Learn more about how to use the Search Pane for fast updates to your app. Review feedback and ratings from your users We are enabling makers and organization administrators to view the app ratings and comments provided by app users. The feature is currently available only for model-driven apps as part of preview. The mechanism to capture feedback for the apps is completely managed by Microsoft and is compliant with all international privacy and security standards. The feedback is processed to generate satisfaction score of an app on a scale of 0 to 200 which is displayed to makers for their apps. In addition to app satisfaction score and trends, the feature also provides list of all comments provided by end users which makers and administrators can sort by satisfaction scale. The feature also provides integration with actions to improve your apps – Solution Checker, Performance Insights, Live Monitor and usability recommendations. Learn more here. Customizing forms with even more components You can now add more components to your model-driven forms through the modern form designer! Try customizing the look and feel of your forms with custom components built by Microsoft or other providers available through the marketplace. Learn more at Add, configure, move, or delete components on a form – Power Apps | Microsoft Docs End User Productivity Find your business data in Microsoft Search Allow your Dynamics users to easily locate information from Bing.com, Office.com, and Sharepoint.com by enabling the Dynamics 365 connector. Make your Dynamics users more productive by eliminating switching apps to get to quickly needed business data. Learn more at Dynamics 365 results in Microsoft Search | Microsoft Docs Power Apps on Windows generally available Find all your canvas and model-driven apps in one place. Just sign in, choose an app, and you’re ready to go! Use your apps wherever you are with or without network thanks to offline support. It works just like it does on iOS and Android. With Intune for application management, you can manage the devices and people in your organization that have access to Power Apps on Windows. Power Apps on Windows gives you native experiences to make the most of your Windows device. Add media controls like audio and video, barcode scanner and file attachments to see these experiences in action.’ Learn more at Install Power Apps for Windows – Power Apps | Microsoft Docs Seamlessly add your apps to Teams We are excited to announce a new feature that will make your Power Apps and Teams integration that much easier. Currently, customers can add their favorite apps to Teams by using the “Add to Teams” button at make.powerapps.com/apps. We have extended this capability to our Web Player for canvas apps. Now, they can launch their favorite canvas apps and pin these apps in Teams straight from the Web Player’s header. This capability prevents a user from having to leave the app context & return to make.powerapps.com/apps to add the app to Teams. We believe this new feature will help you more seamlessly enjoy the apps that you use & love in Teams, increasing your in-context productivity & decreasing the amount you need to click. So, next time you are playing a great Power App, check out the button with the Teams logo on the Web Player’s header (see below). Learn more at Embed an app in Teams – Power Apps | Microsoft Docs Expanded support for NFC, and markup support in MR controls The ReadNFC() function has been improved to return all records on the NFC tag as well as the identifier. These records and identifier make it easy to build Power Apps around asset tracking, inventorying, and attendance tracking. Scan the NFC tag on a pallet to see what products are contained within. Scan the uniquely identified tags in products on a shelf to see what is currently available. Have participants scan their NFC-tagged badge to track attendance. The Markup in MR control enables users to paint 3D lines and draw arrows in context of physical space on top of a device’s camera feed. These mixed reality markups can be used during inspections, audits, walkthroughs and more to point out features of the environment and certain objects anchored in space. Lines and arrows can be drawn in a variety of colors to highlight different areas. Learn more at Use the Markup in MR control in Power Apps – Power Apps | Microsoft Docs and ReadNFC function – Power Platform | Microsoft Docs   Learning and Doc Updates We’ve also released new, and made updates to some of documentation – see a summary before of some of the key updates : Meet the team at the Power Platform Conference! Our team is excited to join the Microsoft Power Platform Conference in the United States sponsored by Microsoft, in-person, in Orlando, Florida, September 20 to 22, 2022. In addition to featuring more than 100 speakers and more than 150 sessions, conference-goers will have the opportunity to connect—and reconnect—with users from around the world, building their personal and professional relationships, while gaining valuable insight into what’s new and next for Microsoft’s business applications. Understand how your peers are using the Power Platform and putting them to work Get new ideas on how you can utilize the tools in more useful ways Meet new #PowerAddicts just like you! Learn about all the tools in the platform Give your organization the edge it needs to provide a more productive and exciting work environment Ask product experts your questions during the live Q&A You can see an overview of the current sessions here. Click here to register: Microsoft Power Platform Conference That is all for this month. Please continue sending us your feedback on features you would like to see in Power Apps. We hope that you enjoy the update!
- Advertisement -spot_img

Latest News

Unified admin center replacing Customer Service standalone experiences

The new Customer Service admin center unifies and simplifies administration across the Microsoft Dynamics 365 Customer Service suite. We’re...
- Advertisement -spot_img