Flow: Approval reminders

For a complicated review process a customer required that users receive reminders on their approval tasks. In most cases you will need a reminder for tasks, but flow approval tasks (at the writing of this blog) don’t have a default reminder setting.

Microsoft has stated that this will become a default feature, but it is unknown when it will be released. So for now you can use the Following solution.

The solution consist of two flows, a flow that is responsible for the overall process and one flow for the reminders.

Reminder flow being started

First we will need to create the reminder flow. This is required because we will need the HTTP POST URL of the reminder flow in the process flow to be able to starts the reminder Flow.

  • Create a flow with the trigger: When a HTTP request is received.
  • Open the trigger action, the generated HTTP POST URL will be used in the other flow.
  • Set the Request Body JSON Schema to be able to receive an id value.
    {     "Type": "object",     "properties": {         "id": {             "type": "string"         }     },     "required": [         "id"     ] } 
  • Add the action Parse JSON.
  • Set the output of the trigger called body as the content (input) for the Parse JSON action.
  • Set the following schema.
    {     "type": "object",     "properties": {         "id": {             "type": "string"         }     } } 
  • Add the delay action and set the timer.
  • Add the Get Item (by ID).
  • Set the action Get Item (by ID) to use the ID generated in the parse JSON action.
  • Now you can add all the required actions and manipulations you need to do on the item.
  • In my flow I check if the SP Document status, if the status is not reviewed a reminder is send, if reviewed nothing happens.

Process flow – starts reminder flow

When you start a flow on an item you will need to tell the flow on which item to start. In my example I am using a fixed id. In most cases you will need to create a more dynamic solution.

  • Create a flow that starts with your preferred trigger.
  • Add a parallel action.
  • Add the HTTP action to the flow to branch.
  • Set the method to POST.
  • Set the URI, copy it from the trigger of the flow that is being started.
  • Set the Body.
    {   "id": "60" } 
  • Add the start and wait for approval to the other branch.
  • If the approval is done I set the property SP Document status to reviewed, this way no reminder will be send.

Flow: Button Flow with user input

Button Flows are great for repetitive tasks that that can run with just a push of a button. But also, to gather information for the users that starts the button Flow. This is a less known feature but very useful!

The Flow

  • Create a Flow with the manual trigger (Flow button).
  • Click on add an input, you can add various types of input.
  • When the Flow starts the user can provide the required input.
  • Click on the … of an input field to make it optional or required.
  • An input text field can also be modified to be a drop-down list or a multi-select list.

Flow: Set permissions using REST API without app permissions

In my last blog post Flow: Set permissions using REST API, I explained how to use the HTTP action and the app permissions. With the HTTP action you can start web services from SharePoint but also from other solutions.
In this blog post I will explain an easier way of using the SharePoint REST API. This setup does not require setting the app permissions. We can simply use the action Send an HTTP request to SharePoint.

Creating the Flow

  • First, we will break the inheritance.
  • Create a Flow with the required trigger.
  • Add the Initialize variable.
  • Rename it to Initialize variable – User Principle ID.
  • Set the name to User Principle ID.
  • Set the type to String.
  • Add the Send an HTTP request to SharePoint action.
  • Change the name to Send an HTTP request to SharePoint – Break inheritance.
  • Select or set the correct Site Address.
  • Set the Methode to POST.
  • The URI is different for every item/list you want to manipulate.
  • _api/lists/getbytitle(‘<list display name>’)/items(<ITEM ID>)/breakroleinheritance(true)
  • Set the Headers as follows.
  • The key is Accept
  • The value is application/json;odata=verbose
  • Now we will look up the user’s information.
  • Add the Send an HTTP request to SharePoint action.
  • Change the name to Send an HTTP request to SharePoint – Get User Info.
  • Select or set the correct Site Address.
  • Set the Methode to GET
  • The URI is different for every item/list you want to manipulate.
    _api/web/siteusers/getbyemail(‘<email address>’)
  • Set the Headers as follows.
  • The key is Accept
  • The value is application/json;odata=verbose
  • Add the Parse JSON action.
  • Set the Content to Body (the result of the Get User info action).
  • Change the name to Parse JSON – Get User Principal ID.
  • Use the following Schema to parse the JSON. This will give you more than you will not for this example. I add this Schema, so you have access to more information if required.
{
    "type": "object",
    "properties": {
        "d": {
            "type": "object",
            "properties": {
                "Alerts": {
                    "type": "object",
                    "properties": {
                        "__deferred": {
                            "type": "object",
                            "properties": {
                                "uri": {
                                    "type": "string"
                                }
                            }
                        }
                    }
                },
                "Groups": {
                    "type": "object",
                    "properties": {
                        "__deferred": {
                            "type": "object",
                            "properties": {
                                "uri": {
                                    "type": "string"
                                }
                            }
                        }
                    }
                },
                "Id": {
                    "type": "integer"
                },
                "IsHiddenInUI": {
                    "type": "boolean"
                },
                "LoginName": {
                    "type": "string"
                },
                "Title": {
                    "type": "string"
                },
                "PrincipalType": {
                    "type": "integer"
                },
                "Email": {
                    "type": "string"
                },
                "Expiration": {
                    "type": "string"
                },
                "IsEmailAuthenticationGuestUser": {
                    "type": "boolean"
                },
                "IsShareByEmailGuestUser": {
                    "type": "boolean"
                },
                "IsSiteAdmin": {
                    "type": "boolean"
                },
                "UserId": {
                    "type": "object",
                    "properties": {
                        "__metadata": {
                            "type": "object",
                            "properties": {
                                "type": {
                                    "type": "string"
                                }
                            }
                        },
                        "NameId": {
                            "type": "string"
                        },
                        "NameIdIssuer": {
                            "type": "string"
                        }
                    }
                },
                "UserPrincipalName": {
                    "type": "string"
                }
            }
        }
    }
}
  • Add the Set variable action.
  • Change the name to Set variable – User Principle ID.
  • Select by name the variable User Principle ID.
  • Set the value to ID (the ID output from Parse JSON – Get User Principal ID)
  • Now we will grant a user permissions, I am granting the challenger (property of the item) contribution access.
  • Add the Send an HTTP request to SharePoint action.
  • Change the name to Send an HTTP request to SharePoint – Grant Contribute permissions.
  • Select or set the correct Site Address.
  • Set the Methode to POST.
  • The URI is different for every item/list you want to change.
    <site url>/_api/lists/getbytitle(‘<list display name>’)/items(<ITEM ID>)//roleassignments/addroleassignment(principalid='<d.ID>’roleDefId=1073741827)
  • The id 1073741827 stands for contributor, in my blog post SharePoint: Get the Role ID you can read more about role id’s.
  • Your Flow will now look like this.

Flow: Set permissions using REST API

For a customer I am creating Microsoft Flows to support various business processes. One Flow controls the process of reviewing and approving vital business documents. These documents are so important that during the day to day business the reviewers and approvers are unable to edit these documents. Only when the documents are in review a select few are allowed to edit them.

Microsoft Flow contains many default actions for all sorts of tasks, but
during the writing of this blog post there is no default action that can set permissions or break the inheritance.

In this blog post I will explain how set custom permissions, break the inheritance and restore the inheritance using the REST API.

Register app and grant app permissions

For the Flow to work we will need to Register an App and grant it permissions. During the registration of the App we will receive various id’s we will use in the Flow.

  • Navigate to the app registration page on the SharePoint site.
https://<tenant>.sharepoint.com/_layouts/15/appregnew.aspx
  • Generate a Client ID and Client Secret.
  • Set the Title to Flow Web Service
  • Set App Domain to www.localhost.com
  • Set Redirect URI to https://www.localhost.com
  • Save the generated Client Id and Client Secret.
  • Navigate to the Grant permissions to an app page. This must be done by browsing to the appinv.aspx page of the site.
http://<hostname>/<the Site Collection>/_layouts/15/appinv.aspx
  • Fill in the Client Id and click on Lookup
  • Now we will grant the App full control access to the site collection.
  • Set the following XML as the Permission Request XML
<AppPermissionRequests>
    <AppPermissionRequest Scope="http://sharepoint/content/sitecollection/web" Right="FullControl" />
</AppPermissionRequests>
  • Click on Create.
  • A pop-up screen will appear asking to Trust the App, click on Trust It.
  • The App has been granted permissions and can be used in the Flow.

Creating the Flow

  • Create a Flow with the required trigger.
  • Add two initialize variable actions for the Token type and Access token.
  • Add the HTTP action to acquire the access token and type.
  • Set the name to HTTP – Request access token and type
  • Set the Method to POST.
  • The URI is different for every tenant, you will need to your tenant id.
  • https://accounts.accesscontrol.windows.net/<tenant ID>/tokens/OAuth/2
  • Set the Headers as follows.
  • The key is Content-Type
  • The value is application/x-www-form-urlencoded
  • For the body you will need the tenant ID, client_credentials, client_id and client_secret.
  • grant_type=client_credentials&client_id=
    <Client ID>@<Tenant ID&client_secret=<Encoded Client Secret>&resource=00000003-0000-0ff1-ce00-000000000000/<tenant>.sharepoint.com@<Tenant ID>
  • Add a Parse JSON action.
  • Set the content to the BODY (result) of the HTTP – Request access token and type action.
  • Use the following Schema to parse the JSON.
{
    "type": "object",
    "properties": {
        "token_type": {
            "type": "string"
        },
        "access_token": {
            "type": "string"
        }
    }
}
  • Set the variable Token type and Access token using the results of the parsed JSON.
  • Now you can break the inheritance, add a HTTP action.
  • Set the name to HTTP – break inheritance.
  • Set the Method to POST.
  • The URI is different for every item/list you want to change.
  • <site url>/_api/lists/getbytitle(‘<list display name>’)/items(<ITEM ID>)/breakroleinheritance(true)
  • Set the Headers as follows.
  • The key is Authorization
  • The value is the Token type and Access token variable. Make sure to add a space between the variables.
  • The key is Accept
  • The value is application/json;odata=verbose
  • Now you can grant an user permissions, I am granting the challenger (property of the item) contribution access.
  • Add a HTTP action, with this action we will get the users information.
  • Set the name to HTTP – Get User info
  • Set the Method to GET
  • The URI is different for every location where you want to get the information from.
    <site url>/ _api/web/siteusers/getbyemail(‘<Challengers email>’)
  • Set the same Headers as before.
  • Add the Parse JSON action, name is Parse JSON – Get User Principal ID
  • Set the content to the BODY (result) of the
    HTTP – Get User info action
  • Add the following Schema to the Use sample payload to generate the schema option.
  • Make sure to enter your own account details.
{
  "d": {
    "results": [
      {
        "Id": 9,
        "LoginName": "i:0#.f|membership|<youraccount>",
        "Title": "<your name>",
        "PrincipalType": 1,
        "Email": "<youremail>",
        "IsSiteAdmin": true
      },
      {
        "Id": 14,
        "LoginName": "i:0#.f|membership|<youraccount>",
        "Title": "Example Title",
        "PrincipalType": 1,
        "Email": "<youremail>",
        "IsSiteAdmin": false
      }
  
    ]
  }
}
  • Add a HTTP action, set the name to HTTP – Grant contribute permissions
  • Set the Method to POST
  • The URI is different for every item/list you want to change.
    <site url>/_api/lists/getbytitle(‘<list display name>’)/items(<ITEM ID>)//roleassignments/addroleassignment(principalid='<d.ID>’roleDefId=1073741827)
  • The id 1073741827 stands for contributor, in my blog post SharePoint: Get the Role ID you can read more about role id’s.
  • Set the same Headers as before.
  • Now you can reset the inheritance if needed, add a HTTP action
  • Set the name to HTTP – Reset Role Inheritance
  • Set the Method to POST
  • The URI is different for every item/list you want to change.
    <site url>/_api/lists/getbytitle(‘<list display name>’)/items(<ITEM ID>)/resetroleinheritance
  • Set the same Headers as before.
  • Your Flow will now look like this.

Office 365: What’s new

In the last several weeks there where a lot of Office 365 announcements. To many to mention all but these are my favorites ones.

Whiteboard in Teams

Microsoft Whiteboard is now available as a commercial preview in Teams! You will be able to create and share a digital whiteboard with everybody in the meeting. Ink beautification is my favorite feature, this will analyzes my hard to read handwriting and changes it into readable text.



Multi-Geo in SharePoint and Office 365 Groups

Multi-Geo Capabilities in SharePoint Online and Office 365 Groups is no longer in preview but available for everybody. Multi-Geo in SharePoint and Groups enables global businesses control the country or region where shared resources like SharePoint Team Sites, Office 365 Groups content (associated SharePoint Sites and Groups mailboxes) are stored at-rest.

SharePoint News

The news features of SharePoint is upgraded with new capabilities to further empower the news experience. My favorite feature is the Authoritative news, this will make sure that news from a authoritative or official source will always be displayed on the SharePoint home in Office 365 and on the news tab in SharePoint mobile.



Yammer tab in Microsoft Teams

Yammer can now be added as a tab in Teams! A specified group or topic feed from Yammer will be displayed on the tab.



Copy a plan in Planner

Create a a new plan by duplication an existing one, quick and easy.

Flow: Performance issue

In my previous blog post Flow: Start a flow with another flow I talked about a flow that was becoming very big and slow. In this blog post I will explain why the Flow was very slow and how you can prevent this from happening.

The purpose of the Flow was to convert a complete SharePoint List into a comma separated Excel file. This was not a simple extract but also various data manipulations and user profile data request where required. The Flow ended up with a large number of for each loops and unique variables.

Reason 1: Too many of the action Initialize variable

The Flow contained too many unique variables. I noticesd hat there was a steep incline in the overall processing time when I added more and more unique variables. It started to become slow after about 12 variables. Try too avoid to many unique variables.

Reason 2: Nested for each loops

The Flow also contained too many nested Apply to each actions. This slowed down the Flow but much less than the unique variables. Try too avoid nested loops.