JSON view customizations in SharePoint Online are usually created for local use within a list or library. The view described in this article, however, is intended for web parts - altering how Site Page contents are displayed across pages and templates.

Automatic Updates

Changes and additions to the Site Page library are automatically reflected everywhere the TOC view is currently implemented via web part.

Even when installed across hundreds of pages, updates require just a single action at the source library. This can be quite useful for wiki-style and informational sites… especially ones that will evolve and grow over time.

Implementing

Note: Don’t let the length of this section fool you. These steps are not particularly complicated or time-consuming. I always try to include extra detail, as a fair amount of visitors stumble across this blog. 👍

Site Page Library - Columns

Several custom columns are needed to define the TOC structure. These columns can be created directly within the Site Pages library (easiest) or within the corresponding content type (more flexible).

🔷 Sort Order

Create a number column, which will be used to define the TOC page sequence. This field is not referenced by the formatting JSON, so name it as you wish:

The above settings will work fine, but you don’t have to strictly adhere to them. You might want to disable enforce unique values, for example, as it can be a minor pain later on, without much benefit.

🔷 Indentation

Create another number column, which will define the hierarchy within the TOC. Name it Indent, to align with field references in the formatting JSON:

Site Page Library - Custom View(s)

🔷 Table of Contents (display view)

This view will (later) receive the custom JSON formatting.

1. Create a new public view (call it TOC or something similar)

2. Include these columns:

   1. Indent

   2. Name (for use in forms)

   3. Title

3. Set the Sort parameter to use the custom Order column (assuming you created it):

   

4. Set the Filter criteria to only include items with an Indent value:

   

   💡

   Ignore the lowercase “i” in the screenshot above - field name is Indent (woops)
   ℹ

   You can add a boolean column (or similar) if you’d like more control over item visibility in the TOC. Indent works fine, but if that column has a default value set, new pages will show up instantly.

🔷 Table of Contents (management view)

Optional step, but you may want to do one of these:

1. Add the new library columns to the All Pages system view (and make it the library default, instead of the clumsy, grouped By Author view).

2. Create a new view for working with TOC site page metadata (that won’t receive the JSON formatting)

Site Page Library - Bulk Edit Existing Pages

If there are existing pages in the library, use quick edit to assign column values (Order, Indent) to the pages you want included in the TOC.

Also, make sure each page has a Title value.

Column Usage Tips: Indent

The indent value affects the padding of TOC items and for the more indented ones, font size.

Column Usage Tips: Order

Give yourself plenty of “space” when assigning Order values. Space them apart by counts of 10-100, to provide flexibility for reordering or adding later.

If you number each page sequentially (1,2,3…) you might need to re-number a bunch of Order values to insert new pages where you want them, later.

View Formatting JSON

Details / Notes

Overall, it’s a decent custom view - not a perfect one.

• Much of the styling in this JSON is done using classes, but there are some fixed values in the mix (margins, e.g.)

• There are probably some minor opportunities to improve HTML / flexbox stuff, too

• The key lines for conditional styling are 20, 39 and 45

  • Some of those conditions resolve identically. Those are legacies from development, left in to allow for future customization.

{
  "$schema": "https://developer.microsoft.com/json-schemas/sp/v2/row-formatting.schema.json",
  "schema": "https://developer.microsoft.com/json-schemas/sp/view-formatting.schema.json",
  "target": "_self",
  "debugMode": false,
  "hideColumnHeader": true,
  "hideSelection": true,
  "rowFormatter": {
    "elmType": "a",
    "attributes": {
      "class": "ms-fontColor-themeDarker ms-fontColor-themeDarker--hover",
      "href": "=@currentWeb + '/SitePages/' + [$FileLeafRef]",
      "target": "_self"
    },
    "style": {
      "text-decoration": "none",
      "border": "none",
      "cursor": "pointer",
      "margin-bottom": "2px",
      "margin-left": "=if([$indent] == 2,'12px', if([$indent] == 4, '24px', if([$indent] == 6,'36px', '0px')))",
      "padding": "2px",
      "overflow": "hidden",
              "width": "100%",
              "max-width": "280px"
    },
    "customRowAction": {
      "action": "defaultClick"
    },
    "children": [
      {
        "elmType": "div",
        "style": {
          "display": "flex",
          "flex-direction": "column",
          "align-items": "baseline",
          "flex-wrap": "wrap",
          "box-sizing": "border-box",
          "border-width": "0px",
          "border-left-width": "=if([$indent] == 0,'3px', if([$indent] == 2, '3px', '3px'))",
          "border-style": "solid",
          "padding-left": "4px",
              "width": "100%"
        },
        "attributes": {
          "class": "=if([$indent] == 0,'ms-fontSize-mPlus ms-borderColor-themeDark', if([$indent] == 2, 'ms-fontSize-mPlus ms-borderColor-themeSecondary', if([$indent] == 4,'ms-fontSize-m ms-borderColor-themeLight', 'ms-fontSize-m ms-borderColor-themeLighter'))) + ' ms-bgColor-themeLighter--hover'"
        },
        "children": [
          {
            "elmType": "div",
            "style": {
              "line-height": "1.0em",
              "margin": "2px 0",
              "text-align": "left"
            },
            "txtContent": "[$Title]"
          }
        ]
      }
    ]
  }
}

Document Library Web Part

Add a Document Library web part onto a site page and configure it like this:

By this point, you should be in business.

If this worked out for you, or if you have any difficulties, please drop me a note in the comments.

• Error Handling - THE FLYING POLYMATH

• Try Catch - D365 Demystified

• Error Handling Standards - Matthew Devaney

How can we investigate exceptions without wading through countless pages of flow run history?

If integrating with Azure Application Insights is not in scope and the information available within the Automation Center is not granular or specific enough, consider custom event logging.

Scenarios / Use Cases

Log List Examples

Approval Event History

Scheduled Automation

Bulk Content Sync

Creating a Log or Event List

Columns

There’s no perfect recipe, but I usually include a column for each of these values:

• Run outcome (success, error, warning, etc.)

• Outcome details

• Associated item title

• Associated item ID

• Flow run ID

Then, add additional columns for your specific logging scenario, as needed.

For ALM scenarios, you may find adding these helpful:

• Flow name

• Solution name

• Environment

Configuration Tips

1. Disable search on the list (advanced settings) or restrict list permissions to only the relevant individuals/audiences

   

2. Index any columns that might be needed for sorting/filtering

3. Include a multi-line plain text column, if you’d like to store JSON output

   

4. Create view(s) and add custom column formatting, if that helps readability

5. Examine the list after log entries start to populate - you may think of another field or two worth capturing

Cloning an Existing List

Assuming custom logging proves useful, you may want to create more lists in the future. You can use an existing list as a template, to speed creation. Some options:

• ShareGate migration tool

• Use an existing list option in the SharePoint UI (under site contents)

  

• Microsoft Lists

Adding Logging Actions

Once your list is ready, it’s time to add some flow logic. New log entries will be added using a Create Item action.

There are two general approaches for adding logging steps - both achieve the same result, but have different considerations.

Add to Existing Flow(s)

You can sprinkle logging actions within your existing flow logic, utilizing copy/paste.

Create Standalone Logging Flow

Alternatively, you can create a separate flow (HTTP trigger or child solution flow) to store your logging steps:

Once created, invoke it from existing flow(s) as needed:

Other Notes

• Consider disabling retry policies whenever a standalone logging flow gets invoked or a Create Item log action is called. You don’t want to hold up a parent flow run in the unlikely event that logging hits a snag.

• For logging hierarchical flow outcomes, consider creating an entry for when the parent begins, ends, and every child iteration in between. Store a shared identifier (like parent flow run ID) to help group entries later.

  

• Calculating overall flow run duration, error and success totals, etc. can add additional value to the last log entry for a given flow run. Don’t spend the time adding that logic unless the extra insight is worth it, however.

• You can use the logging technique described on this page to store errors / exceptions only, or you can include successful outcomes and other event types, depending on the situation.

There are several options available when file uploads are enabled for Microsoft Forms:

• Can be optional or required

• Can be limited from 1-10 attachments

• Can restrict to certain file types

You can construct workflow logic around these options, but it's usually best to handle a multitude of scenarios, in case the form or connector changes later.

Storage Locations

Attachments for both types of Forms are stored in different locations:

Tip: Using the same group for both the Form (source) and Planner board (destination) simplifies permissions and avoids the need to move attachment content.

Workflow Logic

The automation is triggered by new form submissions. With each run, the details for each submission are collected and a corresponding Planner task is created.

Optionally, add a condition to determine if attachment(s) were included in the form response, so the subsequent logic can account for both scenarios:

You will need an expression to determine if the file upload "question" within the form is empty or not:

The expression uses a length function on the question within the form that collects attachments. If the outcome is greater than 0, the workflow will "know" attachments were included and can respond accordingly:

Within the Yes branch of the condition, use a Select action to convert the array of form attachments into a format compatible with Planner. Once complete, it will look like this:

For the From field, wrap the dynamic value used above (your attachment "question" within the form) inside a JSON function:

Next, map two properties - resourceLink and alias. Toggle to advanced/text mode...

...and paste the following snippet:

{
    "resourceLink": @{item()?['link']},
    "alias": @{item()?['name']}
}

Once that's complete, add an Update Task Details action, using the ID value from the preceding Create Task action:

Switch to advanced mode within the References section of the Select action and add the Output from the previous Select statement:

Note: attachments in Planner are known internally as references

At this point, your attachment handling logic should be complete.

Create a test form submission, and you should see a task card with the correct attachments included:

Don't forget to go back and complete the No path for the "does the response contain attachments" condition, and incorporate any additional logic you might need in the workflow.

Here's what worked for me in early 2023!

Prerequisites

Even though some of these are detailed topics, I am going to gloss over them since they are covered in-depth elsewhere on the web:

1. Register an Azure App for use as a service principal (later) with your data factory

2. Grant the application appropriate roles for your intended use of Graph

3. Store the client secret value for the app in Azure Key Vault

4. Enable managed identities for your data factory

5. Give the managed identity for your data factory the appropriate role on the Key Vault (to retrieve stored client secret)

6. Configure a data sink to store the Graph results, and ensure the data factory has permission to write there

7. Create a new Linked Service within ADF (type: REST)

   1. Set the Authentication type as Service Principal

   2. Use the Azure Key Vault method to retrieve the client secret from AKV

   3. AAD Resource: https://graph.microsoft.com/

   4. Parameterize the Base URL value

This will get you something like this:

Dataset, Pipeline and Activity Setup

1. Create a new Dataset using the new Linked Service you created (above steps)

   1. You can parameterize the baseURL value if you'd like to use one Dataset for multiple Graph queries.

      

2. Otherwise, provide a fixed Graph API endpoint value within the Dataset, like:

   https://graph.microsoft.com/v1.0/users?$select=id,accountEnabled,createdDateTime,department,displayName,employeeId,employeeType,jobTitle,mail,userPrincipalName,userType,manager,employeeHireDate&$expand=manager($select=id)

3. Create a new Pipeline and add a Copy Data activity

4. Configure the Copy Data activity to use the Dataset you created

5. Delete the automatically-supplied Pagination criteria (RFC5988)

6. Add a new Pagination Rule, like this:

   

Your source definition within the Copy activity should look something like this:

"source": {
    "type": "RestSource",
    "httpRequestTimeout": "00:01:40",
    "requestInterval": "00.00:00:00.010",
    "requestMethod": "GET",
    "paginationRules": {
        "AbsoluteUrl": "$['@odata.nextLink']"
    }
}

Now, when your Copy Data activity executes, it will keep fetching results from Graph until the @odata.nextlink is no longer present in the result body, at which point it will start the sink activity.

Note: this is my first time using the new Neptune editor on Hashnode ... forgive any oddities with the numbered list formatting... I am in a bit of a hurry and will try to fix the markdown later

One of the more common uses for Power Automate is working with **Excel files and data**. Overall compatibility is pretty good, with one significant exception.

Historically, that last item creates a lot of frustration. 😐 Excel is used extensively in the business world and this limitation puts its most commonly-used format outside the reach of Microsoft's own automation platform.

Unstructured Data - Example

The data in this worksheet looks like a table to you and me, but without a formal definition, Automate can't work with the information here.

It needs explicit structure before column relationships and the corresponding data inside the Excel document can be utilized.

The Scenario

You might not use Automate to work with Excel very often¹, but like most juggernauts, it's sometime unavoidable. Here is a situation that presented itself recently:

1. A partner organization emails a collection of Excel worksheets every morning

2. A flow stores them in a SharePoint Online document library

3. The worksheets have consistent structures but the data is not contained within tables

4. The data needs to reach Azure SQL each day without manual intervention

The Solution

Preparing For Multiple Files/Formats

Our scenario involves multiple worksheets, each with a unique data structure. I used an array variable to store configuration details at the beginning of the flow:

Note: If you're working with one Excel file, feel free to skip to the next section

Each object contains information about a worksheet:

Name | Example | Usage --- | --- filename | incomingWorksheet2.xlsx | Name of the Excel worksheet colWidth | BA | Identifier for the last expected column rowLength | 2500 | Number of table rows to create (see notes on "padding" in next section) colHeadings | CustomerName;Item;Price | OPTIONAL - column heading overrides tableName | Sales | SQL table where data will be stored. Also used to name each Excel table created. keyColumn | saleID | Column used to filter results - use one that has a value in every row

Next, we will loop over the array, and the real party can begin:

Note: Pre-baked arrays are okay when quickly proving out a new method. For an actual solution, environment variables are a better choice.

Adding Tables into Excel Worksheets with Existing Data

The Excel connector within Power Automate has a Create Table action. You can use this action to insert a table into an Excel worksheet that already contains data. I was very surprised to see this work!

We're not out of the woods yet, though. The amount of worksheet data fluctuates each day in our scenario, which is a problem because Automate can't "see" how much data exists at each runtime.

We can mitigate some of the uncertainty by "padding" the Create Table action. For example, if you expect ~2,000 rows of data in a worksheet, have the flow create 2,500-3,000 rows when inserting the table.

Without surplus rows, you risk isolating data. Automate can't create tables twice in the same worksheet, so options for self-correction are slim if you undershoot the mark. Aim high, but don't go too far overboard!

Note: This "padding" technique only works if you can make solid predictions about the expected data

Here is the Create Table action, using dynamic values from the configuration array:

Note: Use fixed values for the parameters if you're operating on a single worksheet

If your setup is correct, the existing Excel data will remain in place while the new table is inserted. The action will continue until it hits the row limit, adding blank rows to the worksheet once it runs past the data.

Getting Data Back from Excel

Use List Table Rows to pull the data into Automate. Provide an OData filter query (under advanced options) to retrieve non-blank rows only:

items('for_each_Excel_document')?['keyColumn']

Unless you are dealing with very small data sets, don't forget to enable pagination for the List Table Rows action. This will allow the flow to pull all the data back from Excel in successive chunks, then proceed once complete.

Set the threshold equal to the highest row count you'll be using in the Create Table action(s).

Do Something With the Results

If you've made it this far, the possibilities are wide open! Extracting unstructured data from Excel worksheets using Power Automate is no small feat.

Possibilities From Here

• Loop over each row in the result set and store the data somewhere (SQL, SharePoint, Dataverse, etc.) line-by-line

• Use a switch statement to handle the results from unique worksheets in different ways

• Pass the result set into a SQL table (1,000 rows at a time) using the Execute a SQL query action

Thoughts on Excel as a Data Source

Excel is often a popular data source for users getting started with the Power Platform. It's a familiar, flexible and portable format.

I don't typically recommend it - there are more performant and less volatile options available. Sometimes you don't have a choice, so it's good to have a few tricks up your sleeve.

Disclosure and Final Thought

There are better, far more elegant ways to solve this problem than the approach described on this page. What's outlined above isn't a foolproof method. It's not designed for heavy usage across a broad spectrum of enterprise-grade scenarios.

But in a pinch, and for the right use cases, this method should get the job done. I hope this comes in handy for individuals who don't necessarily have the means, expertise or time to handle app registration, HTTP calls, Graph, and so forth. As you continue your journey along the Power Platform progression arc, I hope you learn those methods, too.

SharePoint is known for its highly customizable permissions. That flexibility can have its perils, of course, but with the right approach (and for the right scenarios) it can be very effective.

Power Automate provides a few basic connector actions for working with SharePoint permissions:

1. Revoke access to an item

2. Create access links for an item

Not much for now, but fortunately the HTTP to SharePoint action opens up numerous other possibilities.

Familiar Methods, New Approach

SharePoint's REST API has a number of endpoints for managing permissions. Most methods can be re-used across different entities like sites, lists, items, etc. If you've done on-premises SharePoint development, you may already be familiar with some of them.

The calls are simple - no payloads, headers or returns to process for most scenarios. The only tricky part can be finding the exact syntax, and there may be some data peculiarities to manage, depending on your scenario.

Power Automate HTTP Examples - SharePoint Permissions

Getting the Principal ID of a Group

Type: GET

Note: Replace GROUP NAME with your target group name

_api/web/sitegroups/getbyname('GROUP NAME')/Id

Getting Principal IDs for All Groups

_api/web/sitegroups?$select=Title,ID

Results will be an array of all groups available on the site.

Note: You can find group IDs manually by clicking individual groups within Site Settings -> People and Groups and checking the address bar.

Cutting this corner won't save you much time, however. For most scenarios, it's better to fetch the value(s) at runtime.

Getting Principal ID for Specific User

There are a couple ways to do this. First, you might want to use a tool like SP Insider (pictured above) to get familiar with the SiteUsers data structure within your site.

Or, with Power Automate…

Here are two sample queries - one for email, one for user name:

_api/Web/SiteUsers?$filter=Email eq 'Sample.Person@samplesite.com'

Note: The search terms are case sensitive!

_api/Web/SiteUsers?$filter=Title eq 'Sample Person'

You'll get a single-node array in the return, containing the user's ID value for that site.

Getting Principal IDs for All Users

You'll be getting a lot of data back with this one, potentially, so consider using select to narrow the return down to just the fields you need.

_api/Web/SiteUsers?$select=ID,Title,Email

There are some important limitations to consider here:

1. SiteUsers data is site-specific

2. A user's Principal ID on one site will be different from their Principal ID on another site

3. The SiteUsers list will only contain records for users who have visited the site (or have been added via a few other methods).

There is an ensureUser method to explore, if you want to pursue this approach further.

Getting All List/Library GUIDs

I tend to work with GUIDs more than GetByTitle endpoints, so the examples on this page are tailored to that approach. Here's a quick way to get all list GUIDs on a site, in case you need it:

Type: GET

/_api/Web/Lists?&$select=Title, ID

Getting All Role Definitions

Each permission role in SharePoint (Full Control, Edit, etc.) has a specific ID associated with it. You'll need this value for some of the example calls below.

Type: GET

_api/web/roledefinitions

Results will be an array containing objects for each role definition.

Get Current Permissions on Item/Document

Type: GET

_api/web/lists/getbytitle('LIST NAME')/items(ITEM ID)/roleassignments

Will return an array of objects. Each PrincipalId will tell you who has permission to the item, but not the permission type.

Use an Apply to Each step to loop through the results and perform further actions.

Break Permission Inheritance on an Item or Document

Type: POST

_api/Web/Lists(guid'LIST GUID')/Items(12)/breakroleinheritance(copyRoleAssignments=true, clearSubscopes=true)

Restore Permission Inheritance on Item/Document

*Added August, 2024

_api/Web/lists/getByTitle('YOUR-LIST-OR-LIBRARY-HERE')/items(ITEM-ID-HERE)/ResetRoleInheritance()

Type: POST

Remove Permissions from a List/Library

Type: DELETE

_api/Web/Lists(guid'LIST GUID')/RoleAssignments/GetByPrincipalId(5)

Note: Replace the principal ID value for the user/group you are targeting, and the GUID for your list or library.

Remove Permissions from an Item/Document

Type: DELETE

_api/Web/Lists(guid'LIST GUID')/Items(12)/RoleAssignments/GetByPrincipalId(5)

Note: Replace the the principal ID and list GUID values to suit your specific scenario

You don't need a specific role definition for this one - it will simply remove the target entity's permissions (whatever those may be) for the item.

Add Permissions to a List/Library

Type: POST

_api/Web/Lists(guid'LIST GUID')/RoleAssignments/addroleassignment(principalid=5,roledefid=1073741827)

Note: Replace the the principal ID, role definition and list GUID values to suit your specific scenario

Conclusion

That covers many of the more common permission management activities in SharePoint. You can extend this approach to cover lots of other scenarios, as well. 👍

I'm a fan of Microsoft Planner. It's easy to use, flexible, and the UI/UX is rock solid. The tie-in with O365 Groups and Teams is a strong selling point, as well.

Now, Planner isn't the perfect solution for every scenario (you probably wouldn't want to manage sprints with it) but it is very popular within many companies, large and small.

Definitions

Microsoft naming conventions don't always make things easy, so:

Integration Opportunities Abound

Planner can be used in many different ways, but at its core it's all about task management, which makes it a juicy target for automation. The Power Platform connector is pretty robust, and you can extend that even further by hitting the Planner API through Microsoft Graph.

However, any integration efforts quickly expose Planner's underlying data structure, which has some quirks.

Task Labels

Planner boards come with 25 labels to help you and your team classify the individual tasks on the board. Each label has a default name - its associated color - and that name can be customized to provide more meaning and context for the plan users. Cool feature!

Customizations, like label names, are contained at the individual plan level. For example, one team might use red for marking "Urgent" work and a different team may use it to classify something as "Top Secret."

The Challenge

When retrieving Planner task data, any label information comes back as an appliedCategories object:

It's not an array.

There are no name/value pairs.

It's just... booleans with no tie-back to the label names. What does category18 mean? Has it been customized? How can I tell?

Fortunately, you can get a bit of a "glossary" if you retrieve the overall plan data:

That's great, but how do I map those values? How do I bounce a name/value object against an object of booleans?

The Power Automate Way

Different platforms/languages will have their own approach to the challenges above. For Automate, it required some considerable thinking!

At the time this came up, I was working on a solution that iterated over many plans, so I needed a method that scaled. If you are working with data from just an individual plan, there are definitely some corners you could cut.

Building a Glossary Array

1.) When I got to the point in my automation where I was working with individual plans, I used the Get plan details action.

2.) Next, I used a Compose statement to craft my array. It took a lot of typing, but copy/paste made it less of an ordeal.

3.) Most teams that use labels within Planner also customize the label names - but it's not an absolute certainty. The Get plan details action only returns customized values. I wanted to be certain I covered both scenarios, so I used a coalesce expression within each node of the array.

Creating a Task Label Array

The steps above get us halfway there, but we still need to handle the other part of the mapping - the data from each individual task.

4.) Inside of a For each task loop, I started with a Parse JSON step, using the appliedCategories value as the content source.

5.) The schema needs to be created manually (unless you magically have a task with all 25 labels applied, to feed into the generator):

{ "type": "object", "properties": { "category1": { "type": "boolean" }, "category2": { "type": "boolean" }, "category3": { "type": "boolean" }, "category4": { "type": "boolean" }, "category5": { "type": "boolean" }, "category6": { "type": "boolean" }, "category7": { "type": "boolean" }, "category8": { "type": "boolean" }, "category9": { "type": "boolean" }, "category10": { "type": "boolean" }, "category11": { "type": "boolean" }, "category12": { "type": "boolean" }, "category13": { "type": "boolean" }, "category14": { "type": "boolean" }, "category15": { "type": "boolean" }, "category16": { "type": "boolean" }, "category17": { "type": "boolean" }, "category18": { "type": "boolean" }, "category19": { "type": "boolean" }, "category20": { "type": "boolean" }, "category21": { "type": "boolean" }, "category22": { "type": "boolean" }, "category23": { "type": "boolean" }, "category24": { "type": "boolean" }, "category25": { "type": "boolean" } } }

The Parse JSON step is important because it saves you having to write 25 expressions with null-handling logic in the next step.

6.) Next, I used a Compose statement (and a lot of copy/pasting) to create the initial array for the task labels. Note the key/value format matches the "glossary" we created previously.

7.) Then we filter the task label array to remove any nodes containing nulls. Booleans are tricky when filtering arrays in Automate, so switch to advanced mode and use an expression:

@equals(item()?['value'], true)

This yields an array like this:

[ { "key": "category14", "value": true }, { "key": "category18", "value": true }, { "key": "category19", "value": true }, { "key": "category23", "value": true } ]

Putting it All Together

8.) Now, you've got matching arrays - both sides of the equation! Where you take it from here may vary depending on your solution needs.

I needed each applied label as an individual record, so I looped through the newly-created task label array, filtering against the glossary array we created earlier with each iteration.

A couple people reached out to ask for more details on step #8 recently.

Here are the details on the For Each action and the Filter step just inside. You may need to zoom in or click the picture to see smaller details:

This last part may vary, depending on how you want the label data structured in your flow. I packed each value into an object and rolled those into an array variable using an Append action:

Here is the object, with each expression expanded. I include taskID since it's an effective way to relate child entities in Planner (labels, assignments, etc.) back to the parent:

{
  "labelTitle": first(body('filter_plan_labels_with_task_labels'))?['value'],
  "taskID": items('for_each_task')?['ID'],
  "labelID": int(
                substring(
                    first(body('filter_plan_labels_with_task_labels'))?['key'],
                    8
                )
             )
}

The final stage for this workflow gathers up the data collected for the various Planner entities and ships it off to a separate flow for processing and storage.

I hope that helps!

There is a pretty fun story to be told about this particular solution, but I will save that for another article - don't want to get off track here tonight.

Conclusion

This was an interesting puzzle to solve, and the only real drawback was that it involved a fair amount of repetition. But now that it's done, I've got a robust solution that can be scaled considerably.

Some of the upper-echelon Automate junkies might be able to squeeze a little more speed out of this method, but overall it is quite performant. Using Compose actions instead of variables any time you can get away with it definitely helps. Automate handles arrays and array filtering very quickly, too.

Flow Source

If you want to see a mermaid visual of the logic flow, please visit this GitHub Gist.

And here is the (sanitized) source JSON for the flow:

{
  "$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "$connections": {
      "defaultValue": {},
      "type": "Object"
    },
    "$authentication": {
      "defaultValue": {},
      "type": "SecureObject"
    },
    "bool_emailNotifications (jake_emailNotifications)": {
      "defaultValue": true,
      "type": "Bool",
      "metadata": {
        "schemaName": "jake_emailNotifications",
        "description": "Set to No if you want to turn off 'process complete' emails"
      }
    },
    "text_sqlServer (jake_sqlServer)": {
      "defaultValue": "***SCRUBBED***",
      "type": "String",
      "metadata": {
        "schemaName": "jake_sqlServer"
      }
    },
    "text_sqlDatabase (jake_sqlTable)": {
      "defaultValue": "***SCRUBBED***",
      "type": "String",
      "metadata": {
        "schemaName": "jake_sqlTable"
      }
    },
    "text_emailRecipients (jake_emailRecipients)": {
      "defaultValue": "***SCRUBBED***",
      "type": "String",
      "metadata": {
        "schemaName": "jake_emailRecipients"
      }
    },
    "text_processFlowEndpoint (jake_test_postURL)": {
      "defaultValue": "***SCRUBBED***",
      "type": "String",
      "metadata": {
        "schemaName": "jake_test_postURL",
        "description": "endpoint for triggering processing sub flow "
      }
    }
  },
  "triggers": {
    "Recurrence": {
      "recurrence": {
        "frequency": "Day",
        "interval": 1,
        "timeZone": "Pacific Standard Time",
        "startTime": "2022-05-01T00:00:00Z",
        "schedule": {
          "hours": [
            "1"
          ]
        }
      },
      "metadata": {
        "operationMetadataId": "48f13d96-ccee-42b8-9de4-d9e92c683b79"
      },
      "type": "Recurrence"
    }
  },
  "actions": {
    "init_assignmentArray": {
      "runAfter": {
        "init_taskArray": [
          "Succeeded"
        ]
      },
      "metadata": {
        "operationMetadataId": "ee36ea65-589b-4cbb-88f4-4d427253f226"
      },
      "type": "InitializeVariable",
      "inputs": {
        "variables": [
          {
            "name": "assignmentArray",
            "type": "array"
          }
        ]
      }
    },
    "init_taskObject": {
      "runAfter": {
        "init_errorCount": [
          "Succeeded"
        ]
      },
      "metadata": {
        "operationMetadataId": "df6b1fbf-f47b-42a4-ac2e-f6af361e2887"
      },
      "type": "InitializeVariable",
      "inputs": {
        "variables": [
          {
            "name": "taskObject",
            "type": "object",
            "value": {
              "taskID": "",
              "planID": "",
              "bucketID": "",
              "taskTitle": "",
              "planTitle": "",
              "bucketTitle": "",
              "taskDescription": "",
              "startDate": "",
              "createdDate": "",
              "dueDate": "",
              "completeDate": "",
              "createdByID": "",
              "orderHint": "",
              "pctComplete": ""
            }
          }
        ]
      }
    },
    "init_errorString": {
      "runAfter": {
        "init_outcomeArray": [
          "Succeeded"
        ]
      },
      "metadata": {
        "operationMetadataId": "8b4796a3-4846-4fef-9c94-11860d9767c9"
      },
      "type": "InitializeVariable",
      "inputs": {
        "variables": [
          {
            "name": "errorString",
            "type": "string"
          }
        ]
      }
    },
    "init_taskArray": {
      "runAfter": {
        "init_taskObject": [
          "Succeeded"
        ]
      },
      "metadata": {
        "operationMetadataId": "242f3f77-c144-4d0e-a9f4-5dd030a23526"
      },
      "type": "InitializeVariable",
      "inputs": {
        "variables": [
          {
            "name": "taskArray",
            "type": "array"
          }
        ]
      }
    },
    "init_checklistArray": {
      "runAfter": {
        "init_labelArray": [
          "Succeeded"
        ]
      },
      "metadata": {
        "operationMetadataId": "a8e30162-dc67-40a2-aa2c-5c3d9234b896"
      },
      "type": "InitializeVariable",
      "inputs": {
        "variables": [
          {
            "name": "checklistArray",
            "type": "array"
          }
        ]
      }
    },
    "init_labelArray": {
      "runAfter": {
        "init_labelValuesArray": [
          "Succeeded"
        ]
      },
      "metadata": {
        "operationMetadataId": "fb3b0418-82c1-4001-8135-04c7bcde2a7b"
      },
      "type": "InitializeVariable",
      "inputs": {
        "variables": [
          {
            "name": "labelArray",
            "type": "array"
          }
        ]
      }
    },
    "init_attachmentArray": {
      "runAfter": {
        "init_assignmentArray": [
          "Succeeded"
        ]
      },
      "metadata": {
        "operationMetadataId": "40513abf-01c1-4699-8681-263ee9e882a4"
      },
      "type": "InitializeVariable",
      "inputs": {
        "variables": [
          {
            "name": "attachmentArray",
            "type": "array"
          }
        ]
      }
    },
    "init_labelValuesArray": {
      "runAfter": {
        "init_attachmentArray": [
          "Succeeded"
        ]
      },
      "metadata": {
        "operationMetadataId": "9d17111f-b964-422c-b416-9a3ee0b59349"
      },
      "type": "InitializeVariable",
      "inputs": {
        "variables": [
          {
            "name": "labelValuesArray",
            "type": "array"
          }
        ]
      },
      "description": "used for storing the label info for a given plan - dont think it's used"
    },
    "Plan_and_task_iteration": {
      "actions": {
        "for_each_plan": {
          "foreach": "@outputs('get_active_plans')?['body/value']",
          "actions": {
            "List_buckets": {
              "runAfter": {},
              "metadata": {
                "operationMetadataId": "0e8aa5dd-aac0-4784-b418-693f426629a2"
              },
              "type": "OpenApiConnection",
              "inputs": {
                "host": {
                  "connectionName": "shared_planner",
                  "operationId": "ListBuckets_V3",
                  "apiId": "/providers/Microsoft.PowerApps/apis/shared_planner"
                },
                "parameters": {
                  "groupId": "@items('for_each_plan')?['GroupID']",
                  "id": "@items('for_each_plan')?['PlanID']"
                },
                "authentication": "@parameters('$authentication')"
              }
            },
            "List_tasks": {
              "runAfter": {
                "plan_label_values_array": [
                  "Succeeded"
                ]
              },
              "metadata": {
                "operationMetadataId": "d7847aa4-8952-41c1-8f4e-533c880b946b"
              },
              "type": "OpenApiConnection",
              "inputs": {
                "host": {
                  "connectionName": "shared_planner",
                  "operationId": "ListTasks_V3",
                  "apiId": "/providers/Microsoft.PowerApps/apis/shared_planner"
                },
                "parameters": {
                  "groupId": "@items('for_each_plan')?['GroupID']",
                  "id": "@items('for_each_plan')?['PlanID']"
                },
                "authentication": "@parameters('$authentication')"
              }
            },
            "for_each_task": {
              "foreach": "@outputs('List_tasks')?['body/value']",
              "actions": {
                "filter_bucket_array": {
                  "runAfter": {},
                  "metadata": {
                    "operationMetadataId": "bab69193-9ca3-4715-8d61-254f7fa86136"
                  },
                  "type": "Query",
                  "inputs": {
                    "from": "@outputs('List_buckets')?['body/value']",
                    "where": "@equals(item()?['id'], items('for_each_task')?['bucketId'])"
                  }
                },
                "is_more_task_detail_needed": {
                  "actions": {
                    "Get_task_details": {
                      "runAfter": {},
                      "metadata": {
                        "operationMetadataId": "40bd4ba4-1fe8-4566-9c90-783a1a028b88"
                      },
                      "type": "OpenApiConnection",
                      "inputs": {
                        "host": {
                          "connectionName": "shared_planner",
                          "operationId": "GetTaskDetails_V2",
                          "apiId": "/providers/Microsoft.PowerApps/apis/shared_planner"
                        },
                        "parameters": {
                          "id": "@items('for_each_task')?['id']"
                        },
                        "authentication": "@parameters('$authentication')"
                      }
                    },
                    "for_each_checklist_item": {
                      "foreach": "@outputs('Get_task_details')?['body/checklist']",
                      "actions": {
                        "append_to_checklist_array": {
                          "runAfter": {},
                          "metadata": {
                            "operationMetadataId": "77340521-feb2-4cf3-8a6d-00f31d7277d1"
                          },
                          "type": "AppendToArrayVariable",
                          "inputs": {
                            "name": "checklistArray",
                            "value": {
                              "itemTitle": "@items('for_each_checklist_item')?['value/title']",
                              "itemComplete": "@items('for_each_checklist_item')?['value/isChecked']",
                              "taskID": "@items('for_each_task')?['id']",
                              "orderHint": "@items('for_each_checklist_item')?['value/orderHint']",
                              "itemID": "@int( items('for_each_checklist_item')?['id'] )",
                              "modifiedByID": "@items('for_each_checklist_item')?['value/lastModifiedBy/user/id']",
                              "modifiedDate": "@items('for_each_checklist_item')?['value/lastModifiedDateTime']"
                            }
                          }
                        }
                      },
                      "runAfter": {
                        "append_taskObject_to_taskArray_detailed": [
                          "Succeeded"
                        ]
                      },
                      "metadata": {
                        "operationMetadataId": "491f333b-8f0c-4b00-90c9-f19c10948a6c"
                      },
                      "type": "Foreach",
                      "runtimeConfiguration": {
                        "concurrency": {
                          "repetitions": 50
                        }
                      }
                    },
                    "for_each_attachment": {
                      "foreach": "@outputs('Get_task_details')?['body/references']",
                      "actions": {
                        "append_to_attachmentArray": {
                          "runAfter": {},
                          "metadata": {
                            "operationMetadataId": "23902441-6a89-4dd2-b1eb-6b2068053cb7"
                          },
                          "type": "AppendToArrayVariable",
                          "inputs": {
                            "name": "attachmentArray",
                            "value": {
                              "createdByID": "@items('for_each_attachment')?['value/lastModifiedBy/user/id']",
                              "attachmentTitle": "@items('for_each_attachment')?['value/alias']",
                              "attachmentLink": "@items('for_each_attachment')?['resourceLink']",
                              "taskID": "@items('for_each_task')?['id']"
                            }
                          }
                        }
                      },
                      "runAfter": {
                        "for_each_checklist_item": [
                          "Succeeded"
                        ]
                      },
                      "metadata": {
                        "operationMetadataId": "1db02863-5401-4ccb-a543-835d83505745"
                      },
                      "type": "Foreach",
                      "runtimeConfiguration": {
                        "concurrency": {
                          "repetitions": 50
                        }
                      }
                    },
                    "append_taskObject_to_taskArray_detailed": {
                      "runAfter": {
                        "Get_task_details": [
                          "Succeeded"
                        ]
                      },
                      "metadata": {
                        "operationMetadataId": "8a962b72-e609-496a-b789-05e80f48f3ee"
                      },
                      "type": "AppendToArrayVariable",
                      "inputs": {
                        "name": "taskArray",
                        "value": {
                          "taskID": "@items('for_each_task')?['ID']",
                          "planID": "@items('for_each_task')?['planId']",
                          "bucketID": "@items('for_each_task')?['bucketId']",
                          "taskTitle": "@items('for_each_task')?['title']",
                          "planTitle": "@items('for_each_plan')?['PlanName']",
                          "bucketTitle": "@first(body('filter_bucket_array'))?['name']",
                          "taskDescription": "@outputs('Get_task_details')?['body/description']",
                          "startDate": "@items('for_each_task')?['startDateTime']",
                          "createdDate": "@items('for_each_task')?['createdDateTime']",
                          "dueDate": "@items('for_each_task')?['dueDateTime']",
                          "completeDate": "@items('for_each_task')?['completedDateTime']",
                          "createdByID": "@items('for_each_task')?['createdBy/user/id']",
                          "orderHint": "@items('for_each_task')?['orderHint']",
                          "pctComplete": "@items('for_each_task')?['percentComplete']"
                        }
                      }
                    }
                  },
                  "runAfter": {
                    "filter_bucket_array": [
                      "Succeeded"
                    ]
                  },
                  "else": {
                    "actions": {
                      "append_taskObject_to_taskArray": {
                        "runAfter": {},
                        "metadata": {
                          "operationMetadataId": "8a962b72-e609-496a-b789-05e80f48f3ee"
                        },
                        "type": "AppendToArrayVariable",
                        "inputs": {
                          "name": "taskArray",
                          "value": {
                            "taskID": "@items('for_each_task')?['ID']",
                            "planID": "@items('for_each_task')?['planId']",
                            "bucketID": "@items('for_each_task')?['bucketId']",
                            "taskTitle": "@items('for_each_task')?['title']",
                            "planTitle": "@items('for_each_plan')?['PlanName']",
                            "bucketTitle": "@first(\n    body('filter_bucket_array')\n    )?['name']",
                            "taskDescription": "",
                            "startDate": "@items('for_each_task')?['startDateTime']",
                            "createdDate": "@items('for_each_task')?['createdDateTime']",
                            "dueDate": "@items('for_each_task')?['dueDateTime']",
                            "completeDate": "@items('for_each_task')?['completedDateTime']",
                            "createdByID": "@items('for_each_task')?['createdBy/user/id']",
                            "orderHint": "@items('for_each_task')?['orderHint']",
                            "pctComplete": "@items('for_each_task')?['percentComplete']"
                          }
                        }
                      }
                    }
                  },
                  "expression": {
                    "or": [
                      {
                        "equals": [
                          "@items('for_each_task')?['hasDescription']",
                          true
                        ]
                      },
                      {
                        "greater": [
                          "@items('for_each_task')?['referenceCount']",
                          0
                        ]
                      },
                      {
                        "greater": [
                          "@items('for_each_task')?['checklistItemCount']",
                          0
                        ]
                      }
                    ]
                  },
                  "metadata": {
                    "operationMetadataId": "b8b0c2c6-d713-480e-9669-b824959b2c54"
                  },
                  "type": "If",
                  "description": "if a task has no description, checklist, or attachments, we don't need to run 'Get task details'"
                },
                "for_each_assignment": {
                  "foreach": "@items('for_each_task')?['_assignments']",
                  "actions": {
                    "append_to_assignmentArray": {
                      "runAfter": {},
                      "metadata": {
                        "operationMetadataId": "1d93b63a-b9e4-4c3b-8667-84e4845b2ed3"
                      },
                      "type": "AppendToArrayVariable",
                      "inputs": {
                        "name": "assignmentArray",
                        "value": {
                          "taskID": "@items('for_each_task')?['id']",
                          "assignedToID": "@items('for_each_assignment')?['userId']"
                        }
                      }
                    }
                  },
                  "runAfter": {
                    "is_more_task_detail_needed": [
                      "Succeeded"
                    ]
                  },
                  "metadata": {
                    "operationMetadataId": "0aacd0d8-1c14-46c3-9ac5-80431deb8100"
                  },
                  "type": "Foreach",
                  "runtimeConfiguration": {
                    "concurrency": {
                      "repetitions": 50
                    }
                  }
                },
                "task_labels_object": {
                  "runAfter": {
                    "for_each_assignment": [
                      "Succeeded"
                    ]
                  },
                  "metadata": {
                    "operationMetadataId": "1bd3d278-4616-405e-a76d-f9f1bb457947"
                  },
                  "type": "Compose",
                  "inputs": "@items('for_each_task')?['appliedCategories']"
                },
                "Parse_JSON_for_task_labels": {
                  "runAfter": {
                    "task_labels_object": [
                      "Succeeded"
                    ]
                  },
                  "metadata": {
                    "operationMetadataId": "c7ce52b2-6115-4ad8-81f1-107cc7efed71"
                  },
                  "type": "ParseJson",
                  "inputs": {
                    "content": "@outputs('task_labels_object')",
                    "schema": {
                      "type": "object",
                      "properties": {
                        "category1": {
                          "type": "boolean"
                        },
                        "category2": {
                          "type": "boolean"
                        },
                        "category3": {
                          "type": "boolean"
                        },
                        "category4": {
                          "type": "boolean"
                        },
                        "category5": {
                          "type": "boolean"
                        },
                        "category6": {
                          "type": "boolean"
                        },
                        "category7": {
                          "type": "boolean"
                        },
                        "category8": {
                          "type": "boolean"
                        },
                        "category9": {
                          "type": "boolean"
                        },
                        "category10": {
                          "type": "boolean"
                        },
                        "category11": {
                          "type": "boolean"
                        },
                        "category12": {
                          "type": "boolean"
                        },
                        "category13": {
                          "type": "boolean"
                        },
                        "category14": {
                          "type": "boolean"
                        },
                        "category15": {
                          "type": "boolean"
                        },
                        "category16": {
                          "type": "boolean"
                        },
                        "category17": {
                          "type": "boolean"
                        },
                        "category18": {
                          "type": "boolean"
                        },
                        "category19": {
                          "type": "boolean"
                        },
                        "category20": {
                          "type": "boolean"
                        },
                        "category21": {
                          "type": "boolean"
                        },
                        "category22": {
                          "type": "boolean"
                        },
                        "category23": {
                          "type": "boolean"
                        },
                        "category24": {
                          "type": "boolean"
                        },
                        "category25": {
                          "type": "boolean"
                        }
                      }
                    }
                  }
                },
                "task_labels_array": {
                  "runAfter": {
                    "Parse_JSON_for_task_labels": [
                      "Succeeded"
                    ]
                  },
                  "metadata": {
                    "operationMetadataId": "65d680cc-2ba7-4198-a3ef-007d5841dcf0"
                  },
                  "type": "Compose",
                  "inputs": [
                    {
                      "key": "category1",
                      "value": "@body('Parse_JSON_for_task_labels')?['category1']"
                    },
                    {
                      "key": "category2",
                      "value": "@body('Parse_JSON_for_task_labels')?['category2']"
                    },
                    {
                      "key": "category3",
                      "value": "@body('Parse_JSON_for_task_labels')?['category3']"
                    },
                    {
                      "key": "category4",
                      "value": "@body('Parse_JSON_for_task_labels')?['category4']"
                    },
                    {
                      "key": "category5",
                      "value": "@body('Parse_JSON_for_task_labels')?['category5']"
                    },
                    {
                      "key": "category6",
                      "value": "@body('Parse_JSON_for_task_labels')?['category6']"
                    },
                    {
                      "key": "category7",
                      "value": "@body('Parse_JSON_for_task_labels')?['category7']"
                    },
                    {
                      "key": "category8",
                      "value": "@body('Parse_JSON_for_task_labels')?['category8']"
                    },
                    {
                      "key": "category9",
                      "value": "@body('Parse_JSON_for_task_labels')?['category9']"
                    },
                    {
                      "key": "category10",
                      "value": "@body('Parse_JSON_for_task_labels')?['category10']"
                    },
                    {
                      "key": "category11",
                      "value": "@body('Parse_JSON_for_task_labels')?['category11']"
                    },
                    {
                      "key": "category12",
                      "value": "@body('Parse_JSON_for_task_labels')?['category12']"
                    },
                    {
                      "key": "category13",
                      "value": "@body('Parse_JSON_for_task_labels')?['category13']"
                    },
                    {
                      "key": "category14",
                      "value": "@body('Parse_JSON_for_task_labels')?['category14']"
                    },
                    {
                      "key": "category15",
                      "value": "@body('Parse_JSON_for_task_labels')?['category15']"
                    },
                    {
                      "key": "category16",
                      "value": "@body('Parse_JSON_for_task_labels')?['category16']"
                    },
                    {
                      "key": "category17",
                      "value": "@body('Parse_JSON_for_task_labels')?['category17']"
                    },
                    {
                      "key": "category18",
                      "value": "@body('Parse_JSON_for_task_labels')?['category18']"
                    },
                    {
                      "key": "category19",
                      "value": "@body('Parse_JSON_for_task_labels')?['category19']"
                    },
                    {
                      "key": "category20",
                      "value": "@body('Parse_JSON_for_task_labels')?['category20']"
                    },
                    {
                      "key": "category21",
                      "value": "@body('Parse_JSON_for_task_labels')?['category21']"
                    },
                    {
                      "key": "category22",
                      "value": "@body('Parse_JSON_for_task_labels')?['category22']"
                    },
                    {
                      "key": "category23",
                      "value": "@body('Parse_JSON_for_task_labels')?['category23']"
                    },
                    {
                      "key": "category24",
                      "value": "@body('Parse_JSON_for_task_labels')?['category24']"
                    },
                    {
                      "key": "category25",
                      "value": "@body('Parse_JSON_for_task_labels')?['category25']"
                    }
                  ]
                },
                "for_each_task_label": {
                  "foreach": "@body('filter_task_labels_array')",
                  "actions": {
                    "filter_plan_labels_with_task_labels": {
                      "runAfter": {},
                      "metadata": {
                        "operationMetadataId": "a9bad329-fa19-41ff-8533-527fdba98367"
                      },
                      "type": "Query",
                      "inputs": {
                        "from": "@outputs('plan_label_values_array')",
                        "where": "@equals(item()?['key'], items('for_each_task_label')?['key'])"
                      }
                    },
                    "append_to_labelArray": {
                      "runAfter": {
                        "filter_plan_labels_with_task_labels": [
                          "Succeeded"
                        ]
                      },
                      "metadata": {
                        "operationMetadataId": "4b7a974e-2343-4abc-b9fe-ca9ce06465fc"
                      },
                      "type": "AppendToArrayVariable",
                      "inputs": {
                        "name": "labelArray",
                        "value": {
                          "labelTitle": "@first(body('filter_plan_labels_with_task_labels'))?['value']",
                          "taskID": "@items('for_each_task')?['ID']",
                          "labelID": "@int(\r\n    substring(\r\n        first(body('filter_plan_labels_with_task_labels'))?['key'],\r\n        8\r\n    )\r\n)"
                        }
                      }
                    }
                  },
                  "runAfter": {
                    "filter_task_labels_array": [
                      "Succeeded"
                    ]
                  },
                  "metadata": {
                    "operationMetadataId": "503bf544-b0e9-433c-82f5-12ffaedbc419"
                  },
                  "type": "Foreach",
                  "runtimeConfiguration": {
                    "concurrency": {
                      "repetitions": 50
                    }
                  }
                },
                "filter_task_labels_array": {
                  "runAfter": {
                    "task_labels_array": [
                      "Succeeded"
                    ]
                  },
                  "metadata": {
                    "operationMetadataId": "ab454f83-d0f0-4956-9311-40840ab8ca9e"
                  },
                  "type": "Query",
                  "inputs": {
                    "from": "@outputs('task_labels_array')",
                    "where": "@equals(item()?['value'], true)"
                  }
                },
                "if_label_25_support_is_true": {
                  "actions": {
                    "if_task_not_complete": {
                      "actions": {
                        "link_to_this_task": {
                          "runAfter": {},
                          "metadata": {
                            "operationMetadataId": "559bc95a-b489-45af-8d41-5b6e96875fa7"
                          },
                          "type": "Compose",
                          "inputs": "<a href=\"https://tasks.office.com/***SCRUBBED***/Home/Task/@{outputs('Get_task_details')?['body/id']}\">@{items('for_each_task')?['title']}</a>"
                        },
                        "Post_message_in_a_chat_or_channel": {
                          "runAfter": {
                            "link_to_this_task": [
                              "Succeeded"
                            ]
                          },
                          "metadata": {
                            "operationMetadataId": "e6abb82c-7b65-42e2-99b6-19cc68093c5c"
                          },
                          "type": "OpenApiConnection",
                          "inputs": {
                            "host": {
                              "connectionName": "shared_teams_1",
                              "operationId": "PostMessageToConversation",
                              "apiId": "/providers/Microsoft.PowerApps/apis/shared_teams"
                            },
                            "parameters": {
                              "poster": "Flow bot",
                              "location": "Channel",
                              "body/recipient/groupId": "***SCRUBBED***",
                              "body/recipient/channelId": "***SCRUBBED***",
                              "body/messageBody": "<p>There has been a request for help from a task on the @{items('for_each_plan')?['PlanName']} (@{items('for_each_plan')?['Team']}) board in Planner.<br>\n<br>\n<span style=\"font-size: 16px\"></span><span style=\"font-size: 16px\">@{outputs('link_to_this_task')}</span><span style=\"font-size: 16px\"></span></p>"
                            },
                            "authentication": "@parameters('$authentication')"
                          }
                        },
                        "log_help_request": {
                          "runAfter": {
                            "Post_message_in_a_chat_or_channel": [
                              "Succeeded"
                            ]
                          },
                          "metadata": {
                            "operationMetadataId": "57d990aa-2533-4875-a43a-032328619dca"
                          },
                          "type": "OpenApiConnection",
                          "inputs": {
                            "host": {
                              "connectionName": "shared_sql",
                              "operationId": "PostItem_V2",
                              "apiId": "/providers/Microsoft.PowerApps/apis/shared_sql"
                            },
                            "parameters": {
                              "server": "***SCRUBBED***",
                              "database": "***SCRUBBED***",
                              "table": "***SCRUBBED***",
                              "item/workflowType": "taskRetrieve",
                              "item/outcome": "Support Request",
                              "item/details": "Task: @{items('for_each_task')?['title']}\nPlan: @{items('for_each_plan')?['PlanName']}\nTeam: @{items('for_each_plan')?['Team']}",
                              "item/startTime": "@body('Start_time_PST')"
                            },
                            "authentication": "@parameters('$authentication')"
                          }
                        }
                      },
                      "runAfter": {},
                      "expression": {
                        "not": {
                          "equals": [
                            "@items('for_each_task')?['percentComplete']",
                            100
                          ]
                        }
                      },
                      "metadata": {
                        "operationMetadataId": "97078d0f-d82e-4382-9501-5f5da3d914d6"
                      },
                      "type": "If"
                    }
                  },
                  "runAfter": {
                    "for_each_task_label": [
                      "Succeeded"
                    ]
                  },
                  "expression": {
                    "equals": [
                      "@body('Parse_JSON_for_task_labels')?['category25']",
                      "@true"
                    ]
                  },
                  "metadata": {
                    "operationMetadataId": "d9694eb5-44b2-4dfc-87aa-445050326d1c"
                  },
                  "type": "If"
                }
              },
              "runAfter": {
                "List_tasks": [
                  "Succeeded"
                ]
              },
              "metadata": {
                "operationMetadataId": "c62e1965-b11e-4ba9-bd86-d226d0c6aa8b"
              },
              "type": "Foreach",
              "runtimeConfiguration": {
                "concurrency": {
                  "repetitions": 50
                }
              }
            },
            "plan_label_values_array": {
              "runAfter": {
                "Get_plan_details": [
                  "Succeeded"
                ]
              },
              "metadata": {
                "operationMetadataId": "6d9990c3-257a-44a3-b7dc-4a290f5d9bc5"
              },
              "type": "Compose",
              "inputs": [
                {
                  "key": "category1",
                  "value": "@coalesce(\r\n    outputs('Get_plan_details')?['body/categoryDescriptions/category1'],\r\n    'Pink'\r\n)"
                },
                {
                  "key": "category2",
                  "value": "@coalesce(\r\n    outputs('Get_plan_details')?['body/categoryDescriptions/category2'],\r\n    'Red'\r\n)"
                },
                {
                  "key": "category3",
                  "value": "@coalesce(\r\n    outputs('Get_plan_details')?['body/categoryDescriptions/category3'],\r\n    'Yellow'\r\n)"
                },
                {
                  "key": "category4",
                  "value": "@coalesce(\r\n    outputs('Get_plan_details')?['body/categoryDescriptions/category4'],\r\n    'Green'\r\n)"
                },
                {
                  "key": "category5",
                  "value": "@coalesce(\r\n    outputs('Get_plan_details')?['body/categoryDescriptions/category5'],\r\n    'Blue'\r\n)"
                },
                {
                  "key": "category6",
                  "value": "@coalesce(\r\n    outputs('Get_plan_details')?['body/categoryDescriptions/category6'],\r\n    'Purple'\r\n)"
                },
                {
                  "key": "category7",
                  "value": "@coalesce(\r\n    outputs('Get_plan_details')?['body/categoryDescriptions/category7'],\r\n    'Bronze'\r\n)"
                },
                {
                  "key": "category8",
                  "value": "@coalesce(\r\n    outputs('Get_plan_details')?['body/categoryDescriptions/category8'],\r\n    'Lime'\r\n)"
                },
                {
                  "key": "category9",
                  "value": "@coalesce(\r\n    outputs('Get_plan_details')?['body/categoryDescriptions/category9'],\r\n    'Aqua'\r\n)"
                },
                {
                  "key": "category10",
                  "value": "@coalesce(\r\n    outputs('Get_plan_details')?['body/categoryDescriptions/category10'],\r\n    'Gray'\r\n)"
                },
                {
                  "key": "category11",
                  "value": "@coalesce(\r\n    outputs('Get_plan_details')?['body/categoryDescriptions/category11'],\r\n    'Silver'\r\n)"
                },
                {
                  "key": "category12",
                  "value": "@coalesce(\r\n    outputs('Get_plan_details')?['body/categoryDescriptions/category12'],\r\n    'Brown'\r\n)"
                },
                {
                  "key": "category13",
                  "value": "@coalesce(\r\n    outputs('Get_plan_details')?['body/categoryDescriptions/category13'],\r\n    'Cranberry'\r\n)"
                },
                {
                  "key": "category14",
                  "value": "@coalesce(\r\n    outputs('Get_plan_details')?['body/categoryDescriptions/category14'],\r\n    'Orange'\r\n)"
                },
                {
                  "key": "category15",
                  "value": "@coalesce(\r\n    outputs('Get_plan_details')?['body/categoryDescriptions/category15'],\r\n    'Peach'\r\n)"
                },
                {
                  "key": "category16",
                  "value": "@coalesce(\r\n    outputs('Get_plan_details')?['body/categoryDescriptions/category16'],\r\n    'Marigold'\r\n)"
                },
                {
                  "key": "category17",
                  "value": "@coalesce(\r\n    outputs('Get_plan_details')?['body/categoryDescriptions/category17'],\r\n    'Light green'\r\n)"
                },
                {
                  "key": "category18",
                  "value": "@coalesce(\r\n    outputs('Get_plan_details')?['body/categoryDescriptions/category18'],\r\n    'Dark green'\r\n)"
                },
                {
                  "key": "category19",
                  "value": "@coalesce(\r\n    outputs('Get_plan_details')?['body/categoryDescriptions/category19'],\r\n    'Teal'\r\n)"
                },
                {
                  "key": "category20",
                  "value": "@coalesce(\r\n    outputs('Get_plan_details')?['body/categoryDescriptions/category20'],\r\n    'Light blue'\r\n)"
                },
                {
                  "key": "category21",
                  "value": "@coalesce(\r\n    outputs('Get_plan_details')?['body/categoryDescriptions/category21'],\r\n    'Dark blue'\r\n)"
                },
                {
                  "key": "category22",
                  "value": "@coalesce(\r\n    outputs('Get_plan_details')?['body/categoryDescriptions/category22'],\r\n    'Lavender'\r\n)"
                },
                {
                  "key": "category23",
                  "value": "@coalesce(\r\n    outputs('Get_plan_details')?['body/categoryDescriptions/category23'],\r\n    'Plum'\r\n)"
                },
                {
                  "key": "category24",
                  "value": "@coalesce(\r\n    outputs('Get_plan_details')?['body/categoryDescriptions/category24'],\r\n    'Light gray'\r\n)"
                },
                {
                  "key": "category25",
                  "value": "@coalesce(\r\n    outputs('Get_plan_details')?['body/categoryDescriptions/category25'],\r\n    'Dark gray'\r\n)"
                }
              ]
            },
            "Get_plan_details": {
              "runAfter": {
                "List_buckets": [
                  "Succeeded"
                ]
              },
              "metadata": {
                "operationMetadataId": "0dc5fdf6-2fa2-48ae-a4e5-020dec34cb88"
              },
              "type": "OpenApiConnection",
              "inputs": {
                "host": {
                  "connectionName": "shared_planner",
                  "operationId": "GetPlanDetails",
                  "apiId": "/providers/Microsoft.PowerApps/apis/shared_planner"
                },
                "parameters": {
                  "id": "@items('for_each_plan')?['PlanID']"
                },
                "authentication": "@parameters('$authentication')"
              }
            },
            "Append_to_errorString_2": {
              "runAfter": {
                "List_buckets": [
                  "Failed"
                ]
              },
              "metadata": {
                "operationMetadataId": "62a6b5ae-3e2e-490c-9f7e-932225197b4e"
              },
              "type": "AppendToStringVariable",
              "inputs": {
                "name": "errorString",
                "value": "Failed to get Planner data (buckets)\n@{items('for_each_plan')?['PlanName']} | @{items('for_each_plan')?['PlanID']} | @{items('for_each_plan')?['GroupID']} | @{items('for_each_plan')?['GroupName']} | @{items('for_each_plan')?['InsertedOn']} | @{items('for_each_plan')?['Team']} | @{items('for_each_plan')?['Leader']} | @{items('for_each_plan')?['LastRunDate']}<br>"
              },
              "description": "if service account does not have plan access, an error will generate"
            },
            "increment_errorCount_2": {
              "runAfter": {
                "Append_to_errorString_2": [
                  "Succeeded"
                ]
              },
              "metadata": {
                "operationMetadataId": "dab9642e-300b-4202-9be7-323e2f874e11"
              },
              "type": "IncrementVariable",
              "inputs": {
                "name": "errorCount",
                "value": 1
              }
            },
            "update_lastRunDate_on_source_row": {
              "runAfter": {
                "for_each_task": [
                  "Succeeded"
                ]
              },
              "metadata": {
                "operationMetadataId": "9288db35-967c-4ad8-8010-55fe7fef0234"
              },
              "type": "OpenApiConnection",
              "inputs": {
                "host": {
                  "connectionName": "shared_sql",
                  "operationId": "PatchItem_V2",
                  "apiId": "/providers/Microsoft.PowerApps/apis/shared_sql"
                },
                "parameters": {
                  "server": "@parameters('text_sqlServer (jake_sqlServer)')",
                  "database": "@parameters('text_sqlDatabase (jake_sqlTable)')",
                  "table": "***SCRUBBED***",
                  "id": "@items('for_each_plan')?['ID']",
                  "item/LastRunDate": "@body('Start_time_PST')"
                },
                "authentication": "@parameters('$authentication')"
              }
            }
          },
          "runAfter": {
            "get_active_plans": [
              "Succeeded"
            ]
          },
          "metadata": {
            "operationMetadataId": "4795519f-7313-40f8-9956-4b55cd3d8164"
          },
          "type": "Foreach",
          "runtimeConfiguration": {
            "concurrency": {
              "repetitions": 50
            }
          }
        },
        "get_active_plans": {
          "runAfter": {},
          "metadata": {
            "operationMetadataId": "41fba7a5-dec9-4cf3-b9c9-2ab3af9320f1"
          },
          "type": "OpenApiConnection",
          "inputs": {
            "host": {
              "connectionName": "shared_sql",
              "operationId": "GetItems_V2",
              "apiId": "/providers/Microsoft.PowerApps/apis/shared_sql"
            },
            "parameters": {
              "server": "@parameters('text_sqlServer (jake_sqlServer)')",
              "database": "@parameters('text_sqlDatabase (jake_sqlTable)')",
              "table": "***SCRUBBED***",
              "$filter": "Active eq 1"
            },
            "authentication": "@parameters('$authentication')"
          },
          "description": "get active plans from SQL table (populated and managed by customer via powerApp)"
        },
        "increment_errorCount": {
          "runAfter": {
            "get_active_plans": [
              "Failed",
              "TimedOut"
            ]
          },
          "metadata": {
            "operationMetadataId": "5fe7081a-63d9-4a0c-86d9-23e0e70d964a"
          },
          "type": "IncrementVariable",
          "inputs": {
            "name": "errorCount",
            "value": 1
          }
        },
        "append_errorString": {
          "runAfter": {
            "increment_errorCount": [
              "Succeeded"
            ]
          },
          "metadata": {
            "operationMetadataId": "4331ac95-7f3e-447a-8a1f-c5510d0c2ca8"
          },
          "type": "AppendToStringVariable",
          "inputs": {
            "name": "errorString",
            "value": "Failed to get active plans<br>"
          }
        }
      },
      "runAfter": {
        "init_recordCounts": [
          "Succeeded"
        ]
      },
      "metadata": {
        "operationMetadataId": "97ae9def-14eb-4ffe-95f7-2f5e5ec0b360"
      },
      "type": "Scope"
    },
    "check_for_email_notification_preference": {
      "actions": {
        "send_completion_email_lite": {
          "runAfter": {},
          "metadata": {
            "operationMetadataId": "b340dff7-7d1b-4081-ab75-dbe9dc7180d1"
          },
          "type": "OpenApiConnection",
          "inputs": {
            "host": {
              "connectionName": "shared_office365_1",
              "operationId": "SendEmailV2",
              "apiId": "/providers/Microsoft.PowerApps/apis/shared_office365"
            },
            "parameters": {
              "emailMessage/To": "@parameters('text_emailRecipients (jake_emailRecipients)')",
              "emailMessage/Subject": "Task Aggegation Complete - @{div(sub(ticks(body('End_Time_PST')), ticks(body('Start_time_PST'))), 600000000)} minutes - @{variables('errorCount')} errors",
              "emailMessage/Body": "<p>@{variables('recordCounts')} </p>",
              "emailMessage/Importance": "Normal"
            },
            "authentication": "@parameters('$authentication')"
          }
        }
      },
      "runAfter": {
        "http_response": [
          "TimedOut"
        ]
      },
      "expression": {
        "equals": [
          "@parameters('bool_emailNotifications (jake_emailNotifications)')",
          true
        ]
      },
      "metadata": {
        "operationMetadataId": "05ae3102-3d82-424e-ad05-b2dfc05f743f"
      },
      "type": "If"
    },
    "init_errorCount": {
      "runAfter": {
        "init_errorString": [
          "Succeeded"
        ]
      },
      "metadata": {
        "operationMetadataId": "31631ada-9b18-4f95-9e4e-660597cb8d1d"
      },
      "type": "InitializeVariable",
      "inputs": {
        "variables": [
          {
            "name": "errorCount",
            "type": "integer",
            "value": 0
          }
        ]
      }
    },
    "Start_time_PST": {
      "runAfter": {},
      "metadata": {
        "operationMetadataId": "ccf5cf73-8dfa-4d3b-9b80-df852045c97e"
      },
      "type": "Expression",
      "kind": "ConvertTimeZone",
      "inputs": {
        "baseTime": "@{utcNow()}",
        "formatString": "o",
        "sourceTimeZone": "UTC",
        "destinationTimeZone": "Pacific Standard Time"
      }
    },
    "get_existing_SQL_records": {
      "actions": {
        "get_existing_tasks": {
          "runAfter": {},
          "metadata": {
            "operationMetadataId": "076b756a-9716-4a44-87ec-2582a1f0b7e8"
          },
          "type": "OpenApiConnection",
          "inputs": {
            "host": {
              "connectionName": "shared_sql",
              "operationId": "GetItems_V2",
              "apiId": "/providers/Microsoft.PowerApps/apis/shared_sql"
            },
            "parameters": {
              "server": "@parameters('text_sqlServer (jake_sqlServer)')",
              "database": "@parameters('text_sqlDatabase (jake_sqlTable)')",
              "table": "***SCRUBBED***",
              "$filter": "isActive eq 1"
            },
            "authentication": "@parameters('$authentication')"
          },
          "runtimeConfiguration": {
            "paginationPolicy": {
              "minimumItemCount": 25000
            }
          }
        },
        "get_existing_assignments": {
          "runAfter": {
            "get_existing_tasks": [
              "Succeeded"
            ]
          },
          "metadata": {
            "operationMetadataId": "076b756a-9716-4a44-87ec-2582a1f0b7e8"
          },
          "type": "OpenApiConnection",
          "inputs": {
            "host": {
              "connectionName": "shared_sql",
              "operationId": "GetItems_V2",
              "apiId": "/providers/Microsoft.PowerApps/apis/shared_sql"
            },
            "parameters": {
              "server": "@parameters('text_sqlServer (jake_sqlServer)')",
              "database": "@parameters('text_sqlDatabase (jake_sqlTable)')",
              "table": "***SCRUBBED***",
              "$filter": "isActive eq 1"
            },
            "authentication": "@parameters('$authentication')"
          },
          "runtimeConfiguration": {
            "paginationPolicy": {
              "minimumItemCount": 25000
            }
          }
        },
        "get_existing_attachments": {
          "runAfter": {
            "get_existing_assignments": [
              "Succeeded"
            ]
          },
          "metadata": {
            "operationMetadataId": "076b756a-9716-4a44-87ec-2582a1f0b7e8"
          },
          "type": "OpenApiConnection",
          "inputs": {
            "host": {
              "connectionName": "shared_sql",
              "operationId": "GetItems_V2",
              "apiId": "/providers/Microsoft.PowerApps/apis/shared_sql"
            },
            "parameters": {
              "server": "@parameters('text_sqlServer (jake_sqlServer)')",
              "database": "@parameters('text_sqlDatabase (jake_sqlTable)')",
              "table": "***SCRUBBED***",
              "$filter": "isActive eq 1"
            },
            "authentication": "@parameters('$authentication')"
          },
          "runtimeConfiguration": {
            "paginationPolicy": {
              "minimumItemCount": 25000
            }
          }
        },
        "get_existing_checklist_items": {
          "runAfter": {
            "get_existing_attachments": [
              "Succeeded"
            ]
          },
          "metadata": {
            "operationMetadataId": "076b756a-9716-4a44-87ec-2582a1f0b7e8"
          },
          "type": "OpenApiConnection",
          "inputs": {
            "host": {
              "connectionName": "shared_sql",
              "operationId": "GetItems_V2",
              "apiId": "/providers/Microsoft.PowerApps/apis/shared_sql"
            },
            "parameters": {
              "server": "@parameters('text_sqlServer (jake_sqlServer)')",
              "database": "@parameters('text_sqlDatabase (jake_sqlTable)')",
              "table": "***SCRUBBED***",
              "$filter": "isActive eq 1"
            },
            "authentication": "@parameters('$authentication')"
          },
          "runtimeConfiguration": {
            "paginationPolicy": {
              "minimumItemCount": 25000
            }
          }
        },
        "get_existing_labels": {
          "runAfter": {
            "get_existing_checklist_items": [
              "Succeeded"
            ]
          },
          "metadata": {
            "operationMetadataId": "076b756a-9716-4a44-87ec-2582a1f0b7e8"
          },
          "type": "OpenApiConnection",
          "inputs": {
            "host": {
              "connectionName": "shared_sql",
              "operationId": "GetItems_V2",
              "apiId": "/providers/Microsoft.PowerApps/apis/shared_sql"
            },
            "parameters": {
              "server": "@parameters('text_sqlServer (jake_sqlServer)')",
              "database": "@parameters('text_sqlDatabase (jake_sqlTable)')",
              "table": "***SCRUBBED***",
              "$filter": "isActive eq 1"
            },
            "authentication": "@parameters('$authentication')"
          },
          "runtimeConfiguration": {
            "paginationPolicy": {
              "minimumItemCount": 25000
            }
          }
        }
      },
      "runAfter": {
        "init_checklistArray": [
          "Succeeded"
        ]
      },
      "metadata": {
        "operationMetadataId": "0a15e51f-ea62-4662-9ec6-64805e8c3d3e"
      },
      "type": "Scope"
    },
    "init_recordCounts": {
      "runAfter": {
        "get_existing_SQL_records": [
          "Succeeded"
        ]
      },
      "metadata": {
        "operationMetadataId": "18ee4e3e-b4c7-4071-97b4-0bed010e698b"
      },
      "type": "InitializeVariable",
      "inputs": {
        "variables": [
          {
            "name": "recordCounts",
            "type": "string",
            "value": "<h3>EXISTING SQL RECORDS</h3>\n<ul>\n<li>Tasks: @{length( outputs('get_existing_tasks')?['body/value'] )}</li>\n<li>Assignments: @{length( outputs('get_existing_assignments')?['body/value'] )}</li>\n<li>Attachments: @{length( outputs('get_existing_attachments')?['body/value'] )}</li>\n<li>Checklist Items: @{length( outputs('get_existing_checklist_items')?['body/value'] )}</li>\n<li>Labels: @{length( outputs('get_existing_labels')?['body/value'] )}</li>\n</ul>"
          }
        ]
      }
    },
    "init_outcomeArray": {
      "runAfter": {
        "init_inactiveChecklist_array": [
          "Succeeded"
        ]
      },
      "metadata": {
        "operationMetadataId": "ac0964c2-d3e3-4baa-a5a7-d611751a2567"
      },
      "type": "InitializeVariable",
      "inputs": {
        "variables": [
          {
            "name": "outcomeArray",
            "type": "array"
          }
        ]
      }
    },
    "init_inactiveTasks_array": {
      "runAfter": {
        "if_weekday": [
          "Succeeded"
        ]
      },
      "metadata": {
        "operationMetadataId": "81057d90-262d-409e-87fc-5d3ddaf9d56f"
      },
      "type": "InitializeVariable",
      "inputs": {
        "variables": [
          {
            "name": "inactiveTasks",
            "type": "array"
          }
        ]
      }
    },
    "init_inactiveLabels_array": {
      "runAfter": {
        "init_inactiveAssignments_array": [
          "Succeeded"
        ]
      },
      "metadata": {
        "operationMetadataId": "2b6ede09-4521-4637-b8cd-559e7d298517"
      },
      "type": "InitializeVariable",
      "inputs": {
        "variables": [
          {
            "name": "inactiveLabels",
            "type": "array"
          }
        ]
      }
    },
    "init_inactiveAttachments_array": {
      "runAfter": {
        "init_inactiveTasks_array": [
          "Succeeded"
        ]
      },
      "metadata": {
        "operationMetadataId": "822732d7-f448-4df5-a865-e10ca2898905"
      },
      "type": "InitializeVariable",
      "inputs": {
        "variables": [
          {
            "name": "inactiveAttachments",
            "type": "array"
          }
        ]
      }
    },
    "init_inactiveAssignments_array": {
      "runAfter": {
        "init_inactiveAttachments_array": [
          "Succeeded"
        ]
      },
      "metadata": {
        "operationMetadataId": "0e5642fd-169e-4d2f-acc7-36fc12415e49"
      },
      "type": "InitializeVariable",
      "inputs": {
        "variables": [
          {
            "name": "inactiveAssignments",
            "type": "array"
          }
        ]
      }
    },
    "init_inactiveChecklist_array": {
      "runAfter": {
        "init_inactiveLabels_array": [
          "Succeeded"
        ]
      },
      "metadata": {
        "operationMetadataId": "5bb90e84-300c-4a53-a9c4-a2440bc7452c"
      },
      "type": "InitializeVariable",
      "inputs": {
        "variables": [
          {
            "name": "inactiveChecklist",
            "type": "array"
          }
        ]
      }
    },
    "HTTP": {
      "runAfter": {
        "array_payloads": [
          "Succeeded"
        ]
      },
      "metadata": {
        "operationMetadataId": "062aff9d-f992-4b7d-b23a-3bd6cdfc8ee1"
      },
      "type": "Http",
      "inputs": {
        "method": "POST",
        "uri": "@parameters('text_processFlowEndpoint (jake_test_postURL)')",
        "headers": {
          "Content-Type": "application/json"
        },
        "body": "@outputs('array_payloads')"
      },
      "operationOptions": "DisableAsyncPattern"
    },
    "http_response": {
      "runAfter": {
        "HTTP": [
          "Succeeded"
        ]
      },
      "metadata": {
        "operationMetadataId": "fbe15233-84cb-4618-91cb-c350236a79ec"
      },
      "type": "Compose",
      "inputs": "@{outputs('HTTP')['statusCode']}\n@{body('HTTP')}"
    },
    "End_Time_PST": {
      "runAfter": {
        "Plan_and_task_iteration": [
          "Succeeded",
          "Failed"
        ]
      },
      "metadata": {
        "operationMetadataId": "844d3531-4728-412e-855f-690ba1bd04f5"
      },
      "type": "Expression",
      "kind": "ConvertTimeZone",
      "inputs": {
        "baseTime": "@{utcNow()}",
        "formatString": "o",
        "sourceTimeZone": "UTC",
        "destinationTimeZone": "Pacific Standard Time"
      }
    },
    "compose_totals": {
      "runAfter": {
        "End_Time_PST": [
          "Succeeded"
        ]
      },
      "metadata": {
        "operationMetadataId": "33b358a6-a5d6-4f25-aef4-4714c2e8e736"
      },
      "type": "Compose",
      "inputs": "<h2>Gather Task Data</h2>\n<h3>@{length(\noutputs('get_active_plans')?['body/value']\n)} Plans</h3>\n<ul><li>Tasks: @{length(\n    variables('taskArray')\n)}</li></ul>\n<ul><li>Assignments: @{length(\n    variables('assignmentArray')\n)}</li></ul>\n<ul><li>Attachments: @{length(\n    variables('attachmentArray')\n)}</li></ul>\n<ul><li>Checklist items: @{length(\n    variables('checklistArray')\n)}</li></ul>\n<ul><li>Labels: @{length(variables('labelArray'))}</li></ul>\n\n<h3>ERROR COUNT</h3>\n<p>@{variables('errorCount')}</p>\n\n<h3>DEBUG LOG</h3>\n<p>@{variables('errorString')}</p>"
    },
    "array_payloads": {
      "runAfter": {
        "compose_totals": [
          "Succeeded"
        ]
      },
      "metadata": {
        "operationMetadataId": "b459749d-99fd-45a0-90b5-91fa046a813a"
      },
      "type": "Compose",
      "inputs": {
        "parentFlowDuration": "@div(sub(ticks(body('End_Time_PST')), ticks(body('Start_time_PST'))), 600000000)",
        "parentFlowMessage": "@{outputs('compose_totals')}",
        "payloads": [
          {
            "contentType": "task",
            "values": {
              "arraySQL": "@outputs('get_existing_tasks')?['body/value']",
              "arrayCurrent": "@variables('taskArray')"
            }
          },
          {
            "contentType": "checklist",
            "values": {
              "arraySQL": "@outputs('get_existing_checklist_items')?['body/value']",
              "arrayCurrent": "@variables('checklistArray')"
            }
          },
          {
            "contentType": "label",
            "values": {
              "arraySQL": "@outputs('get_existing_labels')?['body/value']",
              "arrayCurrent": "@variables('labelArray')"
            }
          },
          {
            "contentType": "attachment",
            "values": {
              "arraySQL": "@outputs('get_existing_attachments')?['body/value']",
              "arrayCurrent": "@variables('attachmentArray')"
            }
          },
          {
            "contentType": "assignment",
            "values": {
              "arraySQL": "@outputs('get_existing_assignments')?['body/value']",
              "arrayCurrent": "@variables('assignmentArray')"
            }
          }
        ]
      }
    },
    "log_outcome": {
      "runAfter": {
        "http_response": [
          "Succeeded"
        ]
      },
      "metadata": {
        "operationMetadataId": "57d990aa-2533-4875-a43a-032328619dca"
      },
      "type": "OpenApiConnection",
      "inputs": {
        "host": {
          "connectionName": "shared_sql",
          "operationId": "PostItem_V2",
          "apiId": "/providers/Microsoft.PowerApps/apis/shared_sql"
        },
        "parameters": {
          "server": "***SCRUBBED***",
          "database": "***SCRUBBED***",
          "table": "***SCRUBBED***",
          "item/workflowType": "taskRetrieve",
          "item/outcome": "@if(\r\n    greater(\r\n        variables('errorCount'),\r\n        0\r\n    ),\r\n    'Complete with Error',\r\n    'Success'\r\n)",
          "item/itemCount": "@add(\r\n    add(\r\n        length(variables('assignmentArray')),\r\n        length(variables('checklistArray'))\r\n    ),\r\n    add(\r\n        add(\r\n            length(variables('labelArray')),\r\n            length(outputs('get_active_plans')?['body/value'])\r\n        ),\r\n        add(\r\n            length(variables('taskArray')),\r\n            length(variables('attachmentArray'))\r\n        )\r\n    )\r\n)",
          "item/errorCount": "@variables('errorCount')",
          "item/details": "Start: @{body('Start_time_PST')} | Runtime: @{div(\r\n    sub(\r\n        ticks(body('End_Time_PST')),\r\n        ticks(body('Start_time_PST'))\r\n    ),\r\n    600000000\r\n)\r\n\r\n} minutes\n@{length(outputs('get_active_plans')?['body/value'])} pln | @{length(variables('assignmentArray'))} asn | @{length(variables('attachmentArray'))} atc | @{length(variables('checklistArray'))} chk | @{length(variables('labelArray'))} lbl | @{length(variables('taskArray'))}tsk@{variables('errorString')}",
          "item/startTime": "@body('Start_time_PST')"
        },
        "authentication": "@parameters('$authentication')"
      }
    },
    "if_weekday": {
      "actions": {},
      "runAfter": {
        "Start_time_PST": [
          "Succeeded"
        ]
      },
      "else": {
        "actions": {
          "Terminate": {
            "runAfter": {},
            "metadata": {
              "operationMetadataId": "2309e5bb-9878-4721-8a1b-273d5e86b574"
            },
            "type": "Terminate",
            "inputs": {
              "runStatus": "Cancelled"
            }
          }
        }
      },
      "expression": {
        "and": [
          {
            "less": [
              "@dayOfWeek(body('Start_time_PST'))",
              6
            ]
          },
          {
            "greater": [
              "@dayOfWeek(body('Start_time_PST'))",
              0
            ]
          }
        ]
      },
      "metadata": {
        "operationMetadataId": "9fafc0e2-9c45-40f1-b824-ee5cf3561784"
      },
      "type": "If"
    }
  },
  "description": "Fetches all active plans and enumerates tasks, assignments, checklists, assignees, and labels. Aggregates those data points and gets them into Azure SQL."
}

The availability of environment variables within Power Platform solutions is an exciting piece of tech. But like most developing features and platforms, there are some rough edges and pitfalls to be aware of.

Our recent push to a more mature ALM model for custom solutions exposed some of those rough edges, so I sought to help clarify and document some guidelines and tips - for my own sanity and yours!

It's easy to get started with environment variables. It's enticingly easy to create them within a solution or environment. Your apps and flows create them automatically, too - just like connections. If you're like me, you'll be absolutely SWIMMING in variables before long - many of them duplicative, redundant or unused.

The Untangling Process

Connections

I started with the environment connections - sort of the lowest common denominator in solution config. Power Platform loves to create these on the fly, leaving you with tons of duplicates and no viable way to rename or organize them. (Side note: I used to have luck renaming connections by editing the JSON source with Flow Studio, but I think Microsoft has locked that particular backdoor)

You can quickly see if a connection is being used by accessing the details pane, and checking the app and flow panes. Not being used? Delete it!

But what if you have duplicate connections and they're being used? You can either live with the mess, or clean it up. Living with the mess is a viable option - redundant connections are not as detrimental to a deployment as extra environment variables.

Since this was a DEV environment, I made the decision to try and pare everything down to just ONE connection for each connector type. I knew this would cause rework, but I'd be tinkering with the apps and flows later, giving me the chance to wire everything back up again.

Once I was done, I was left with a clean and tidy set of connections. I really should have taken a "before" picture when this list was five times longer (easily) with duplicates galore.

Doing this prework will ensure you have one SharePoint connection, one SQL connection, etc. for use within connection references and the environment variables we'll be sorting out next.

Environment Variables

A fair amount of trial and error led me to the following observations. Microsoft may smooth this experience out in the future, but I believe these findings are accurate at the time of this posting:

1. Data source variables created in an app can be used elsewhere in a solution (within flows, e.g.)

2. Data source variables created in a flow cannot be used in an app within the same solution

3. Data source variables created in a solution cannot be used in apps, but can be used within flows

The conclusion here is obvious - let the app(s) within your solution create your site and list variables when working with the SharePoint connector. Don't create them within the solution itself or within Automate.

If you've already got a tangled mess of environment variables in your solution, and aren't sure which ones were created from PowerApps, you'll probably want a fresh start. Append something like "DELETEME" to the preexisting variables within your solution.

Before deleting the old mess, however, we'll want to create clean, permanent variables - our "keepers." To get started, open your app, remove your SharePoint data sources, and take a deep breath as you watch countless error warnings cascade across your screen.

When you re-add your data sources to the app, the Advanced tab will not work. Don't despair. Paste in the site URL and the app will create variables on the next step within the pane - one for the site, and one for each list.

Note: If your app doesn't seem to be creating variables for you automatically, check Settings -> General -> Automatically create environment variables when adding data sources

Once those variables are created, back out of the app, find them within your solution, and give them friendly titles. I found it helpful to use a convention like:

type_VarName

Delete any site/list variables created via other methods (manually, or via Automate) - if you marked them earlier, this step will be easy. Sometimes deleting one will cause several to disappear at once, because you're kneecapping dependencies. Be careful not to delete the variables you just created.

Rewiring Flows

Go back into your flows, and remap any Site and List values. You must X out the current values and work methodically for this to work correctly. A tip from a colleague: let the list names resolve after you add the site variable, to ensure the method is working.

Your flow should save without errors. If you have errors, go back, and make doubly sure you clear the existing site and list values before adding your app-created environment variables.

Other Recommendations

If you have environment variables floating around, outside of your custom solution(s), you can find them in the Default Solution in your development environment:

You'll probably want to clean this up too, while you're at it. Be careful not to delete anything you want to keep!

Conclusion

When you're finished, you should have an ultra clean and easy-to-understand, minimalist set of environment variables. This will make solution development, packaging and deployment much easier!

I went from 12 environment variables down to 3, by following the steps and guidelines outlined above.

It's worth mentioning, this is a loose approach. Your situation may vary. And these guidelines really only apply to SharePoint Online environment variables. Once Microsoft extends data source environment variables to other connector types, the experience may get smoothed out and the information in this article will be outdated. Only time will tell. 😀

This is not a perfect pattern! What I outline here is not enterprise-grade by any means. The whole thing would fall on its face, if scaled. 😀

I approached this problem (and corresponding solution) as a low-risk, thought exercise.

The Problem

A few weeks ago, one of our data engineers approached me with an issue: a vendor that handles a bit of customer outreach for the company will only return results to us in an HTML table, emailed weekly. There's no API to hit, no CSV we can grab. Nothing!

How do we get that tabular information into a database so we can report on it?

Thinking Through It

Sending HTML tables via email is a decent way to enable folks to quickly view data, but it's a terrible way to share data. There's no direct path to ingest it, and all of the information is wrapped in heavy layers of HTML - both the table structure itself and the surrounding message body.

What makes this tricky is that every scenario is unique. Your "how do I get tabular data out of an email body" problem is almost certainly different from this one. Table structures vary, different systems generate message bodies in different ways, some inject a ton of HTML "junk" and some don't.

Our table contained 93 rows of data - not very much. Those 93 rows of data, however, were wrapped inside 47 nested tables comprising 48,000 lines of HTML ... yikes!

Solutioning with Power Automate

While there's no one-size-fits-all approach to solving this, there are some proven methods we can employ!

1. I started by bringing the email message body into a htmlConversion action:

☝ Don't be fooled by Automate's award-winning UI... there's a value in there!

2. The original HTML goes in, and something resembling plaintext comes out after the HTML structure and syntax gets stripped out:

3. I used a "landmark" method next, finding a reliable chunk of text, in a fixed position near the start and end of the table. Using a subString expression with two Compose actions allowed me to isolate the table:

substring(
    body('htmlConversion'),
    add(
        indexOf(
            body('htmlConversion'),
            'Reviewer_Job_Title'
            ),
        20)
)

The second substring expression is quite similar. You find your landmark, then walk n number of characters forward or backward from there.

4. I borrowed this next method after some web searching yield a great article on the subject.

Now that we have the table values isolated in plaintext, we can split them into an array.

The expression inside is a bit tricky. Let's walk through it, starting from the inside out:

split(
    trim(
        replace(
            uriComponent(
                    outputs('trimEnd')
                        ),
                '%0A',
                '~~'
                )
            ),
    '~~')

1. Take the trimmed plaintext...

2. Encode it

3. Replace the linebreaks with an arbitrary string ("~~")

4. Split the entire thing into an array, using the arbitrary string

5. We're almost there! The next step is to dump any empty nodes from the array, like this:

6. After that, we're pretty much home free. We can iterate over the array, and record the data wherever we like (SQL, SharePoint, etc.). I used SharePoint in this example.

The method I employed is a bit flaky - but it works. Since I knew the table had 17 columns, I looped through the primary array until I had a complete row, creating a temporary array in the process. Once my counter hit 17, I cleared the temporary array and reset the sub counter. Rinse, repeat, until the whole thing is processed.

You will want to unencode the values, as you create your temporary array:

uriComponentToString(items('Apply_to_each'))

What Are the Weak Points? How Could We Improve This Method?

1. Creating an object for each row, instead of manually mapping array position. Would be more elegant, but not really needed in this case.

2. Relying on “landmarks” in the HTML is really flaky. If the vendor changes anything in their email format, even something trivial like their logo, this solution may stop working.

3. Looping a fixed number of times only works if table columns are consistent

4. The flow runs very slow due to serial concurrency. About 12 minutes to process 93 rows of data. Solution not scalable.

Final Flow

Major updates to Roadmap items are communicated via email and within each tenant's Message Center. But the Roadmap is vast - not every update warrants direct communication. Items change all the time without notification.

So how do we detect changes to the Roadmap items for which we are acutely interested? If you're eagerly awaiting a new feature, for example, how will you know if the release date gets pushed out?

Option One - Check the Roadmap every day

Nobody has time for that!

Additionally, how would you know definitively that what you're looking at today is different than what you saw yesterday?

Option Two - Subscribe to an item's RSS feed

Every item on the Roadmap has an RSS link. You could subscribe to the items you care about, and monitor for developments.

However, not everyone uses RSS readers - let alone on a frequent basis, so it might be difficult to detect changes this way.

Option Three - Poll the RSS feed at in interval with Power Automate

1) Create a scheduled, recurring flow using Power Automate

I chose to query the Roadmap weekly - every Wednesday.

2) Copy the RSS feed url from the Roadmap item you wish to track, and paste it within Automate's RSS action

3) Store the RSS output in a new object variable

Use an expression to isolate the first return object:

first(outputs('Feed')?['body'])

4) Use the Get Past Time action to bracket your time range. You'll want this to be greater than or equal to your flow recurrence schedule.

5) Use a Condition to determine if the Roadmap item has been updated within this timeframe

You'll need to grab the updatedOn value from the RSS object using a simple expression:

variables('varObject')['updatedOn']

6) If the Roadmap item was updated within the last 10 days, you can have Automate send an email to your team, notify people via Teams - the choice is yours! If the Roadmap item hasn't been updated recently, the flow simply terminates and tries again the following week.

I went the simplest route, and had Automate email my team with a link back to the original Roadmap item we were interested in:

How it Works

The Power Automate method is possible thanks to the values returned inside the RSS output. When a Roadmap item is touched, the updatedOn value is refreshed automatically. Even the smallest changes to Roadmap items will trigger a refreshed updatedOn value. We've been using this flow method for about a year now and have found it quite reliable.

How Could This Method Be Improved?

This method doesn't tell you what changed, specifically - only that something changed. Since we only use this for Roadmap items we are keenly interested in, it's usually pretty obvious what's changed, once we get the notification and take a look. And, it's almost always release dates. 😁

The RSS output doesn't contain all the information found within each Roadmap item, either. You won't see General Availability dates, release phase information, or tenant type specifics. If we had that information, we could do some cool change data capture and really drill down into the exact nature of each update. But for our use case, the method outlined here is more than enough.

The Flow

Here is the whole thing put together: