Garry Trinder

My top three Microsoft 365 sessions at Microsoft Inspire 2022

2022-07-18T00:00:00+00:00

Microsoft Inspire 2022, the annual partner conference takes place virtually between 19-20 July.

Here are three sessions that caught my eye whilst looking through the session schedule that I think will be of interest to those who are already, or are thinking about, building solutions on the Microsoft 365 platform.

1️⃣ 🧘 Bring all your essential apps, tools, and processes into the flow of work

🗣 Navjot Khalsa

The Collaborative Apps solution play will help customers improve the flow of work with integrated Teams apps built by Microsoft, ISVs, and SI partners or built by their own organization—all in one place.

2️⃣ 💰 Create New Revenue Streams with Teams apps

🗣 Alvaro Celis and Gloria Sánchez

Customers are evolving to hybrid models quickly where Teams is the new front-end for hybrid work. With over 270M monthly active users, Teams offers the biggest opportunity for partners to reach new audiences and segments globally. Join us to learn the business opportunities that Modern Work offers and hear best practices from other partners. The Teams platform can help both your business and your customer’s business thrive.

3️⃣ 🎓 Viva Learning APIs public preview: How to leverage these connectors

🗣 Andrea Lum, Divyanka Malik & Malabika Roy

Viva Learning Content Sync APIs are now available in public preview. In this session we’ll review what the APIs are, how they work, and what’s next for Viva Learning extensibility. We’ll also discuss how to utilize these APIs to onboard more customers to Viva Learning, as well as partnership and monetization opportunities for Systems Integrators and Learning Solution providers.

Have you registered?

What sessions are you looking forward to?

Run Github Actions locally using act

2022-05-02T00:00:00+00:00

I recently worked on refactoring the CLI for Microsoft 365 Login GitHub Action and one of the issues I came across during the development was being able to get fast feedback on the changes I had made.

The only way I could test the changes was to commit my changes, push them to GitHub and manually trigger the workflow.

Thankfully, nektos\act, is a command line tool that helps emulate the GitHub Actions environment locally using Docker,enabling you to trigger workflows without having to push to GitHub first.

As act relies on Docker, you will need this installed before installing it. You can install act using package managers such as homebrew or chocolatey, or via an installer which you can find on the latest releasepage.

Once installed, you can trigger a workflow by executing act at the command line.

To test the Login action locally, I created the following test.yml file in the .github/workflows directory.

The workflow uses the workflow_dispatch event which is a manual trigger, it defines a single job that runs on the latest version of Ubuntu and has two steps, the first to checkout the local repository making the files available to the workflow runner and the second which executes the local version of our action denoted by uses: ./. The login step uses two GitHub Secrets which as passed as values into the ADMIN_USERNAME AND ADMIN_PASSWORD options.

To execute this workflow locally, we run…

act workflow_dispatch -s ADMIN_USERNAME=username -s ADMIN_PASSWORD=password

Where workflow_dispatch is passed as the tigger type (default is push) and pass two values as GitHub Secrets using the -s option.

As we can see, we can now easily run our actions locally using act, and we can benefit from a much faster feedback loop 🚀

Get verified! Setup git commit signing on Windows

2021-09-01T00:00:00+00:00

When you work locally on your computer, git allows you to set the name and email address of the author to anything you wish. This, potentially, makes it difficult for other people to be confident that commits you create were actually created by you when you push your commits to a public repository on GitHub.

To help solve this problem you can configure git to sign your commits. When you sign commits locally and push them to GitHub, your commits can be verified by GitHub as coming from a trusted source, marking them as Verified and stamped with a green tick ✅.

This guide will step through the process of how to configure commit signing in your local git repositories in Windows and how to configure GitHub to show your commits as verified.

This guide requires that you have at least git for Windows v2.19.1 installed, as after this release, git was bundled with a program called gpg.

The GNU Privacy Guard commonly know as gpg, is a command line tool that we will use to generate a key on your local machine, which will be used to sign your git commits with.

Verify that GPG is in PATH

To ensure that you can use gpg in a shell other than git bash where it is auto-loaded for you, you should add the C:\Program Files\Git\usr\bin to your system environment variables, which is the location of where the gpg command line tool is installed with git.

To verify that gpg is in your PATH, execute gpg --version in either a command shell or PowerShell session.

Generate GPG key

To generate a GPG key, execute gpg --full-generate-key.

This will start an interactive wizard where you will be prompted to confirm several details, the first choice you will need to make is to select the type of key you want.

gpg --full-generate-key

gpg (GnuPG) 2.2.29-unknown; Copyright (C) 2021 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Please select what kind of key you want:
   (1) RSA and RSA (default)
   (2) DSA and Elgamal
   (3) DSA (sign only)
   (4) RSA (sign only)
  (14) Existing key from card
Your selection?

For ease here, I would recommend accepting the default option, RSA and RSA, confirm by hitting return.

The next choice is to confirm the keysize you want to use.

RSA keys may be between 1024 and 4096 bits long.
What keysize do you want? (3072)

Again for ease here, I would recommend accepting the default key size, 3072, confirm by hitting return.

We are next asked the set the lifetime of the key, in either days, weeks, months, years or set it to not expire.

Please specify how long the key should be valid.
         0 = key does not expire
      <n>  = key expires in n days
      <n>w = key expires in n weeks
      <n>m = key expires in n months
      <n>y = key expires in n years
Key is valid for? (0)

The choice here is entirely upto you, however I would recommend setting an expiry date rather than accepting the default which does not apply an expiry date.

I opted for setting the key to expire in 1 year from now, so enter 1y and confirm by hitting return.

You will be asked to confirm the expiry date.

Key expires at Tue Aug 30 17:19:20 2022 GMTST
Is this correct? (y/N)

I would recommend that if you have opted to set an expiry date on your key then take this opportunity to set a reminder in your calendar a week before the date shown so you can recycle your keys in good time.

Confirm that the date is correct by entering y and confirm by hitting return.

Now we need to provide our identity, which will be used as part of the key.

Enter your name in the real name section and confirm by hitting return, then enter the email address associated with your GitHub account again confirming by hitting return.

If you don’t want to use your personal email address, you can also use a GitHub @users.noreply.github.com email address, if you have this configured in your GitHub profile

Finally, you will be also asked for a comment, whilst this is optional and can be left blank, you may want to add GitHub here as the comment. Adding a comment here will help distinguish between different keys that you may create in the future for other services that use the same identity.

Real name: Megan Bowen
Email address: meganb@contoso.com
Comment: GitHub
You selected this USER-ID:
    "Megan Bowen (GitHub) <meganb@contoso.com>"

Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit?

Confirm the generated USER-ID by entering O and hitting return.

You will now be prompted by a Windows dialog box from an application called pinentry to enter a passphrase. The passphrase is used to encrypt the key, this makes the actual key itself useless to an attacker as the passphrase entered at this stage will be required to use it.

Enter your passphrase, click OK and re-confirm the passphrase by entering it again and clicking OK.

It is possible to skip the passphrase by entering nothing into the passphrase field however it is strongly recommended that you enter a strong passphrase. For this step, I used a password generator and stored the passphrase safely in my password manager for future use.

Export your key

After completing the key generation wizard, you will be presented with an output in the command line describing the key you just created.

We need to generate a lot of random bytes. It is a good idea to perform some other action (type on the keyboard, move the mouse, utilize the disks) during the prime generation; this gives the random number generator a better chance to gain enough entropy.
We need to generate a lot of random bytes. It is a good idea to perform some other action (type on the keyboard, move the mouse, utilize the disks) during the prime generation; this gives the random number generator a better chance to gain enough entropy.
gpg: key 9910FD82B391958B marked as ultimately trusted
gpg: revocation certificate stored as '/c/Users/meganb/.gnupg/openpgp-revocs.d/93154FC4A7100D0C2C9455689910FD82B391958B.rev'
public and secret key created and signed.

pub   rsa3072 2021-08-31 [SC] [expires: 2022-08-31]
      93154FC4A7100D0C2C9455689910FD82B391958B
uid                      Megan Bowen (GitHub) <meganb@contoso.com>
sub   rsa3072 2021-08-31 [E] [expires: 2022-08-31]

The information in the final section displays the key type and size (rsa3072), expiry date (2022-08-31), public key (93154FC4A7100D0C2C9455689910FD82B391958B) and the USER-ID associated with the key (Megan Bowen (GitHub) <meganb@contoso.com>).

Now that we have created our key, we need to obtain the ID of the key we want to use, to do that we list the keys in the long form format by executing gpg --list-secret-keys --keyid-format=long.

gpg --list-secret-keys --keyid-format=long

gpg: checking the trustdb
gpg: marginals needed: 3  completes needed: 1  trust model: pgp
gpg: depth: 0  valid:   2  signed:   0  trust: 0-, 0q, 0n, 0m, 0f, 2u
gpg: next trustdb check due at 2022-08-27
/c/Users/meganb/.gnupg/pubring.kbx
-----------------------------------------------
sec   rsa3072/9910FD82B391958B 2021-08-31 [SC] [expires: 2022-08-31]
      93154FC4A7100D0C2C9455689910FD82B391958B
uid                 [ultimate] Megan Bowen (GitHub) <meganb@contoso.com>
ssb   rsa3072/DCDCD9E5E414740A 2021-08-31 [E] [expires: 2022-08-31]

The ID of the key above is 9910FD82B391958B, we can use this ID to export the public key which we will use to associated the key we just generated with our GitHub account.

To export the public key, execute gpg --armor --export 9910FD82B391958B.

gpg --armor --export 9910FD82B391958B

-----BEGIN PGP PUBLIC KEY BLOCK-----

mQGNBGEtvXQBDADI1Oratk9LGixH2TN37AGx0yaB5oL0AYSJG2u7uOguDtBemVZo
LlZvNtWpgDqqyRAd81yw7ren30GFbWw2pAOwl2UYL6qTy5eulGzUN5Hse1x6NJK5
...
...
...
i3oT4HsHiwrXXk6Ajw9fotO7Zhx2h2Utqv8c+QypueTpVRcRNk/s
=2BN3
-----END PGP PUBLIC KEY BLOCK-----

Add GPG key to GitHub

We now need to tell GitHub that if we sign commits with this key our commits will be marked as verified, to do this you will need to go into your GitHub settings, create a new GPG key, paste the contents of the public key that we exported (including the comment lines) and click Add GPG key.

Configure git to sign commits

Up to this point we have created a key and told GitHub to mark commits as verified when commits are signed with keys that it knows about when they are pushed to repositories, however we have not yet configured our local instance of git to sign our commits locally and tell it which key should be used when doing so.

We can either set the configuration at the global level, applying globally will turn on commit signing for all repositories and you will use the same key for all commits, or at the local repository level. At the repository level, you need to explicitly turn on commit signing and set the signing key for each repository you use, whilst this may sound like more work, I would recommend that this is an approach you should take if you use different source control providers on the same machine.

I regularly use a combination of GitHub, GitHub Enterprise and Azure DevOps, whilst they all use the same git instance for source control, I need to flexibility to set the configuration I need depending on the repo and source control provider I am using. For example, I use different keys for GitHub and GitHub Enterprise, whereas Azure DevOps does not support the use of GPG keys.

Let’s set the config on our local repo, first, lets ensure that our commits are being signed with the correct username and email, these should match the details you entered when generating the key.

git config --local user.name "Megan Bowen"
git config --local user.email "meganb@contoso.com"

Then we can enable commit signing and tell git which key to use

git config --local commit.gpgsign true
git config --local user.signingkey 9910FD82B391958B

If you really want to set the configuration globally, remove the --local switch in the above examples.

Test your changes

When you next make a commit in the repo, using git commit, you will be prompted by the pinentry program to enter the key passphrase. Enter the passphrase in the dialog and click OK to confirm and sign your commit. By default, gpp will cache your passphase for the next 10 minutes before asking again.

You can increase the timeout by creating a file called gpg-agent.conf in the .gnupg folder in your Windows profile location, e.g. C:\Users\meganb.gnupg, containing the line default-cache-ttl 60, where 60 sets the timeout to 1 minute

Now when you push your commits to GitHub from this repository, you will now see that in the commit log, your commits will display the Verified mark.

Useful Resources

Clean up completed Microsoft To Do tasks using CLI for Microsoft 365

2021-04-07T00:00:00+00:00

Microsoft To Do is my task management tool of choice, I use it for tracking everything I do, which means I generate and complete a lot of tasks during a working week.

So why have I written a script to delete completed tasks, they just get hidden right?

One of the things that I wish would be better is the search capability in Microsoft To Do. I use the Microsoft To Do iOS app for managing my tasks and task lists, using keywords on tasks so that I can search on a keyword and return tasks containing that keyword which don’t all reside in the same task list.

Unfortunately, the search does not provide any filters and returns all tasks containing the keyword including those that have been completed, this makes it hard to see at a glance the active tasks that I have against that keyword.

Using the CLI for Microsoft 365 however we can easily solve this issue, as I am not concerned about tasks that I have completed, I have written a script that iterates across all of the task lists and removes the tasks that have been marked as completed.

CLI for Microsoft 365 is associated with the Microsoft 365 Patterns and Practices (PnP) organisation, which is a virtual team consisting of Microsoft employees and community members focused on helping the community make the best use of Microsoft products.

Clear Power Apps Desktop SaveData cache

2021-02-01T00:00:00+00:00

Since the start of the year I have been working with a customer to help them move a complex Power Apps Canvas app that used a SharePoint Online list backend, to ~~CDS~~ Dataverse.

This app also has a dependency on using the Power Apps Desktop app which helps provide users with offline capabilities similar to running the app on a mobile app, as it does not run in the browser enabling the use of the SaveData and LoadData formulas to save and load data from the device whilst offline.

During the development I found myself needing to clear the Power Apps Desktop SaveData cache numerous times and I found that it is not the easiest of things to do or best documented, unlike the mobile app which give you an option in the menu to that, with the desktop app it requires you to identify the cache location on the device and remove the cache files manually.

Here are the steps you need to take to do that.

Open the Run window (Start -> Run or Win + R)
Open %LocalAppData%
- This will open C:\Users\{username}\AppData\Local in File Explorer
Open Packages folder
Open MicrosoftMSApps folder
- This will have an identifier at the end, e.g. Microsoft.MSApps_8wekyb3d8bbwe
Navigate to LocalState > 14 > UserSavedData folder
Delete all the files in the UserSavedData folder

Reopen your app and your cache will be clear 🚀

Export all your Power Automate Flows using CLI for Microsoft 365

2021-01-14T00:00:00+00:00

When was the last time you backed up all the Flows in your environment?

By combining the CLI for Microsoft 365 and PowerShell we can make this task easy and repeatable.

This script will get all Flows in your default environment and export them as both a ZIP file for importing back into Power Automate and as a JSON file for importing into Azure as an Azure Logic App.

The script assumes that you have already logged into your Microsoft 365 tenant using the m365 login command.

See Logging in to Microsoft 365 in the user guide.

CLI for Microsoft 365 is associated with the Microsoft 365 Patterns and Practices (PnP) organisation, which is a virtual team consisting of Microsoft employees and community members focused on helping the community make the best use of Microsoft products.

Attempted Telephone Banking Scam

2021-01-09T00:00:00+00:00

I received a call from what looked like a genuine number on Saturday afternoon from my bank.

It was framed as a call from the fraud detection team at my bank suggesting that a transaction was attempted to be made in the morning from my account for ~£400 from a account with an Indian gentleman’s name with the reference of RENT, suggesting that I also had received a call from my bank in the morning and spoke to someone in my notes to verify the transaction, which I hadn’t.

At first they tried to verify my address, in this case they had my old address, as I recently moved house, this immediately gave me concern.

They continued to ask questions about how my details could have been taken, have you made any payments online recently or written any passwords down etc.

They then suggested that they can stop the payment going through on your account and reclaim the money, but first need to go through some security questions to verify that I am the account holder, they then asked me to confirm my internet banking username, at this point I challenged them that I did not believe that this was a genuine call.

“look at the back of my debit card”

I was asked to look at the back of my debit card, where it would display the number that has called me on the back of the card, this was an attempt to seem genuine. This is not a genuine way to verify the identity of someone calling your bank, at this point I hung up.

the scammers have been able to clone the official telephone number of my bank

In this case the scammers have been able to clone the official telephone number of my bank in attempt to make the call look genuine and this appears to be on the rise.

I rang the number back, this time speaking to genuine bank employees that verified my account correctly and I was able to discuss the call with them. There was no record of any calls made against my account or any fraudulent activity, confirming that the call was indeed a scam and that they also unfortunately confirmed that this type of scam is on the rise.

Now I do know that my bank do call if you try to make a transaction that they believe to be of the ordinary or that could be deemed fraudulent activity, I have had this in the past when travelling to conferences in a new city and make try to make a purchase which is immediately blocked, so whilst it was an unexpected call, it wasn’t something that I had not experienced before although not for some time.

In hindsight I should have just hung up after the address was stated as incorrect, I am a very security conscious person and do not give out my details unsolicited, but even I was consumed by the potential impact of someone attempting to take money from my account.

If you receive a call from your bank, hang up even if it looks like the genuine number and call them back to ensure that the call is genuine, if it is, the notes will be on your account that a genuine call was made and any issues can be dealt with.

Be careful out there folks, it can happen to any of us.

Run CLI for Microsoft 365 in Docker

2020-12-24T00:00:00+00:00

We are delighted to announce that CLI for Microsoft 365 Docker images are now available to download and use from the Docker Hub.

If this doesn’t mean a lot to you right now, then let me explain why we feel this is a big deal.

Docker enables us to bundle a pre-configured version of CLI for Microsoft 365 together with all its required dependencies into a publicly downloadable image, which you can then use to create an isolated environment on your local machine, called a container, where you can use the CLI for Microsoft 365 without cluttering your machine with dependencies, and all performed by executing just a single command.

Sounds great, right? So how do you get started?

Firstly, you will need to have Docker installed and running on your host machine, to do that, checkout the guides over in the Docker documentation, its free and can be installed on any operating system. Once you have Docker running on your machine, open up your command prompt of choice and run the below command.

docker run --rm -it m365pnp/cli-microsoft365:latest

This command will instruct the Docker engine running on your host machine to start a container using an image called m365pnp/cli-microsoft365, as the :latest tag is specified we are also telling the engine to get the image which contains the latest stable version of the CLI.

As the image won’t exist on your host machine yet, Docker will automatically download the image from the Docker Hub, where our images are publicly available, then start a new container which invoking an interactive terminal session inside the container, this is determined by the presence of the -it switch in the docker run command.

By default, the interactive terminal that is opened is a bash shell, however if you prefer using PowerShell then thats fine, we have you covered as we also bundle PowerShell 7 as part of the image.

If you want to use PowerShell, simply add pwsh to the end of the docker run command and you will get a PowerShell session instead.

docker run --rm -it m365pnp/cli-microsoft365:latest pwsh

Now that you are at the interactive terminal, you can now invoke any CLI for Microsoft 365 command using the m365 prefix as it is already installed, to help you, we have even pre-configured tab command completion for you in both bash and PowerShell. Neat right.

When you are done with your session, just type exit and your interactive terminal will be closed and with that, the isolated container will also be stopped and removed, freeing up resources on your host machine, this is determined by the presence of the --rm switch in the docker run command.

This doesn’t mean that the image you just downloaded has been removed as well, this remains on your machine, we just removed the container instance that was started, so when you run the docker run command again, this time you won’t need to download the image and just head straight for the interactive terminal.

As the container is removed after exiting the interactive terminal, everything stored in the container is removed, this includes any authentication information, therefore when you start a new container you will need to re-authenticate with Microsoft 365.

Checkout our guide for more details on how to use these images, including how to get the latest beta releases, update existing images, execute scripts stored on your local machine inside the running container and how to use your own Azure AD identity for connecting to Microsoft 365 from the running container.

We will be releasing new beta and stable versions as part of our regular release cadence, so you will be able to use the new version of the CLI for Microsoft 365 in Docker immediately after our release to npm.

For a list of available tags, checkout the m365pnp/cli-microsoft365 repository on Docker Hub for the latest images.

CLI for Microsoft 365 is associated with the Microsoft 365 Patterns and Practices (PnP) organisation, which is a virtual team consisting of Microsoft employees and community members focused on helping the community make the best use of Microsoft products.

My WSL2 and Windows Terminal setup

2020-12-20T00:00:00+00:00

Windows Subsystem for Linux (WSL) 2 has really changed the game when it comes to open source development on Windows. As a Mac user, I have benefitted from years of developer workflow improvements and enhancements at the command line but now I can bring those into Windows.

This post documents my setup for open source and SharePoint Framework development, why I use certain components and the configuration steps I took.

Windows Subsystem for Linux (WSL) 2

Windows Subsystem for Linux (WSL) 2 gives developers the ability to run Linux containers, benefiting from the improved filesystem performance, from within Windows.

But wait, doesn’t Docker already do that?

Well yes, but what the really nice thing about WSL2 is, how the WSL2 Linux containers can be interacted with from the Window OS, allowing you to do things like, launching Visual Studio code installed in Windows from within the Linux container or opening the Linux file system in File Explorer in Windows, making for seamless switching and really blurring the lines between the two operating systems.

WSL comes into its own for SharePoint Framework (SFPx) development, which uses an open source technology stack, where developing in WSL2 Linux containers hugely improves the performance of installing and building solutions over using the Windows filesystem.

I’m currently running Ubuntu 20.04 LTS which I installed from Microsoft Store after installing WSL on Windows 10.

JetBrains Mono

I like a good font that is easy to read, my current preference at the moment is JetBrains Mono, which is a free and open source typeface designed for developers, in fact it is the very font that you are reading right now.

It has support for ligatures, which hugely helps with readability of code, reducing noise by merging symbols and balancing whitespace between characters more efficiently than regular fonts.

I downloaded the font from the JetBrains website and installed it in Windows.

Windows Terminal

Windows Terminal is a great open source terminal emulator from Microsoft enabling you to switch between different shells with ease and is fully customisable.

I’ve configured JetBrains Mono as my default font to be used across all shells.

{
    "fontFace": "JetBrains Mono",
    "fontSize": 12
}

I’ve added a new profile to create a new shell option for Ubuntu, which defines the name, source, colour scheme and starting directory for new terminal sessions.

I set my starting directory to the home directory of my Linux user (not Windows user) in WSL, this where I store my code repositories taking advantage of speed of the Linux filesystem.

{
    "guid": "{07b52e3e-de2c-5db4-bd2d-ba144ed6c273}",
    "hidden": false,
    "name": "Ubuntu",
    "source": "Windows.Terminal.Wsl",
    "colorScheme": "Atom One Dark",
    "startingDirectory": "//wsl$/Ubuntu-20.04/home/garrytrinder/"
}

I really like the Atom One Dark theme (I also use the same theme in VSCode), so I’ve added that as a new colour scheme.

{
    "name": "Atom One Dark",
    "background": "#282C34",
    "foreground": "#CCCCCC",
    "black": "#000000",
    "blue": "#61AFEF",
    "brightBlack": "#5C6370",
    "brightBlue": "#61AFEF",
    "brightCyan": "#56B6C2",
    "brightGreen": "#98C379",
    "brightPurple": "#C678DD",
    "brightRed": "#E06C75",
    "brightWhite": "#FFFFFF",
    "brightYellow": "#D19A66",
    "cyan": "#56B6C2",
    "green": "#98C379",
    "purple": "#C678DD",
    "red": "#E06C75",
    "white": "#ABB2BF",
    "yellow": "#D19A66"
}

oh-my-zsh

I use zsh as my preferred shell and oh my zsh to help manage my zsh configuration, it comes bundle with thousands of functions, helpers, plugins, and themes.

I ran the script at the command line and followed the instructions to download and install.

sh -c "$(curl -fsSL https://raw.github.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

I set COMPLETION_WAITING_DOTS="true" and uncommented the line in .zshrc.

By turning on COMPLETION_WAITING_DOTS I get visual feedback from the command line that my tab completion request has been invoked and that the shell is currently loading the available options

Spaceship ZSH

I use Spaceship ZSH as my shell theme, not only does it make my prompt look nice but it also provides extensions that helps improve my developer workflow, bringing information like the current git branch, git status, npm package version and current node version into my shell prompt for increased visibility.

I ran the script at the command line to download and install.

git clone https://github.com/denysdovhan/spaceship-prompt.git "$ZSH_CUSTOM/themes/spaceship-prompt" --depth=1
ln -s "$ZSH_CUSTOM/themes/spaceship-prompt/spaceship.zsh-theme" "$ZSH_CUSTOM/themes/spaceship.zsh-theme"

I set ZSH_THEME="spaceship" and uncommented the line in .zshrc.

I added SPACESHIP_PROMPT_ORDER array to .zshrc above source $ZSH/oh-my-zsh.sh line.

SPACESHIP_PROMPT_ORDER=(
  dir           # Current directory section
  git           # Git section (git_branch + git_status)
  package       # Package version
  node          # Node.js section
  dotnet        # .NET section
  ruby          # Ruby section
  exec_time     # Execution time
  line_sep      # Line break
  battery       # Battery level and status
  jobs          # Background jobs indicator
  exit_code     # Exit code section
  char          # Prompt character
)

The SPACESHIP_PROMPT_ORDER array enables you to define which sections are enabled or disabled in the prompt, this is optional but can improve the performance of the prompt. The less sections are loaded the faster the shell will load, so I enable the sections that are of use to me.

oh-my-zsh Plugins

I use these plugins to help me be more productive on the command line, they provide command aliases, highlighting and enhanced command completions.

git

This plugin comes bundled as part of the oh-my-zsh install, so doesn’t need any installation or configuration, it adds git aliases and command completions.

zsh-syntax-highlighting

I use this plugin to enable highlighting of commands whilst they are typed at the command line, helping me reviewing commands before I run them, particularly useful in catching syntax errors.

I ran the script at the command line to download.

git clone https://github.com/zsh-users/zsh-syntax-highlighting.git ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-syntax-highlighting

I added zsh-syntax-highlighting to the end of plugins array in .zshrc.

plugins=(git zsh-syntax-highlighting)

zsh-syntax-highlighting must always be last in the array to work correctly!

zsh-autosuggestions

I use this plugin to provide as you type completions based on my previous command execution history and available command completions.

I ran the script at the command line to download to download and install.

git clone https://github.com/zsh-users/zsh-autosuggestions ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-autosuggestions

I added zsh-autosuggestions to the plugins array in .zshrc.

plugins=(git zsh-autosuggestions zsh-syntax-highlighting)

Node Version Manager (NVM)

I use nvm to help manage and install multiple versions of nodejs and it makes it really easy to switch between the different versions.

I ran the script at the command line to download and install.

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.37.2/install.sh | zsh

As I can use three up to different versions of nodejs for SharePoint Framework and CLI for Microsoft 365 development, I have installed node@8, node@10 and the current LTS, node@14, also creating an alias for each version, to make switching between versions based on scenario much easier.

For CLI for Microsoft 365 development, I have installed node@14, set it to be the default alias and given it a named alias of cli-m365.

nvm install 14
nvm alias default 14
nvm alias cli-m365 14

For SharePoint Online SPFx development, I have installed node@10 and created an alias of spfx-spo.

nvm install 10
nvm alias spfx-spo 10

For SharePoint On Prem SPFx development, I have installed node@8 and created an alias of spfx-onprem.

nvm install 8
nvm alias spfx-onprem 8

I can easily switch between the different versions without needing to remember the exact version required for each scenario by using the alias.

nvm use cli-m365
nvm use spfx-spo
nvm use spfx-onprem

As I’m using Spaceship ZSH for my prompt, the current selected nodejs version will be displayed clearly on the command line.

Command Line Tools

These Command Line Interface (CLI) tools enable me to manage Microsoft 365 & SharePoint Framework projects, GitHub and Azure all from the command line.

CLI for Microsoft 365

As one of the maintainers of the CLI for Microsoft 365, this is first on my list, it enables me to manage my Microsoft 365 tenants and SharePoint Framework projects from within WSL2.

I ran the script at the command line to download and install.

npm i -g @pnp/cli-microsoft365@latest

I ran the script at the command line to setup command completions for the CLI.

m365 cli completion sh setup

GitHub CLI

I use the GitHub CLI to manage my GitHub repositories from the command line, it enables me to easily clone and fork repositories as well as being able to manage pull requests and issues.

I’ve used this since early beta and it makes working with GitHub so much easier and faster.

I ran the script at the command line to download and install.

sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-key C99B11DEB97541F0
sudo apt-add-repository https://cli.github.com/packages
sudo apt update
sudo apt install gh

I ran the script at the command line to configure VS Code as the default editor.

gh config set editor "code --wait"

Azure CLI

I use the Azure CLI to manage my Azure tenant from the command line.

What I really like about the Azure CLI over the PowerShell modules is the huge range of commands available and that the commands are idempotent, meaning that you can run them over and over, which makes it really quick and easy to build and test deployment scripts.

As there is no package available yet for Ubuntu 20.04 LTS, so I ran the below script to perform a manual install.

sudo apt-get update
sudo apt-get install ca-certificates curl apt-transport-https lsb-release gnupg
curl -sL https://packages.microsoft.com/keys/microsoft.asc |
    gpg --dearmor |
    sudo tee /etc/apt/trusted.gpg.d/microsoft.gpg > /dev/null
    AZ_REPO=$(lsb_release -cs)
echo "deb [arch=amd64] https://packages.microsoft.com/repos/azure-cli/ $AZ_REPO main" |
    sudo tee /etc/apt/sources.list.d/azure-cli.list
sudo apt-get update
sudo apt-get install azure-cli

I also added source /etc/bash_completion.d/azure-cli to .zshrc to setup command completions.

My Configuration Files

I’ve published the full contents of both of my zsh configuration and Windows Terminal settings to GitHub.

Zsh Configuration

This is my current .zshrc file.

Windows Terminal Settings

This is my current settings.json file for Windows Terminal.

Implement Microsoft Graph app-only calls the easy way using Azure Logic Apps and Azure Managed Identity

2020-09-17T00:00:00+00:00

This article is part of #ServerlessSeptember. You’ll find other helpful articles, detailed tutorials, and videos in this all-things-Serverless content collection. New articles from community members and cloud advocates are published every week from Monday to Thursday through September.

Find out more about how Microsoft Azure enables your Serverless functions at https://docs.microsoft.com/azure/azure-functions/.

This post will show you how you can configure an Azure Logic App to make app only calls to the Microsoft Graph without the need to handle any client credentials such as client ids, secrets or certificates, by using Azure Managed Identity authentication.

By enabling Azure Managed Identities on Azure resources, we can use these identities to authenticate to any service that supports Azure Active Directory authentication.

As Azure manages the identity for us, we gain a number of benefits

No client credentials to handle
Automatic credential rolling
Identities are tied to Azure Resources
No additional cost

To keep things super simple, our Azure Logic App will just make a single call to return all Microsoft 365 groups in a given tenant using Azure Managed Identity to authenticate with the Microsoft Graph.

Provision the Azure Logic App

Navigate to the Azure Portal
Click Create a resource
Search for Logic App and hit return
Click Create on the Logic App screen
Create a new resource group e.g. rg-apponly-graph-dev
Select an appropriate region e.g. UK South
Enter name for the logic app e.g. la-apponly-graph-dev
Click Review + Create
Click Create to provision the Azure Logic App

Enable Azure Managed Identity on the Azure Logic App

Open the Logic App after it has been provisioned and scroll to the menu on the left
Click on the Identity menu item under the Settings section
Change the Status toggle to On
Click Save
Click Yes to the prompt which consents that you understand that an identity will be created in Azure Active Directory

Learn more about Managed Identity on docs.microsoft.com

View Azure Managed Identity Service Principal

Open Azure Active Directory
Click on the Enterprise Applications menu item
Change the Application type dropdown to All
Search for the name of the Logic App e.g. la-apponly-graph-dev
Click on the name of the application listed in the table to view the Service Principal details
Click the Permissions menu item under the Security section

Grant the Azure Managed Identity Service Principal Microsoft Graph app only permissions

Open the Azure Cloud Shell from the Azure Portal suite bar (Accept the prompt to create a storage account if you have never used the Cloud Shell before)
Wait for the Cloud Shell session to start
Execute m365 login --authType identity to login to your Microsoft 365 tenant using Managed Identity authentication
Execute m365 status to confirm login status
Execute m365 aad approleassignment add --displayName "la-apponly-graph-dev" --resource "Microsoft Graph" --scope "Group.Read.All" to grant the Managed Identity Service Principal the Group.Read.All application permission to the Microsoft Graph
Close the Cloud Shell prompt
Click Refresh to update the Permissions and confirm that the new permission has been granted

The tool used in this step is the CLI for Microsoft 365 which is pre-installed in the Azure Cloud Shell, as it is a cross platform tool it can be used in either bash or PowerShell. To learn more about the CLI and its features/commands, check out the project documentation

Configure the Azure Logic App

Open the Logic App
Scroll down to view the Templates section and click Blank Logic App to open the Logic App Designer
Search for Recurrence, click on Schedule and then Recurrence to add the trigger action
Leave the trigger action inputs as the default values
Click New step
Search for HTTP, click on HTTP to add the action
Select GET from the dropdown in the Method field
Enter https://graph.microsoft.com/v1.0/groups in the URI field
Click on the Add new parameter field
Check the Authentication checkbox
Click on the design surface (away from the Add new parameter field) to render the Authentication section
Change the Authentication type to Managed Identity
Enter https://graph.microsoft.com in the Audience field
Click Save

Manually run the Azure Logic App

Click the Run button in the Logic App Designer to manually trigger the Logic App
After a few moments the Logic App Designer will display the results of the run
Click the HTTP action to view the successful request result

Congratulations! You just pulled data from the Microsoft Graph without having to pass any credentials! 🎉 🚀

Cleanup

Open the Resource Groups view
Click on the resource group e.g. rg-apponly-graph-dev
Click Delete resource group
Enter the name of the resource group in the field e.g. rg-apponly-graph-dev
Click Delete

As the Azure Managed Identity Service Principal lifecycle is tied to the resource that created it, it is automatically removed from Azure Active Directory when the resource is deleted

Summary

Azure Logic Apps and Azure Managed Identity provide a very powerful and highly secure, no-code approach that is ideal for automation scenarios that are incredibly easy to configure.

When working with cloud solutions we should always be ensuring that client credentials and secrets are secured, Azure Managed Identity helps reduce the burden of maintaining and rolling credentials, helping you increase your security in a simple and effective way.

If you would like to learn about how you can use Azure Managed Identity with other Azure Resources such as Azure VMs and Azure Functions, checkout my session recording of Keyless Authentication using Azure Managed Identity from the PnP Virtual Conference held on 1st September 2020.

Inconvenient Microsoft Word comments in Microsoft 365

2020-06-10T00:00:00+00:00

I have been recently looking into how the comments feature in Microsoft Word works across Microsoft 365, specifically around the @ mention feature, to help customers be more productive when authoring and reviewing documents, however I noticed that it doesn’t always work as you would maybe expect it to.

The Comments feature has been in Microsoft Word for a long time, so long that I’m pretty sure most of us just refer to it as always being there, it enables you to highlight a section of the document and make a comment, starting a discussion thread directly within that document, where others can reply, with the ultimate aim to provide feedback that can be actioned before publishing the document to wider audience.

As time has moved on this feature has been given an upgrade, as we now live in a more connected world, the ability to @ (at) mention was included so that you could notify colleagues directly in a comment to get their immediate feedback. It is a great feature, however as our world has got bigger, we now access our documents in different ways, through Microsoft Teams, the browser, desktop and mobile apps, which has led to some differences in the functionality offered which may have an impact on how you might choose to collaborate on a document with your colleagues.

So lets take a look at the two types of @ mentions possible…

@ mentions in comments, this is what most people will be used to doing, you create a new comment in the document and in the comment @ mention the person who you want to notify, sending an auto email to that person letting them know that something needs their attention.

inline @ mentions, rather than creating the comment first and then @ mentioning, you can @ mention directly within the document. This automatically creates a comment with the comment of the person who you @ mentioned, whilst this can be useful, the comment that is auto-created is less than desirable as you have to explain what your comment is in a reply, this will send an auto email to that mentioned person.

There are a couple of features to be aware of that that are associated with the use of comments in Word…

Follow-Ups, is a view displayed in the Navigation pane which lists all the instances in the document where a person has been @ mentioned, useful for you to jump to different locations in a long document where your input is required.

Share and Notify, if you @ mention someone who does not have access to the document, a prompt will be displayed asking whether you would like to share that document with that person, this can be useful or not, depending on your situation.

Word Online in Teams

Now that we know the features, lets see what functionality is available, starting with one of the most common scenarios at the moment, viewing a Word document via the Microsoft Teams interface.

As this is going to be quite a common scenario, I was quite surprised to find that it is not possible to @ mention in a comment and you cannot @ mention inline, you do however get the Follow-Ups section in the Navigation pane.

To compensate for the lack of @ mentions, as the document is being shown within the Teams interface, you do get the ability to create a teams conversation and @ mention people in the conversation but as this is outside of the document this conversation will not be visible to other authors or reviewers viewing the document outside of the Teams interface, it also doesn’t allow you to highlight sections of the document, like you can with a comment, so could be problematic when using this approach to give context about a change that is required in a document. I see this as useful to talk around the document in general but not specific areas.

Document conversations are created in the Channel closest to where that file is stored, for example, if the file is accessible from the Files tab on the General channel, the new conversation will be created in the Posts tab of the General channel.

Microsoft 365 Word

After viewing the document in the Teams interface, chances are that most people will open the document in Microsoft Word desktop app using the ‘Open in Desktop App’ button. When viewing the document outside of the Teams interface, it is noticeable that a few options now change, Conversations are gone, @ mentions in comments are now possible but inline @ comments are not.

We now have @ mentions, great, however there is something that you need to be careful of, if you @ mention a person who does not have access to the document i.e. not a member of the Team that the document is stored in, when you mention them, you will receive a prompt that tells you that this person does not have access to the document and that you can share the document with them and notify them that the document hsa been shared with them.

Whilst this is a nice feature, what this does behind the scenes is that it gives the person being mentioned edit access directly to the document. No problem, you might think, it is however worth knowing that when you grant access to a document this way you are using document level permissions which can make managing and tracking who has access to which document in the future difficult, as this is not easily noticeable which documents have unique permissions applied, you will have to look into the permissions in SharePoint to see who has access to the document. One ommision from the desktop app is the Follow-Ups view, if you have a few mentions in a document you will need to manually search for them.

Note: Both the Windows and Mac OS versions of Word have the same functionality

Word Online in Browser

Another way to view the document is to open the document in Word Online using the ‘Open in Web Browser’ button, whilst you would think that there won’t be much difference between Word Online in the browser and Word Online in Teams, it is noticeable that a few options are not the same, Conversations are gone in the same way as in the desktop app, @ mentions in comments and inline @ mentions are now possible as and the Follow-Ups view is visible in the Navigation pane. Again, like in the desktop app, mentioning a person who does not have access to the document will give the Share & Notify prompt.

Word for iOS (iPad)

Lastly, as more people are using the Word for iOS app on mobile and tablet, this supports does support @ mentions in comments and will prompt to Share & Notify if mentioning people who don’t have access to the document, but inline @ mentions and the Follow-Ups view are not supported.

Summary

I was quite surprised to see the difference in this functionality across the different versions of Word that could be used when authoring and reviewing a document across Microsoft 365.

The one place where I would have expected @ mentions to work due to it being a common interface, is through the Teams interface but this is not the case, as it favours using the Conversations route instead for @ mentioning. The main reason for this seems to be to stop team members from sharing the documents directly with individuals outside of the Team without maybe realising it, however this can easily be done via other Word versions such as the desktop app.

The below table shows what functionality is available in different versions of Word in Microsoft 365.

	@ Comment	@ Inline	Follow-Ups	Conversations	Share & Notify
Word Online in Teams	❌	❌	✅	✅	❌
Word Online in Browser	✅	✅	✅	❌	✅
Microsoft 365 Word	✅	❌	❌	❌	✅
Word for iOS (iPad)	✅	❌	❌	❌	✅

Using your own Azure AD identity with Office 365 CLI

2020-05-10T00:00:00+00:00

The Office 365 CLI provides a quick and easy way to manage your Office 365 tenant from any operating system and any shell.

When you use the Office 365 CLI to connect to your tenant for the first time, you are presented with a Permissions requested prompt from Azure, by accepting this prompt you are consenting to using the PnP Office 365 Management Shell Azure AD application with your tenant as well as the permissions that it requires.

We ask for a wide range to permissions up front, including permissions that require administrative level consent, so that it is easy for to get started with the CLI and try out the commands across many Office 365 CLI workloads in your tenant without having to handle the complexity of managing the permissions for the different commands manually in Azure.

Whilst this is fine for working against development and test environments, using these levels of permissions against production environments is inconvenient and administrators are not comfortable with granting such permissions to a multi-tenant application within their environment.

In this scenario, administrators will want to provide their own Azure AD app registration to use with the CLI to enable greater control over the permissions that are granted.

This tutorial will walk you through how to create your own Azure AD application with permissions restricted to only read information about SharePoint Online Site Collections and how to use this custom application with the Office 365 CLI.

Register Azure AD application in your tenant

We first need to register a new Azure AD application in your tenant, to do this we will need to navigate to the Azure Portal.

Select Azure Active Directory from the global menu, select App registrations in the Azure Active Directory blade and then select the New registration action button to open the Register an application form.

In the form, enter a name for your new application, for the purposes of this tutorial lets use Custom PnP Office 365 CLI, you can always change this later if you want. Leave the Supported account types and Redirect URI as they are and select the Register button at the foot of the form to create your custom application.

After the application has been created, you will be presented with the blade for your application displaying an overview of some properties of the application. At this point it is a good idea to take note of two key pieces of information that we will need later.

Take a copy of both the Application (client) ID and Directory (tenant) ID values and save them to a place for you to refer back to them later.

Confgure Authentication settings

We next need to configure our new application so that it can be used with the Office 365 CLI, to do this we need select Authentication in the Custom PnP Office 365 CLI blade menu.

This will present you with three sections, Platform configuration, Supported account type and Advanced settings.

Select the Add a platform button to open up the Configure platforms menu and select Mobile and desktop applications under the Mobile and desktop applications heading, this will open another menu called Configure Desktop + Devices displaying a section called Redirect URIs and a list of checkboxes with some pre-defined URIs.

Select the first option in the list, https://login.microsoftonline.com/common/oauth2/nativeclient and select the Configure button at the foot of the menu.

This will refresh the Authentication blade and will display the Redirect URI we just chose from the menu.

This Redirect URI is specific to the use of authentication methods that do not use a web interface for authenticating users and are therefore called Native Clients, this is the category that the Office 365 falls into.

Moving on, we can skip over the Supported account type section, as this is defaulted to Accounts in this organizational directory only (<tenant> only - Single tenant) it means that only users within the current tenant directory can use this identity and onto the Advanced settings section, in here we need to toggle the Default client type toggle so that is enabled, as we are using the Device code flow method to authenticate to our tenant using the Office 365 CLI.

To make sure all these changes are applied, select the Save button before moving on.

Configure API Permissions

Now that we have configured the application to work with the Office 365 CLI, we next need to grant what permissions the CLI will have against our tenant. Select the API permssions in the Custom PnP Office 365 CLI blade menu.

You will see a section called Configured permissions with one permission already granted, this is the defaul permission which allows the application to sign the user account used when authenticating to the Microsoft Graph.

Select the Add a permission button to open the Request API permissions menu, as we are only interested in granting our application access to SharePoint Online for the purpose of this tutorial, select SharePoint in the list of APIs that are available.

This opens the menu with two options Delegated permissions or Application permissions, as we are going to be communicating with the SharePoint Online APIs as the authenticated user, select Delegated permissions, this will display a list of available permissions that we can choose from.

For the purpose of this tutorial we only want to grant read access to SharePoint Online, so expand the AllSites grouping and select the AllSites.Read permissions and select the Add permssions button to apply these permissions.

Note that the AllSites.Read permission does not directly grant the signed-in user access to all sites in SharePoint Online. As we authenticate as the signed-in user, that user must still have access to the SharePoint sites that we want to return information about, otherwise the SharePoint Online API calls will fail with 401 Unathorized

You will be presented with the Configured permissions section again but this time the AllSites.Read permission will be shown under the SharePoint grouping.

This completes the configuration required in the Azure portal, we can now move onto configuring the Office 365 CLI to use our custom application to login to Office 365.

Create Office 365 CLI environment variables

To configure the Office 365 CLI to use our newly created custom application, we need to tell it the Client ID of our custom application and the Tenant ID of where the custom application has been created.

To do that, we need to create two environment variables, called OFFICE365CLI_AADAPPID and OFFICE365CLI_TENANT, giving them the values that you saved earlier.

How you set the environment variables is dependant on the operating system and shell you are using.

If you are on Windows, you can set the environment variables using the $env:<variable-name> approach in a PowerShell session.

$env:OFFICE365CLI_AADAPPID="506af689-32aa-46c8-afb5-972ebf9d218a"
$env:OFFICE365CLI_TENANT="e8954f17-a373-4b61-b54d-45c038fe3188"

Execute $env:OFFICE365CLI_AADAPPID and $env:OFFICE365CLI_TENANT to verify that the environment variables have been created correctly

If you using Linux or MacOS, you can set the environment variables using the export command from your terminal prompt.

export OFFICE365CLI_AADAPPID=506af689-32aa-46c8-afb5-972ebf9d218a
export OFFICE365CLI_TENANT=e8954f17-a373-4b61-b54d-45c038fe3188

Execute printenv to verify that the environment variables have been created correctly

Now that we have set our environment variables, we are now ready to use our custom application to log in with using the Office 365 CLI.

For the purpose of this tutorial, we will be using the Device code flow to interactively authenticate with an Office 365 CLI tenant. As this is the first time that we will have used the custom application to authenticate, we will also be required to give our consent.

At your terminal session, execute o365 login to start the authentication process, a login device code will be displayed along with a link to a web page where it needs to be entered. Navigate to https://microsoft.com/devicelogin, enter the code into the input field and select Next. You will then be presented with either a login screen or accounts that you have already logged in to Office 365 with. Login with or choose the account from the list that you want to use with Office 365 CLI.

You will now be prompted to consent that the custom application, Custom PnP Office 365 CLI, can use the two permissions that we configure earlier, Read items in all site collections and Sign you in and read your profile on your behalf. Select Accept to consent and complete the sign-in process.

Returning back to your command line, you can now verify that the sign in has been succesful by executing the o365 status command.

Finally, to test that we can indeed read SharePoint Online site collections, lets invoke the following command

o365 spo site get --url https://trinder365dev.sharepoint.com -o json --pretty

The JSON representation of the SharePoint Online site will be returned to the console.

Congratulations! You have just configured the Office 365 CLI to use your own custom application with custom permissions from your own Azure Active Directory.

Find out more

If you would like to know more about Office 365 CLI, visit the web site at https://aka.ms/o365cli.

If you see any room for improvement or suggestions, please don’t hesitate to reach out to us either on GitHub or @office365cli on Twitter.

Appendix: Persisting environment variables

As mentioned earlier, the way in which we set the environment variables meant that they are only set for the lifetime of the session, if the terminal session is closed, you will need to repeat those steps, which maybe undesirable.

How you permanently set the environment variable is dependant on the operating system and shell you are using.

If you are on Windows, you can set the environment variables using the Edit the system environment variables approach in the Windows UI.

Search for Edit the system environment variables in Start Menu and launch it. Select Environment Variables, under the User variables for <user-name> section, select New... to open a dialog. In the dialog, enter OFFICE365CLI_AADAPPID in the variable name field and set the value using the Client ID (quotes should be ommitted), select OK to save the value and repeat the process for the OFFICE365CLI_TENANT variable. Select OK until all windows are closed to persist the changes.

Open a new PowerShell session and execute $env:OFFICE365CLI_AADAPPID and $env:OFFICE365CLI_TENANT to verify that the environment variables have been created correctly.

If you are on Linux or MacOS, depending on your terminal, add the export lines to .bashrc or .zshrc file in your home directory.

If you are using PowerShell Core, it is worth noting that environment variables set in bash or zsh will persist to the pwsh session and the same applies to Windows.

Recovering a pull request after accidentally deleting the source branch

2020-05-03T00:00:00+00:00

If you are a regular contributor to an open source project on GitHub pushing code changes via pull requests, it is a good idea to delete the branches that have been merged and no longer needed.

I like to make sure that I keep my repositories up to date and employ good branch hygiene, making sure that I only have branches that I am working on in my GitHub forks and locally on my machine.

Currently we release a new version of the Office 365 CLI on a weekend, so I’ve got into a habit of using this day to sync my fork, ensuring that both the master and dev branches are up to date and cleanup up any branches that I don’t need anymore.

Now reading the title of this post, I’m sure you can now imagine what prompted me to write it… yes, you guessed it, I deleted a branch that I still needed, both from my fork in GitHub and locally. To make matters worse, deleting this branch automatically caused my open pull request causing it to be instantly closed.

As it turns out, this was fairly simple to fix. Every commit that you make in Git is uniquely recorded with a SHA-1 checksum and we can use this to create a new branch from, essentially recreating the branch from a point in time.

git checkout -b <branch> <start_point>

Create a new branch named <branch> and start it at <start_point>

The important part is obtaining the commit SHA-1 checksum of my commit. I was able to get this from my closed pull request by viewing the Commits tab on the pull request and copying the commit SHA-1 using the copy button.

Using the git checkout command, I was able to then re-create the branch locally and push the branch back up to my fork in GitHub, which restored the branch that my pull request was referencing.

git checkout -b auth-filestorage a1a12389bbefdf1aa197d04940b48d8641bbeae7
git push --set-upstream origin auth-filestorage

This then allowed my to reopen my pull request 🙌🏻

Crisis averted.

Identify and report on Microsoft Teams Private Channels using Office 365 CLI and PowerShell

2020-04-14T00:00:00+00:00

Do you need to identify Microsoft Teams Private Channels in your tenant quickly?

When a Private Channel is created in a Microsoft Team, a new SharePoint site collection is created behind the scenes, however these are not visible in the SharePoint Online Admin Center (modern and classic) or easily identifiable in the Teams Admin Center, so it is useful from an adminstration point of view to be able to identify these.

Thankfully these sites are created using a site template called TEAMCHANNEL#0 which we can use to track them down with.

The below script uses the spo site classic list command in Office 365 CLI and PowerShells Export-Csv cmdlet, to identify those Private Channel sites and export some basic information about them into a CSV file.

This script assumes you are already logged into your Office 365 tenant after using the o365 login command. More

o365 spo site classic list -o json --query 'sort_by([], &Title)[?Template==`TEAMCHANNEL#0`].{Title:Title,Url:Url,Owner:Owner,Template:Template}' | ConvertFrom-Json | Export-Csv -NoClobber -Encoding utf8 -UseQuotes Always -Path teams-private-channel-report.csv

Which returns the below output

"Title","Url","Owner","Template"
"Sales and Marketing - Private Team","https://m365x835955.sharepoint.com/sites/SalesAndMarketing-PrivateTeam","meganb@m365x835955.onmicrosoft.com","TEAMCHANNEL#0"
...

Getting started with Office 365 CLI and PowerShell

2020-04-13T00:00:00+00:00

In this post, we will show you how to get started with using the Office 365 CLI with the popular PowerShell scripting language on Windows and now also cross platform using PowerShell Core (pwsh).

Why would I want to use the Office 365 CLI?

As more and more organisations move into Office 365, more solutions are being built that expand beyond the Windows operating system. Developers and adminstrators are no longer constrained to Microsoft development technologies tied to the Windows platform, opening up the possibility to develop applications and automation scripts using cross platform technologies to authenticate and communicate with Office 365 workloads.

Unfortunately, managing many of the workload settings is possible only through using PowerShell on Windows. It is typicaly for developers and administrators to use a combination of different PowerShell modules to achieve this, such as PnP PowerShell and SharePoint Management Shell. For non-Windows users to handle such a scenario, it is common for them to use Windows Virtual Machines just to manage these settings, which is not convenient and can be costly.

The Office 365 CLI is a cross-platform command line interface that enables you to manage your Office 365 tenant on any operating system or shell, whether you are on Windows, MacOS, or Linux, or use CMD, PowerShell, bash or zsh.

The CLI also provides a single unified login to Office 365 workloads. It is becoming more and more common that you need to manage and provision assets in many different workloads in the same script and it is incovenient to connect/disconnect with them individually. The CLI handles this complexity for you, enabling you to concentrate on your script logic without having to handle the authentication requirements for each workload as this is managed behind the scenes for you.

Installing the Office 365 CLI

The CLI runs on NodeJS, therefore it does require that you have Node v6 or higher installed on your machine.

Open up a PowerShell session and install the CLI using npm, once installed, this will be available to use in your shell.

PS > npm install @pnp/office365-cli -g

Learn more about installing the Office 365 CLI here

Setup command completion

One of the key features of PowerShell is that tabbed command completion is built in by default. If you want to find a command to use you can simply tab and move through the different cmdlets available to you.

With the 2.7 (March 2020) release of the Office 365 CLI, we added command completion functionality for PowerShell, to enable a similar experience when using the CLI.

To enable command completion, we have provided a command in the CLI to help do this for you.

Using the cli completion pwsh setup command adds a reference in your PowerShell profile which loads the CLI command completion when you open a new PowerShell session.

PS > o365 cli completion pwsh setup --profile $PROFILE

Notice that we prefix the cli completion pwsh setup command with o365 in the above example. To execute any CLI command using PowerShell, we must prefix them with o365 or office365 to access the CLI in non-immersive mode.

Learn more about immersive and non-immersive mode here.

You should close your current PowerShell session after running the above command for the changes to take effect.

When you next use the CLI commands, you can use <tab> to return options available to you, for example, o365 <tab> to return all top level command groups.

With every release of the Office 365 CLI, (beta releases are weekly and major releases are monthly), we add new commands for you to use.

To ensure that you can use these new commands in command completion, you need to update, to do that use the update command.
PS > o365 cli completion pwsh update

View command help

In PowerShell, you can the Get-Help cmdlet to return interactive help for a given cmdlet as the Office 365 CLI is not built using PowerShell it is not possible to use this, however we do provide a --help option on all commands in the CLI.

Use this to return information on what the command does, the options available and examples of how to use the command.

PS > o365 spo web get --help

  Usage: spo web get [options]

  Retrieve information about the specified site

  Options:

    --help                 output usage information
    -u, --webUrl <webUrl>  URL of the site for which to retrieve the information
    --query [query]        JMESPath query string. See http://jmespath.org/ for more information and examples
    -o, --output [output]  Output type. json|text. Default text
    --pretty               Prettifies json output
    --verbose              Runs command with verbose logging
    --debug                Runs command with debug logging

  Examples:
  
    Retrieve information about the site https://contoso.sharepoint.com/subsite
      spo web get --webUrl https://contoso.sharepoint.com/subsite

Authenticating with your Office 365 tenant

Before we run any commands that call Office 365, we need to make sure that we are connected to our Office 365 tenant, you can do this using the login command.

PS > o365 login
To sign in, use a web browser to open the page https://microsoft.com/devicelogin and enter the code XXXXXXXXXX to authenticate.

The default login method used is the device code method, this is ideal for using accounts that have multi-factor authentication enabled on them as the login is interactive and performed in the browser.

Simply navigate to the Microsoft device login screen, enter the code returned from the command and login using your Office 365 account.

Learn more information about authenticating with Office 365 CLI and other authentication methods available here

Executing commands from PowerShell

Once connected to your Office 365 tenant, executing commands is straight forward.

If we want to return information about a SharePoint Online site, we can use the spo web get command, as shown in the example below.

PS > o365 spo web get --webUrl "https://contoso.sharepoint.com"
Title : My Awesome Site
Url   : https://contoso.sharepoint.com
...

Learn more about all the commands available here

Working with data

In the previous example, the response is simply returned to the PowerShell prompt as text, however when building scripts we want to reuse information from previous commands to pass into other commands, or interrogate the returned responses in more detail.

To work with the data returned from the CLI commands, we can use --output json option to ask the CLI to return JSON instead of text, which is the default output type for all CLI commands, and convert that response into it into a useable object.

PowerShell conveniently provides us with a cmdlet to do this, ConvertFrom-Json, which makes coverting JSON responses into a PowerShell object easy.

We can use a pipe (|) to pass the output of the CLI command directly to this cmdlet and save it as a PowerShell variable which enables us to then access properties directly and return their values.

If we want to access the Title property value of a SharePoint Web, building on the previous example we can use this approach, as shown in the example below.

PS > $web = o365 spo web get --webUrl "https://contoso.sharepoint.com" --output json | ConvertFrom-Json
PS > $web.Title
My Awesome Site

And if we wanted to iterate over a response that returns a JSON array we can pipe the PowerShell object into the ForEach-Object cmdlet, as shown in the example below.

$sites = o365 spo site list -o json | ConvertFrom-Json
$sites | ForEach-Object { $_.Title }

As the above examples show, we can easily create PowerShell objects using this approach using the ConvertFrom-Json cmdlet and the use the data with any PowerShell cmdlet available.

Example Scripts

The Office 365 CLI web site contains a section for example scripts, with many using PowerShell.

Checkout the examples here.

If you build a script and would like to add it our examples section, we would love to hear from you, get in touch with the project our at our GitHub repository.

Find out more

If you need more help getting started or want more details about the commands, the architecture or the project, go to https://aka.ms/o365cli.

If you see any room for improvement or suggestions, please don’t hesitate to reach out to us either on GitHub or @office365cli on Twitter.

Keeping your fork up to date

2020-03-16T00:00:00+00:00

When contributing to an open source project one of the regular tasks that you need to perform is ensuring that your fork is up to date to help avoid merge conflicts when merging your code contributions.

As a maintainer and contributor to the Office 365 CLI project, this is a task which I perform weekly in-line with our release cadence, ensuring that I am creating any new branches from the latest version of the source code.

We currently release a new beta version every Sunday, updating our dev branch and a monthly release which updates our master branch.

As an example, our last release contained 10 commits to the dev branch, meaning that my forked version of the dev branch was now 10 commits behind and missing those commits.

Add the upstream remote

When you first create a fork and clone this to your local machine, there is no link between your fork and the repository that it has been created from.

For us to be able to pull down updates from the original repository, we need to ensure that we have that link.

This link is established by creating a new remote called upstream targeting the original repository.

git remote add upstream https://github.com/pnp/office365-cli.git

To verify that the upstream link has been establised you can use git remote -v to return a list of the remotes created on your local repository

Now that this link is established, we can pull down the latest source from the original repository to our machine.

git fetch upstream

This will pull down all the branches from the upstream which we can use to rebase our local out of date branches with.

Keep dev in sync

To update our local dev branch with the latest changes in the upstream, we can use the git pull command, using the --rebase switch and define the remote and branch that you want to use to rebase from.

Rebase re-plays the commits from the latest source code on top of your branch, adding the missing changes.

After rebasing, your local dev branch will be the same as the branch in the upstream repository matching the same number of commits on your local machine.

We can then push the local branch up to GitHub local using git push.

You will now see that your dev branch in your fork on GitHub.com now matches the number of commits.

git checkout dev
git pull --rebase upstream dev
git push

Keep master in sync

You can easily repeat the same process for the master branch using the same approach.

git checkout master
git pull --rebase upstream master
git push

Keep old branches in sync

If you have old branches, maybe a feature branch that you are still working on but want to keep up to date, you can use the same steps but target the upstream dev branch when rebasing instead.

git checkout feature-branch
git pull --rebase upstream dev
git push --force

The --force switch is required here if you have previously pushed your old branch to your fork on GitHub.com, this will replace the branch on GitHub with your updated local branch which contains the commits from the upstream dev branch, the updates, and your own commits made to your feature branch, your changes.

Keep your upstream in sync

As time moves on, the upstream will be updated after a release and you need to keep this in sync on your local machine.

When that changes, you will need to ensure you fetch the latest changes onto your local machine before you then rebase any branches.

git fetch upstream

Squash your commits using git interactive rebase

2020-03-10T00:00:00+00:00

This post will show you how to merge all of your commits into one to help make your pull requests lighter and help keep the history clear for others to track changes.

Every commit you make, saves any changes to a local git repository, helping build up a history log of what has happened over time.

It is good practice to commit changes frequently as we work in our feature branches so that we can keep track of the changes we have made and make it easier to roll back to a working state. That said, commiting frequently does have its drawbacks, it can lead to pull requests being created with several or if it is a larger change, potentially hundreds of commits.

This level of detail may make great sense to someone who has written the code, however this maybe confusing the someone who is required to review those changes as part of a pull request code review.

Does the reviewer really need to know that you made 5 commits to get something working or another 3 commits to fix typos? Probably not.

Therefore it is good practice that before submitting a pull request, you tidy the history of your feature branch to just represent all the changes you have made in a single commit. You will find that some open source projects will encourage this, such as the Office 365 CLI who operate a One PR = One Commit rule for pull requests helping keep the commit history nice and clean for all to see.

So how can this be done?

By using something called, git interactive rebase, which we can use to help re-write the commit history in our local repository.

Consider this scenario, I am writing a blog post in a new feature branch, I create the basic page for the post with a title and commmit this change. I then start to write my blog post, after a while I take a break, so I commit the changes made, when I return I complete the rest of the post and commit those changes again. After another break, I return to read through my post and spot some typos, so I make those changes and again commit them.

This is a fairly common scenario, but as you can see I have so far created 4 commits and viewing the history, git log --oneline, you would see something like this…

37b5bf3 (HEAD -> your-branch) Fixed typos
fdabd0d Complete
67a35d7 Stopped for break
83bddef Initial commit

So based on the above git log output, we can use the rebase command and its interactive mode to re-write our history.

Executing git rebase -i HEAD~4, where 4 represents the number of commits you want to go back in your history to re-write. The rebase process will be started and you will be entered into an interactive editor, which will look something like this…

pick 83bddef Initial commit
pick 67a35d7 Stopped for break
pick fdabd0d Complete
pick 37b5bf3 Fixed typos

# Rebase 83bddef..37b5bf3 onto 37b5bf3 (4 commands)
#
# Commands:
# p, pick <commit> = use commit
# r, reword <commit> = use commit, but edit the commit message
# e, edit <commit> = use commit, but stop for amending
# s, squash <commit> = use commit, but meld into previous commit
# f, fixup <commit> = like "squash", but discard this commit's log message
# x, exec <command> = run command (the rest of the line) using shell
# b, break = stop here (continue rebase later with 'git rebase --continue')
# d, drop <commit> = remove commit
# l, label <label> = label current HEAD with a name
# t, reset <label> = reset HEAD to a label
# m, merge [-C <commit> | -c <commit>] <label> [# <oneline>]
# .       create a merge commit using the original merge commit's
# .       message (or the oneline, if no original merge commit was
# .       specified). Use -c <commit> to reword the commit message.
#
# These lines can be re-ordered; they are executed from top to bottom.
#
# If you remove a line here THAT COMMIT WILL BE LOST.
#
# However, if you remove everything, the rebase will be aborted.
#
# Note that empty commits are commented out

The key point to note here is that the editor displays the commits in reverse order starting from 4 commits back, which was defined by HEAD~4, they also contain a commit command all set to pick which is the default.

What we want to do is keep a single commit but merge all other commits into one, to do this we will edit the commands next to each commit, except the top one, in the editor.

Using your keyboard, press s to go into INSERT mode, replace pick on all commit lines except the top one with fixup or f and replace the top commit with reword or r, then press esc to leave INSERT mode. You will end up with something like this…

reword 83bddef Initial commit
fixup 67a35d7 Stopped for break
fixup fdabd0d Complete
fixup 37b5bf3 Fixed typos

So what is going on here?

The above commands squash the three commits into the top commit discarding any commit messages from the log (fixup) and also give us the chance to amend the commit message of the remaining commit to something more appropriate (reword).

Press : followed by x and press enter, this will save your changes and start the rebase.

Next, you will be presented with a screen displaying the commit message of the commit you marked with reword. Edit the commit message in the same way as you did for the previous step and save your changes in the same way.

You should now recieve a success message in the console, Successfully rebased and updated refs/heads/your-branch..

If you view the git log again, git log --oneline, you will now find just a single commit, with the other commits no longer showing as they are now merged with the one remaining commit.

Easily authenticate with and call the Microsoft Graph using Office 365 CLI and PowerShell Core

2019-11-05T00:00:00+00:00

This post will show you how you can easily authenticate with and call the Microsoft Graph using using Office 365 CLI and PowerShell Core.

We start by entering a PowerShell Core interactive session using pwsh -NoLogo, the -NoLogo switch hides the copyright banner at startup.

Once into the pwsh session, we authenticate with Office 365 using the login command in the Office 365 CLI. This command will initiate the device login process as default however this can be changed to use a specific username and password or certificate, if required.

Once authenticated, we use the accesstoken get command to return a new access token specifically for the Microsoft Graph, the Uri of which is passed in as the value of the resource parameter, -r https://graph.microsoft.com.

Now that we have our access token, we can pass this into the Authorization header of a HTTP request as a Bearer token, the request is invoked by the Invoke-WebRequest cmdlet which performs a GET request to the Uri of a Microsoft Graph endpoint, which in this example is the me endpoint which returns information about the currently logged on user.

The HTTP response is returned as an object containing the JSON response which is contained in the Content property of the repsonse. We parse the response content to create a PowerShell Object from the returned JSON using the ConvertFrom-Json cmdlet that we can then inspect. Easy!

Although this example uses the Microsoft Graph, we can use this same approach to return access tokens for other services. For example, we could pass https://tenant.sharepoint.com as the value of the resource parameter when invokeing the accesstoken get command to return an access token for a SharePoint Online tenant instead.

This post was inspired by a demo presented by Lee Ford (@lee_ford) at the Global Microsoft 365 Developer Bootcamp held in Nottingham, where he demonstrated how he used PowerShell Core to call the Microsoft Graph. This post simplifies the authentication by using the Office 365 CLI. Thanks Lee 👍🏻

More information

How to use Visual Studio Code Remote Containers to develop Microsoft Teams apps

2019-10-30T00:00:00+00:00

This post will guide you through the process of creating and configuring a remote development container within Visual Studio Code for Microsoft Teams app development. The ‘Visual Studio Code Remote - Containers’ extension lets you use a Docker container as a full-featured development environment.

Prerequisites

This guide assumes that you have Docker already installed configured to use Linux containers and is running, see Docker Install for more detail.

Create the project folder

First we need to create an empty folder for our project.

Open a terminal session
Create a new folder for your project
- mkdir teams-remote-container
Change into project directory
- cd teams-remote-container
Open folder in Visual Studio Code
- open .

Install VSCode Remote Development Extension Pack

To enable the remote development functionality within Visual Studio Code you will need to install an extension from Microsoft, see Remote Development Extension Pack on the marketplace.

Open Extensions marketplace from the Side Bar
Search for Remote Development
Install the extension

Add Development Container Configuration Files

Next step is to create a base remote container configuration within the empty project.

Open the command palette
Search for and select the Remote-Containers: Add Development Container Configuration Files... command
From the Add Development Container Configuration Files menu, type node and select Node.js (latest LTS) & Typescript

After completing the above steps you will find a new folder in your project folder called .devcontainer which contains two files, devcontainer.json and Dockerfile.

A prompt will be displayed asking if you want to reopen the project in a container, ignore this

Update the Dockerfile

Next step is to update the base Dockerfile to use a lighter base Docker image Node.js and include the dependencies required for Microsoft Teams app development.

Open Dockerfile
On line 6, replace FROM node:lts with FROM node:slim
On line 37, replace && npm install -g tslint typescript \ with && npm install -g tslint typescript yo gulp-cli generator-teams \
Save the file

Update devcontainer.json

Next step is to change the VSCode configuration file which VSCode will use when instrucing Docker to build and start the container.

Open devcontainer.json
Update name to from Node.js (latest LTS) & TypeScript to Microsoft Teams Development
Uncomment line 14 and replace "appPort": [] with "appPort": [3007,9229],
Uncomment line 17
Uncomment line 22 and replace "runArgs": [ "-u", "node" ], with runArgs": [ "-u", "node" ],
Save the file

Reopen the project

Now that we have configured our remote container, we are now ready to reopen the project inside the Container.

Open the command pallete or click the Remote Container icon (><) in the bttom left of the status bar
Search for and select Remote-Containers: Reopen in Container

VSCode will instruct Docker to build the Dockerfile, generating an image with all the required dependencies installed, reopen the project within the context of the container and open an interactive bash terminal session.

Scaffold your Microsoft Teams project

Now that the container is running, we can run commands inside it to scaffold our new project.

You do this by executing yo teams from the terminal session to start the Microsoft Teams Yeoman generator.

After your project has been created, run npm run-script debug to start the ngrok server. Opening a browser window and navigating to http://localhost:3007 will display the debug web server running within the container.

Update devcontainer.json to apply project environment variables in container

When a new project has been created a .env file is created, as we are running in a container we need to tell Docker to use this file to update the environment variables within the running container.

This step is important for when you want to package your app as environment variables are used in the packaging process

Open devcontainer.json
On line 22, replace runArgs": [ "-u", "node" ] with runArgs": [ "-u", "node", "--env-file=.env"]
Save file
Open the command pallete, search for and select Remote-Containers: Rebuild Container

Closing connection

When you are done, you can close the project and the container by clicking on the DevContainer icon in the bottom left of the status bar and selecting Close remote connection

Simplify your provisioning with Azure Automation, PnP PowerShell and Microsoft Flow

2019-08-06T00:00:00+00:00

The age old task of automating the provisioning of SharePoint site collections has always brought about new ways of doing things, we developers are always on the look out for anything that will make this process simpler and more automated than ever.

Earlier this year, I really wanted to get back into speaking at local user groups, so I put together this session and presented it to the Birmingham O365 User Group, it was really well recieved and the feedback I got was amazing.

Since then I have repeated this session at the Nottingham, Leeds and Glasgow User Groups, the latter of which was done remotely and also recorded. I hope you enjoy :)

Please be aware that it was recently announced that the Azure Automation connector, along with all other Azure based connectors, will require a premium licence from 1st October 2019. For more information on the licence changes here

Example runbooks and the presentation slides can be found on GitHub here

Finally, I’d like to thank all the organisers of the user groups that accepted my requests or asked me to present this session, without you giving up your time to run these events, it would not be possible 👏🏻

Veronique Lengelle (Glasgow)
- @veronicageek
Matt Weston (Birmingham)
- @MattWeston365
Simon Doy & Simon Hudson (Leeds)
- @simondoy
- @simonjhudson

Provision modern webparts on SP2019 modern pages using PnP PowerShell

2019-06-03T00:00:00+00:00

🚨 UPDATE 🚨 You can now use Add-PnPClientSideWebPart cmdlet as it is now enabled for use in the SharePoint Server 2019 PnP PowerShell module.

PnP PowerShell is my go to for automating most things in SharePoint, whether that is the Online or On Prem flavours. However there are times when there is a specific cmdlet only available in SharePoint Online, I recently came across this whilst working on a SharePoint 2019 project using the Modern page experience and SharePoint framework.

Add-PnPClientSideWebPart is only available for SharePoint Online, so I had to get creative. The below script will enable you to add 3rd Party or out of the box modern web parts for a modern client side page, using the same usage as the Online cmdlet.

Bulk insert array of JSON objects into Azure SQL Database using Microsoft Flow

2019-03-03T00:00:00+00:00

Following on from my previous post, Export Time Entries from Harvest using Microsoft Flow, I ended up with an array of time entries objects and now I need to store it all away in an Azure SQL table.

The easiest approach would be to utilise an Apply to Each action to loop over all of the entries pulled from the Harvest API and in each loop use the Insert Record action to add a new item to the table.

Whilst this works, the Apply to Each is slow and when dealing with thousands of records, you don’t want to be executing individual requests to insert each row. Where possible, you should always try to avoid using the Apply to Each action to keep your Flows performant (see Removing unnecessary Apply to Each action when using Get Items action).

So how do we add thousands of rows quickly and without using a loop? The answer lies with Azure Blob Storage and a SQL Stored Procedure.

I created an Azure Storage Account called ‘harvestdata001’ and a blob container called ‘harvestdata’, this is be where the array containing the time entry objects will be saved to as a JSON file. This is done easily by using the Create blob action in Flow, passing the array as File content, giving it a filename and choosing an appropriate path, ‘harvestdata’ being the root of the blob container.

Now that I have the data stored where I need it, I then set about configuring Azure SQL so that it knows where to look.

Executing the above SQL against the database, it does a number of things, it configures a master password for the database (this is required to create the credential and external storage), an external datasource credential and the external datasource itself which is associated with the credential created in the previous statement. In SQL Server Management Studio, you can see the external storage under External Resources.

The next step is to create the stored procedure which will handle the importing of data.

Executing the above SQL against the database creates a new stored procedure called ImportTimeEntries, it accepts single parameter called Run which expects the number 1 to be passed, otherwise it doesn’t run, this reason for this will become apparent later.

In my scenario, this stored procedure also truncates the time entries table and then imports all the data from the external storage, not the most elegant of solutions but serves its purpose (for now 😀).

After the truncate statement is where the real magic happens, the FROM statement loads the JSON file from Azure Storage and the WITH statement creates an in-memory resultset, each row defining the column name, data type and an expression which maps property in the JSON to the column, this is particularly useful when the JSON property name does not exactly match the column name in your SQL Table.

The in-memory resultset is then used as the data source for the SELECT and INSERT statements to add the rows to the TimeEntry table.

Moving back to Flow, all I needed to do was to add a new action, using the Execute Stored Procedure action I execute the ImportTimeEntries procedure. Here is where the Run parameter was needed, not sure if this is a bug or by design but Flow doesn’t like it if you try to execute a stored procedure without passing a parameter.

As I mentioned at the start of this post, the reason for doing all of this was for performance.

It takes 4 minutes to pull all the time entries from the Harvest API, thats 3993 rows but it takes only 4 seconds to transform and import all of that data into SQL. Impressive! 😀

Export Time Entries from Harvest using Microsoft Flow

2019-02-27T00:00:00+00:00

Harvest, we are big fans of the time recording system @idlive and have been using it for years to track time spent on delivering projects for our clients. After a discussion one day with our Delivery Lead, he expressed an idea… “wouldn’t it be great if we could share the time tracked on our projects directly with our customers?”. An idea was born and a solution was to present itself…

One Sunday afternoon I sat down to look at the first problem… “how do I export time entries out of Harvest?” which this post tackles.

Naturally my first port of call was Microsoft Flow. I knew that there are serveral standard Harvest connectors provided, unfortunately for time entries, you can only return a single entry by its ID and create a new entry, neither of which were really going to help me.

In this situation, when there is no standard way to integrate with a third party system, the best way is to create a Custom Connector to “fill in the gaps”.

Harvest has a mature and well documented API, one of many reasons why its so good, so this was a fairly straight forward task to create a connector that securely calls the Harvest API to return time entries for all projects.

The action that I created, List all time entries, takes three parameters, the Harvest Account ID for the account you want to return data from (this is required for all requests), the date I wanted to return time entries from, (we have over 5 years worth of time entries so don’t want them all) and a page number.

So great, I now have the ability to pull back time entries, job done… well, maybe not… you see, the Harvest API only returns 100 entries at a time (see Pagination, so I needed to come up with a way of how to loop through all of the pages.

Enter the ‘Do Until’ action, this allows us to repeat an series of actions until a certain condition is met, in this case I needed to keep calling the Harvest API but each time asking for the next page of results until the current page was higher than the total pages for my query.

Using a combination of variables to store the current page value (HarvestPage) and total pages value (HarvestTotalPages), I update these in the Do Until loop using the Increment Variable and Set Variable actions respectively.

So now I have worked out how to call the Harvest API securely and being able loop through all the pages of time entries. I now needed to be able to store the response from each API call to build up a single collection of all the time entries I need.

The way to do this was to initialize an Array variable (HarvestTimeEntries) and by using a Compose action within the Do Until loop, I use the Union() function to merge the two Arrays into one, the initially empty, HarvestTimeEntries variable and the response from the latest Harvest API call.

Great, so I have all the time entries I need in one place but now I need to be able to store in a place where it can be reported on.

This next step would involve storing each time entry returned in Azure SQL. Now you would think that this again would be something that Flow can do easily, which it can, but with a downside… its very slow.

Looping through all the time entry objects in the HarvestTimeEntries array and using the Insert Record SQL Server action took an absolute eternity to finish. Flow is really poor at handling large iterations, we are talking thousands of rows here, so it wasn’t a great solution and there had to be a better way… which there is…

I will follow up with another blog post of how I import thousands of records stored in JSON format, directly into Azure SQL Server in a matter of seconds by using a single action in Flow.

The Harvest API Custom Connector that I use in this Flow is on Github here, with instructions on how to setup the connector in your own tenant.

Complete Flow

Identify SharePoint Online Site Experience by PowerShell

2018-12-15T00:00:00+00:00

We live in a world where SharePoint has become somewhat of a split personality, we have the Modern experience and the Classic experience, confusing for end users but also difficult for administrators to track.

I had some spare time this weekend and noticed this tweet on the #sphelp hashtag.

SharePoint Online PowerShell question: Is there a way to pull a list of sites with a property for classic or modern? #SPHelp @ciphertxt @PlateSpinner @ToddKlindt @O365Adam
— Sam Larko (@SPSamL) December 14, 2018

So thought I’d take a look, the result of which was this script.

Which gives you the below output.

It uses the Microsoft.Online.SharePoint.PowerShell model to return all SharePoint Online sites using Get-SPOSite for a connected tenant and using an expression column, it determines whether the site is modern or not based on its template.

The list of templates (to my knowledge) that determine a modern site are

Template	Description
STS#3	Modern Team Site with No Office 365 Group
GROUP#0	Modern Team Site with Connected Office 365 Group
SITEPAGEPUBLISHING#0	Modern Communications Site

A good starting point if nothing else to track down those classic sites or just to see how much spread of site experiences you have across your tenant 😀

Limited patching of SharePoint Hyperlink fields in PowerApps

2018-12-14T00:00:00+00:00

PowerApps and SharePoint have a strange relationship, on one hand they work great together for simple things, but sometimes they just don’t get along in the way you would expect.

A colleague who was working on an app we are building for a client was having issues updating the hyperlink field, his actually issue was more around passing the value of a textbox which happened to be a number not text, but the issue was raised.

I was busy at the time so threw out a tweet to get some traction on solving the issue whilst mentioning some well known PowerAppers in the process.

Anyone know if it is possible to update a SharePoint Hyperlink field using Patch() in @PowerApps ? @ShanesCows @8bitclassroom #PowerAppsHelp
— Garry Trinder (@garrytrinder) December 14, 2018

Shane thankfully replied and helped push me in the right direction but gave me confidence that it was indeed possible.

If I remember correctly you can update either the URL or the text but not both? Make a sample app with the Hyperlink column and see what options it offers you. Good place to start.
— Shane Young PowerApps MVP (@ShanesCows) December 14, 2018

So I did exactly that, built a PowerApp and tested it myself.

As a SharePoint guy of many years, I know that a Hyperlink field is made up of two parts, Description and Url, the Description being the display text of the link when displayed in a SharePoint list and the Url, the target of the link.

However, it appears that PowerApps does not, it only knows half the truth, the Url.

Take the patch below, it creates an item in a SharePoint list with the Hyperlink field set to a location on Google Maps…

… but it updates both the Url and Description property to the same value that is passed in.

To try and solve this, I’ve tried the old SharePoint tricks of formatting the string passed in the Patch in particular format, some of them I’ve tried below.

{url};#{text}
{url}, {text}
{url},{text}
{url};{text}

None of them updated the Description, it just saved the full string in the Url field, breaking the link.

Investigating more on this, I looked at how a NewForm would treat a Hyperlink field, and it treats it in the same way, you just get a single field and there is no way of updating both the Url and Description independantly of each other.

For our scenario, we could handle the fact that we couldn’t update the Description but it worth knowing that this isn’t possible in PowerApps yet.

The only way that I think you could do this is by using a Flow which uses the SharePoint HTTP action to update the item using the REST API or by creating a Custom Connector, but as Beau Cameron points out below, there are license considerations to be made.

Ya, just be aware of the Flow and PowerApps licensing changes coming if you go that route...
— Beau Cameron (@Beau__Cameron) December 14, 2018

Big thanks to Beau for giving me the push to post this and help get over my blog post anxiety, cheers buddy 😊👍🏻

Flow loves Legacy Systems

2018-11-09T00:00:00+00:00

Legacy systems… yes, you know the ones… where an API is a collection of folders where flat files are picked up by scheduled tasks import tasks… no web APIs here… built using old technologies and running on a server in the corner of the office. This is far removed from cloud computing, but it doesn’t mean that it can’t make use of what the cloud has to offer.

We recently took on a project with a customer who had one of these legacy systems, the system is used heavily within their business to manage the day to day operations of their maintenance engineers as well as invoicing, so quite important, abeit old, it still delivers business value.

We have been brought in to help modernise the way that there maintenance engineers send updates to the back office team, who have the task of importing these updates into the system using a combination of Excel spreadsheets and flat files. Not the quickest or easiest of processes to deal with, but it works to a degree.

As part of our modernisation, we are building a PowerApp that will allow the maintenance engineers to remotely view the jobs they need to carry out, complete them and have the ability to create new jobs adhoc, all whilst updating the legacy system. Easy right…

Well, not so much, remember this is a legacy system, it doesn’t have a web API that we can just call and get an instant response, it uses flat files and we have the small problem of getting this data from the cloud onto the server sat in the corner of the office, oh and we have no way of knowing whether the file we just dropped on to the server has been sucessful or not, remember we don’t get an instant response.

The good news is Flow can help handle all of this and quite easily…

The first step was to setup the On-premises Data Gateway, this is what allows us to connect to our local server in Flow and using it in conjunction with the File System connector, we can move files using into a destination folder on the server ready for importing.

Using a SharePoint Document Library to store a template import file, we get raw text content using the SharePoint Get File Content action. The template contains a number of tokens for us to replace with our own values using a series of Compose actions and the replace expression. Each compose action uses the previous action output so that at the end we have a a text file that resembles what we need to send to the server for import.

We take that file and drop it on the server using the File System Create File action, as well as dropping the same file into another SharePoint Document Library so that we have a place where we track the files that we have sent and when.

The import process of the legacy system is a simple one, drop the file into a process folder, if it works, it is dropped into a success folder, if it fails, it well you get the idea… so we can reuse the File System triggers to check for new files in a specific location.

We have built two flows that again use the File System connector to trigger when a new file is added to the success and failure folders respectively, we can then use this to notify invoicing of a new completed job or notify someone to investigate why the import failed.

In all, the integration side of the project has taken very little time to implement, literally hours, which I find amazing. In years gone by this level of integration would have resorted to writing code and would have taken days, even weeks, to achieve. Flow has taken all that pain away and given much more flexibility to what traditionally has been rigid, costly exercise.

So if you have old systems, don’t think that they can’t have their day once again, Flow can help 😀

Removing unnecessary Apply to Each action when using Get Items action

2018-07-19T00:00:00+00:00

Flow is great, but it can add unnecessary Apply to Each actions which can slow you down and clutter your Flows but using an Expression can help.

Whilst working on Flows to automate business processes for clients, I’m always looking for ways that I can streamline them, removing actions that appear unnecessary but are easy to add to your Flow sometimes without you realising.

One of those cases is you use the SharePoint Get Items action, being a SharePoint guy I use this action alot, usually to query a list to return a single item based on some identifier that is not the Item ID, such as a unique Title.

Get Items action will always return an Array of Items even if you only want one Item

The response from this action will always return an array of SharePoint list items, even if you specify 1 in the Top property of the action, telling the action that you are only interested in one item.

In future steps if you add a property from this action into another action, that action is automatically placed in an “Apply to Each” action, just for a single item.

The example below shows how this happens, we are getting a single car from a list of Cars and using it in the next action.

Creating a loop for a single item is an unnecessary overhead, it would be better to just access the first item directly without the loop.

This is where an Expression and the First() function comes in, allowing us to remove the Apply to Each from the Flow.

The expression used above is in full below

first(body('Get_Car_from_Cars_List')?['value'])?['Manufacturer']

body references are always the name of the actions but spaces replaced with underscores. Name your actions wisely!

Although this is a very simple example, when we are building Flows it is quite easy for them to become large quite quickly so any way of removing actions is a good thing.

References

Workflow Definition Language functions reference for Azure Logic Apps

Start With Why

2018-05-24T00:00:00+00:00

A good friend sent me a link to a video one evening, the video just so happened to be one of the most watched TED Talks of all time, currently racking up a cool 38M views and it was a revelation.

Following watching this video, I then went onto to also read Simons book on the subject, Start With Why and his next book, Leaders Eat Last.

They are both incredibly inspiring and I urge you to read them but the core message is simple, people are inspired by why you do the things that you do, not how or what you do.

Its such a simple message, but something also that is hard to quantify, most people know what they do and how they do it, but only a small number know why they do the things they do. I find this fascinating, that something so simple is so hard to discover, why do you do what you do?

The Golden Circle

The Golden Circle is how Simon “codified” his message, starting from within the circle, Why drives behaviour, How and What are the tools to help achieve that behaviour. I’m not going to go into detail about how that behaviour is changed, Simon can do it so much better than I can, in the video above.

Finding My Why

So after reading the books and watching the videos, it was time to try and discover my why, my reason for doing the things that I do.

After some thought, my Why is quite simple, the driving force behind the things I do is around my enjoyment of learning, finding better ways of doing things and sharing that knowledge with others to help them come up with innovative solutions to their own problems.

I just happen to do that through the use of the Microsoft cloud, be it Azure, Office 365, SharePoint Online, Flow etc and by writing posts on this blog I plan to share that knowledge.

My name is Garry, I am driven by finding better ways of solving problems to help people become more productive (why) by sharing my knowledge with others and engaging in discussions (how), it will inspire us to create innovative solutions to problems using the Microsoft cloud (what)

Garry Trinder

My top three Microsoft 365 sessions at Microsoft Inspire 2022

1️⃣ 🧘 Bring all your essential apps, tools, and processes into the flow of work

2️⃣ 💰 Create New Revenue Streams with Teams apps

3️⃣ 🎓 Viva Learning APIs public preview: How to leverage these connectors

Run Github Actions locally using act

Get verified! Setup git commit signing on Windows

Verify that GPG is in PATH

Generate GPG key

Export your key

Add GPG key to GitHub

Configure git to sign commits

Test your changes

Useful Resources

Clean up completed Microsoft To Do tasks using CLI for Microsoft 365

Clear Power Apps Desktop SaveData cache

Export all your Power Automate Flows using CLI for Microsoft 365

Attempted Telephone Banking Scam

Run CLI for Microsoft 365 in Docker

My WSL2 and Windows Terminal setup

Windows Subsystem for Linux (WSL) 2

JetBrains Mono

Windows Terminal

oh-my-zsh

Spaceship ZSH

oh-my-zsh Plugins

git

zsh-syntax-highlighting

zsh-autosuggestions

Node Version Manager (NVM)

Command Line Tools

CLI for Microsoft 365

GitHub CLI

Azure CLI

My Configuration Files

Zsh Configuration

Windows Terminal Settings

Implement Microsoft Graph app-only calls the easy way using Azure Logic Apps and Azure Managed Identity

Provision the Azure Logic App

Enable Azure Managed Identity on the Azure Logic App

View Azure Managed Identity Service Principal

Grant the Azure Managed Identity Service Principal Microsoft Graph app only permissions

Configure the Azure Logic App

Manually run the Azure Logic App

Cleanup

Summary

Inconvenient Microsoft Word comments in Microsoft 365

Word Online in Teams

Microsoft 365 Word

Word Online in Browser

Word for iOS (iPad)

Summary

Using your own Azure AD identity with Office 365 CLI

Register Azure AD application in your tenant

Confgure Authentication settings

Configure API Permissions

Create Office 365 CLI environment variables

Login and consent

Find out more

Appendix: Persisting environment variables

Recovering a pull request after accidentally deleting the source branch

Identify and report on Microsoft Teams Private Channels using Office 365 CLI and PowerShell

Getting started with Office 365 CLI and PowerShell

Why would I want to use the Office 365 CLI?

Installing the Office 365 CLI

Setup command completion

View command help

Authenticating with your Office 365 tenant

Executing commands from PowerShell

Working with data

Find out more

Keeping your fork up to date

Add the upstream remote

Keep dev in sync

Keep master in sync

Keep old branches in sync

Keep your upstream in sync

Squash your commits using git interactive rebase

Easily authenticate with and call the Microsoft Graph using Office 365 CLI and PowerShell Core

More information