Creating a Teams Directory with PowerShell

Teams Directory Lets Users Know What’s Available

Blog posts, articles, and books are hostage to the passing of time and the evolution of technology. I’ve known this truth for years, but it does keep on recurring at regular intervals. For instance, this week I’ve been working on my session for the European SharePoint Conference (ESPC), which takes place in Copenhagen from November 28 to December 1.

My session is about managing Teams for success, a topic that’s impossible to cover in the allotted hour. Focus is therefore necessary, and I’ve decided to discuss issues like Teams sprawl and automation. While preparing my slides, I looked at a article I wrote in April 2019 covering the lack of a Teams directory and how to generate such a directory. A Teams directory helps those who create teams know if a suitable team is already available. It also helps users find teams that they might want to join.

Finding Areas for Improvement

The code in the script I wrote then is not what I would write now. This is natural. We all accumulate knowledge over time and that knowledge guides us on how we solve problems. New technology and updates become available too, and the combination of new technology and new knowledge makes it inevitable that the solution to a problem will probably explore new approaches. There was nothing I could do but start reviewing the code to find areas for improvement.

After the review, I found one technology gap and a couple of ways to improve the script:

  • Teams has changed the format of the internal identifier used to create the deeplink to a team. Recently-created teams use the new format while older teams have the old format. Obviously, the code needs to cope with both formats.
  • The old script uses cmdlets from the Microsoft Teams and Exchange Online management PowerShell modules. Although Microsoft has improved both modules since 2019, using the Microsoft Graph PowerShell SDK should aid performance, especially when the number of teams in a tenant grows into the thousands. At least, that’s the theory.
  • The output (an HTML file and a CSV file) could be improved. For instance, the ImportExcel module supports the generation of nicely-formatted Excel worksheets instead of plain CSV files.

Rewriting Code

Replacing the Get-Team and Get-UnifiedGroup cmdlets with the Microsoft Graph PowerShell SDK is straightforward. The Get-MgTeam cmdlet does the job for both. Thus, to find the set of teams in a tenant, we run:

[Array]$Teams = Get-MgTeam -All

This is equivalent to running the Get-MgGroup cmdlet with a filter to find team-enabled groups:

[array]$Teams = Get-MgGroup -Filter "resourceProvisioningOptions/Any(x:x eq 'Team')" -All 

Afterward, it’s a matter of looping through the set of teams to retrieve information about each team. This is when I hit a problem in that the data returned for a team by Get-MgTeam doesn’t include the internal identifier (a value like 19:BxPfo_xgaoGDQMvyuDzztvrQjLWNRvY6sGoLWGLriHA1@thread.tacv2). This is true even if you specify that the cmdlet should return the InternalId property by specifying it in the Property parameter.

The internal identifier is necessary to form the deeplink for a team. A full deeplink contains the internal identifier, the group identifier for the team, and the tenant identifier. A user can click a deeplink to go direct to a team and apply to join the team if it interests them. Here’s what a complete deeplink looks like:

The workaround is to run Get-MgTeam to process each team in the loop. For example, this is how the code fetches the InternalId:

$InternalId = Get-MgTeam -TeamId $T.Id | Select-Object -ExpandProperty InternalId

Although a solution exists, it’s neither elegant nor satisfactory. The extra calls to Get-MgTeam slow down the script and remove some of the benefit of using Graph API requests instead of the Teams and Exchange Online cmdlets. Not returning the internal identifier for multiple teams might not happen for the sake of performance (the identifier might require retrieval from a separate data store), but it seems like a bug when the cmdlet fails to retrieve the property when explicitly requested. I used version 1.15 of the Microsoft Graph PowerShell SDK and it’s possible that Microsoft will fix the problem in a future version.

The Value of a General-Purpose Cmdlet

The previous iteration of the script uses the Get-UnifiedGroup cmdlet. One of the big advantages of this cmdlet is that it returns interesting information like the group owners and counts for members and external members. You don’t have to request this information. The cmdlet returns it automatically.

However, switching to the Microsoft Graph PowerShell SDK means that the script must include code to retrieve this information. This isn’t very difficult (this article covers the basics), but it’s another thing to do.

Improving Output

As noted above, I used the ImportExcel module to output an Excel worksheet instead of a CSV file. I also wanted to improve the effectiveness of the HTML page by making the deeplink clickable. Playing around with adding the HTML <a href=> tag didn’t work so well until I formatted the output with these commands:

Add-Type -AssemblyName System.Web
[System.Web.HttpUtility]::HtmlDecode($htmlreport) | Out-File $ReportFile -Encoding UTF8

Figure 1 shows the HTML output. Obviously, other team properties could feature in the directory. The intention here is to explore what’s possible and demonstrate the technique rather than to set a standard for Teams directories.

Teams Directory in a HTML file
Figure 1: Teams Directory in a HTML file

For instance, the directory includes all teams. You might decide that it’s better to include just public teams because users can join these teams without owner approval.

Making the Directory Available to Teams Users

Several ways exist to make the Teams Directory available to users:

  • Publish the page on a corporate web site.
  • Import the Excel worksheet into a SharePoint Online list and make the list available to users (for example, as a channel tab).
  • Use the Print function from a browser to create a PDF. Upload the PDF to SharePoint Online and create a channel tab pointing to the PDF. Remember to hold down the CTRL key when clicking the links in the PDF.
  • Import the HTML and XLSX files into SharePoint Online and allow users to download the files from there.

Figure 2 shows the how the Teams viewer displays a PDF created from the web page that was imported into SharePoint Online and accessed through a channel tab.

Teams Directory viewed as a PDF file accessed through a channel tab
Figure 2: Teams Directory viewed as a PDF file accessed through a channel tab

Ongoing Maintenance is the Hard Part

Creating a Teams Directory isn’t particularly difficult. In this case, the only technical difficulty was figuring out how to create the deeplink. The issues involved in the ongoing maintenance of the directory are more prosaic, such as:

  • How often do you refresh the directory.
  • What mechanism to use to refresh the directory (An Azure Automation runbook is a good way to generate files periodically).
  • What’s the best way to make the directory available to users?

The updated script is available on GitHub. If you find another way to generate a Teams Directory, please let me know with a comment.

Leave a Reply

This site uses Akismet to reduce spam. Learn how your comment data is processed.