SharePoint Online, Viva , Teams, Power Platform, Azure, Identity

Introduction

Deep Linking allows uses tor navigate within your apps. Your app can have MS Teams development instance like Bot, Messaging Extension, or Flow Bot send the message notification to user for an important activity. Deep Link navigates the user to the tab so that the user can view more details about activity.

Deep Linking with Tab

Deep Links can be created for Teams entities. In a typical scenario, it is used to create a link that navigates to content and information within your tab. It reduces the context switch. It keeps the user within Teams context without refreshing.

Note

The tab can be defined at Personal Tab with personal scope, Channel or Group Tab with teams or group scope.

The following format can be used for deep links in Bot, Connector, Messaging Extension Cards.

https://teams.microsoft.com/l/entity/<appId>/<entityId>?webUrl=<entityWebUrl>&label=<entityLabel>&context=<context>

The query parameters are,

appId
The ID from your manifest; for example, "fe4a8eba-2a31-4737-8e33-e5fae6fee194"
entityId
The ID for the item in the tab, which you provided when configuring the tab; for example, "id123"
entityWebUrl or subEntityWebUrl
An optional field with a fallback URL to use if the client does not support rendering the tab; for example, "https://tasklist.example.com/123" or "https://tasklist.example.com/list123/task456"
entityLabel or subEntityLabel
A label for the item in your tab, to use when displaying the deep link; for example, "Task List 123" or "Task 456"
context
A JSON object containing the following fields:
subEntityId
An ID for the item within the tab; for example, "task456"
channelId
The Microsoft Teams channel ID that is available from the tab context; for example, "19:cbe3683f25094106b826c9cada3afbe0@thread.skype". This property is only available in configurable tabs with a scope of "team". It is not available in static tabs, which have a scope of "personal".

To implement this, you can "copy link" action from Tab or action item. You can call this url on button click, which designed via adaptive cards. when you call or click the button which is configured with copy link based url. It will gte back into same context and your tab will be reloaded.

Note

This deep link is different from the link provided by the copy link tab menu, its just generate deep link the points to tab.

Navigate to Channel Tab, which you want to connect as deep link.
Click on the "..." top right parllel to tab name.
Click to "Copy link to tab"

Sample Url will be generate,

https://teams.microsoft.com/l/entity/b702977d-06e1-42cc-9166-25ad4d39a9f9/_djb2_msteams_prefix_1145688105?context=%7B%22subEntityId%22%3Anull%2C%22channelId%22%3A%22<<channel id>>%40thread.tacv2%22%7D&groupId=<<group id>>&tenantId=<<tenant id>>

Note

Sub Entitiy Id can used to pass as parameterize value, if we need to simply navigate to tab, In that scenario it can be used as null.

Deep Link to tab embed into below adaptive Card, which used into power automate to send notification, On click on button, it will navigate to Tab as well as pass parameterize url.

{  
    "type": "AdaptiveCard",  
    "version": "2.0",  
    "body": [  
        {  
            "type": "TextBlock",  
            "text": "New Ticket Created",  
            "weight": "Bolder"  
        },  
        {  
            "type": "FactSet",  
            "facts": [  
                {  
                    "title": "Ticket ID",  
                    "value": "@{triggerOutputs()?['body/ID']}"  
                },  
                {  
                    "title": "Ticket Detail",  
                    "value": "@{triggerOutputs()?['body/Title']}"  
                },  
               {  
                    "title": "RequestedBy",  
                    "value": "@{triggerOutputs()?['body/RequestorName/DisplayName']}"  
                },  
               {  
                    "title": "Severity",  
                    "value": "@{triggerOutputs()?['body/Severity/Value']}"  
                },  
               {  
                    "title": "Category",  
                    "value": "@{triggerOutputs()?['body/Category/Value']}"  
                }             
            ],  
            "spacing": "Medium"  
        },  
        {  
            "type": "ActionSet",  
            "actions": [  
                {  
                    "type": "Action.OpenUrl",  
                    "title": "View Ticket",  
                    "url": "https://teams.microsoft.com/l/entity/b702977d-06e1-42cc-9166-25ad4d39a9f9/_djb2_msteams_prefix_1145688105?context=%7B%22subEntityId%22%3A@{triggerOutputs()?['body/ID']}%2C%22channelId%22%3A%2219%3A123c0abe7f0041c68066801eb8a0f8d2%40thread.tacv2%22%7D&groupId=e8312347-f8cd-4177-8661-88b335dab65b&tenantId=4cd94c60-104d-4a43-b441-e735fc34830b",  
                    "style": "positive"  
                }  
            ]  
        }  
    ],  
    "$schema": "http://adaptivecards.io/schemas/adaptive-card.json"  
}  

Finally, we need to find out, how to consume item id into SPFx webpart. It can be achived easily with the below steps.

Package needed to import,

import * as microsoftTeams from "@microsoft/teams-js";  

Initialize into constructor,

microsoftTeams.initialize();  

SubEntityId used to get the parameterized value, assigned to provided variable and same can be used further.

public componentWillMount() {  
     
    microsoftTeams.getContext(teamsContext => {  
    this.itemId = teamsContext.subEntityId;  
    });  
  }  

How easy and quick it was to build a custom Custom Deep Link to Tab.

I hope you have enjoyed and learned something new in this article and Happy Learning !!

Introduction

This article will cover, How to consume Sharepoint online CSOM (REST API) operation using .NET Core 3.1 framework into a console application.

The topic needs to cover here:

Create Azure AD Instance with Delegate Permission.
Create Console Application and Add Microsoft.SharePointOnline.CSOM Nuget Package.
Add Authentication Manager Class to generate the access token.
Get Access Token & access SharePoint Online List data

Step 1 - Create Azure AD Instance with Delegate Permission

Note

Users should have access to Azure Active Directory.

Login to https://portal.azure.com
Search and Select Azure Active Directory

Once the user selects Azure AD, the App registration page will appear.

Select App registrations
Select +New registration

Once the user selects new registration, add below details

Name "spocsom-api", user can add as per project namespace or naming convention guidelines.
Select "Account in this organization (single-tenant)
Click on the Register button

Grant access to SharePoint Online.

Select API Permission
Click to Add Permission
Search and Add SharePoint from Request API Permission

Delegate Permission, It required where user application needs to access data as the signed-in user.

Select Add a Permission
Selection Delegate Permission
Search and Select Sites
Choose "All Site.Read" -> This is not site specific but quite secure , It will just come into use to generate token, not going to grant access to the site to access the content.
Click to "Add Permission"

Grant Admin Consent

Grant permission by admin or user as part of the consent process.

Select "Grant admin consent for default directory and click ok to proceed.
All added api will show granted admin consent on behalf of the user. so it will not prompt for consent.

Allow Public Client Flows

The app is going to collect username and password into plain text, so it should allow to yes.

Select authentication and scroll down till the end
Under advance settings -> select Allow Public client flows -> Select Yes -> Click on Save to Proceed.

Step 2 - Create Console Application and Add Microsoft.SharePointOnline.CSOM Nuget Package

Login to Visual Studio 2019 and Create New Project
Select ConsoleApp (.Net Core) and Ok to proceed.

Install NuGet Package

Select solution and right-click on dependencies and NuGet Packages

Install the below packages:

Microsoft.SharepointOnline.CSOM
Newtonsoft.Json
System.IdentityModel.Token.Jwt

Step 3 - Add Authentication Manager Class to generate the access token

This class helps us to generate access tokens based on application URI, UserName, Password & Azurre AD App Client ID.

Create Auth Manager Class and Copy paste the below codebase:

public class AuthManager : IDisposable
   {
       private static readonly HttpClient httpClient = new HttpClient();
       private const string tokenEndpoint = "https://login.microsoftonline.com/common/oauth2/token";
       // Replace with Azure AD Client ID -Generated in above Steps
       private const string defaultAADAppId = "Azure Active Director Client ID";

       // Token cache handling
       private static readonly SemaphoreSlim semaphoreSlimTokens = new SemaphoreSlim(1);
       private AutoResetEvent tokenResetEvent = null;
       private readonly ConcurrentDictionary<string, string> tokenCache = new ConcurrentDictionary<string, string>();
       private bool disposedValue;

       internal class TokenWaitInfo
       {
           public RegisteredWaitHandle Handle = null;
       }

       public ClientContext GetContext(Uri web, string userPrincipalName, SecureString userPassword)
       {
           var context = new ClientContext(web);

           context.ExecutingWebRequest += (sender, e) =>
           {
               string accessToken = EnsureAccessTokenAsync(new Uri($"{web.Scheme}://{web.DnsSafeHost}"), userPrincipalName, new System.Net.NetworkCredential(string.Empty, userPassword).Password).GetAwaiter().GetResult();
               e.WebRequestExecutor.RequestHeaders["Authorization"] = "Bearer " + accessToken;
           };

           return context;
       }


       public async Task<string> EnsureAccessTokenAsync(Uri resourceUri, string userPrincipalName, string userPassword)
       {
           string accessTokenFromCache = TokenFromCache(resourceUri, tokenCache);
           if (accessTokenFromCache == null)
           {
               await semaphoreSlimTokens.WaitAsync().ConfigureAwait(false);
               try
               {
                   // No async methods are allowed in a lock section
                   string accessToken = await AcquireTokenAsync(resourceUri, userPrincipalName, userPassword).ConfigureAwait(false);
                   Console.WriteLine($"Successfully requested new access token resource {resourceUri.DnsSafeHost} for user {userPrincipalName}");
                   AddTokenToCache(resourceUri, tokenCache, accessToken);

                   // Register a thread to invalidate the access token once's it's expired
                   tokenResetEvent = new AutoResetEvent(false);
                   TokenWaitInfo wi = new TokenWaitInfo();
                   wi.Handle = ThreadPool.RegisterWaitForSingleObject(
                       tokenResetEvent,
                       async (state, timedOut) =>
                       {
                           if (!timedOut)
                           {
                               TokenWaitInfo internalWaitToken = (TokenWaitInfo)state;
                               if (internalWaitToken.Handle != null)
                               {
                                   internalWaitToken.Handle.Unregister(null);
                               }
                           }
                           else
                           {
                               try
                               {
                                   // Take a lock to ensure no other threads are updating the SharePoint Access token at this time
                                   await semaphoreSlimTokens.WaitAsync().ConfigureAwait(false);
                                   RemoveTokenFromCache(resourceUri, tokenCache);
                                   Console.WriteLine($"Cached token for resource {resourceUri.DnsSafeHost} and user {userPrincipalName} expired");
                               }
                               catch (Exception ex)
                               {
                                   Console.WriteLine($"Something went wrong during cache token invalidation: {ex.Message}");
                                   RemoveTokenFromCache(resourceUri, tokenCache);
                               }
                               finally
                               {
                                   semaphoreSlimTokens.Release();
                               }
                           }
                       },
                       wi,
                       (uint)CalculateThreadSleep(accessToken).TotalMilliseconds,
                       true
                   );

                   return accessToken;

               }
               finally
               {
                   semaphoreSlimTokens.Release();
               }
           }
           else
           {
               Console.WriteLine($"Returning token from cache for resource {resourceUri.DnsSafeHost} and user {userPrincipalName}");
               return accessTokenFromCache;
           }
       }

       public async Task<string> AcquireTokenAsync(Uri resourceUri, string username, string password)
       {
           string resource = $"{resourceUri.Scheme}://{resourceUri.DnsSafeHost}";

           var clientId = defaultAADAppId;
           var body = $"resource={resource}&client_id={clientId}&grant_type=password&username={HttpUtility.UrlEncode(username)}&password={HttpUtility.UrlEncode(password)}";
           using (var stringContent = new StringContent(body, Encoding.UTF8, "application/x-www-form-urlencoded"))
           {

               var result = await httpClient.PostAsync(tokenEndpoint, stringContent).ContinueWith((response) =>
               {
                   return response.Result.Content.ReadAsStringAsync().Result;
               }).ConfigureAwait(false);

               var tokenResult = JsonSerializer.Deserialize<JsonElement>(result);
               var token = tokenResult.GetProperty("access_token").GetString();
               return token;
           }
       }

       private static string TokenFromCache(Uri web, ConcurrentDictionary<string, string> tokenCache)
       {
           if (tokenCache.TryGetValue(web.DnsSafeHost, out string accessToken))
           {
               return accessToken;
           }

           return null;
       }

       private static void AddTokenToCache(Uri web, ConcurrentDictionary<string, string> tokenCache, string newAccessToken)
       {
           if (tokenCache.TryGetValue(web.DnsSafeHost, out string currentAccessToken))
           {
               tokenCache.TryUpdate(web.DnsSafeHost, newAccessToken, currentAccessToken);
           }
           else
           {
               tokenCache.TryAdd(web.DnsSafeHost, newAccessToken);
           }
       }

       private static void RemoveTokenFromCache(Uri web, ConcurrentDictionary<string, string> tokenCache)
       {
           tokenCache.TryRemove(web.DnsSafeHost, out string currentAccessToken);
       }

       private static TimeSpan CalculateThreadSleep(string accessToken)
       {
           var token = new System.IdentityModel.Tokens.Jwt.JwtSecurityToken(accessToken);
           var lease = GetAccessTokenLease(token.ValidTo);
           lease = TimeSpan.FromSeconds(lease.TotalSeconds - TimeSpan.FromMinutes(5).TotalSeconds > 0 ? lease.TotalSeconds - TimeSpan.FromMinutes(5).TotalSeconds : lease.TotalSeconds);
           return lease;
       }

       private static TimeSpan GetAccessTokenLease(DateTime expiresOn)
       {
           DateTime now = DateTime.UtcNow;
           DateTime expires = expiresOn.Kind == DateTimeKind.Utc ? expiresOn : TimeZoneInfo.ConvertTimeToUtc(expiresOn);
           TimeSpan lease = expires - now;
           return lease;
       }

       protected virtual void Dispose(bool disposing)
       {
           if (!disposedValue)
           {
               if (disposing)
               {
                   if (tokenResetEvent != null)
                   {
                       tokenResetEvent.Set();
                       tokenResetEvent.Dispose();
                   }
               }

               disposedValue = true;
           }
       }

       public void Dispose()
       {
           // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
           Dispose(disposing: true);
           GC.SuppressFinalize(this);
       }

   }

Step 4 - Get Access Token & access SharePoint Online List data

Get List Data function get data from SharePoint online List and Print out all result based on return data.

static void Main(string[] args)
{
List<Data> getdata = GetListData();
foreach (Data data in getdata)
{
Console.WriteLine("Employee Name " + data.Title);
}
Console.ReadLine();
}

The codebase will invoke the SharePoint online api with help of an access token

public static List<Data> GetListData()
{
const string DataColumn = "ID,Title";
const string DataAPIAllData = "{0}/_api/lists/getbytitle('{1}')/items?$top=10&$select=" + DataColumn + "&$orderby=Modified desc";
try
{
var results = new List<Data>();
string sharepointSiteUrl = Convert.ToString("https://mittal1201.sharepoint.com/sites/CommSiteHub");
if (!string.IsNullOrEmpty(sharepointSiteUrl))
{
string listname = "Employee";
string api = string.Format(DataAPIAllData, sharepointSiteUrl, listname);
if (!string.IsNullOrEmpty(listname))
{
//Invoke REST Call
string response = TokenHelper.GetAPIResponse(api);
if (!String.IsNullOrEmpty(response))
{
JObject jobj = Utility.Deserialize(response);
JArray jarr = (JArray)jobj["d"]["results"];
//Write Response to Output
foreach (JObject j in jarr)
{
Data data = new Data();
data.Title = Convert.ToString(j["Title"]);
results.Add(data);
}
}
return results;
}
else
{
throw new Exception("Custom Message");
}
}
else
{
throw new Exception("Custom Message");
}
}
catch (Exception ex)
{
throw new Exception("Custom Message");
}
}
}

Created a data class with filed title here

public class Data
{
public string Title { get; set; }
}

Create TokenHelper class to get access token based on user credentials and URI. This function helps to get access from AuthManager Class with the provided information.

public static string GetAPIResponse(string url)
{
string response = String.Empty;
try
{
//Call to get AccessToken
string accessToken = GetSharePointAccessToken();
//Call to get the REST API response from Sharepoint
System.Net.HttpWebRequest endpointRequest = (System.Net.HttpWebRequest)System.Net.HttpWebRequest.Create(url);
endpointRequest.Method = "GET";
endpointRequest.Accept = "application/json;odata=verbose";
endpointRequest.Headers.Add("Authorization", "Bearer " + accessToken);
System.Net.WebResponse webResponse = endpointRequest.GetResponse();
Stream webStream = webResponse.GetResponseStream();
StreamReader responseReader = new StreamReader(webStream);
response = responseReader.ReadToEnd();
return response;
}
catch (Exception ex)
{
throw;
}
}
public static string GetSharePointAccessToken()
{
Uri site = new Uri("https://mittal1201.sharepoint.com/sites/CommSiteHub");
string user = "user email address";
string pwd = "user password";
string result;
using (var authenticationManager = new AuthManager())
{
string accessTokenSP = authenticationManager.AcquireTokenAsync(site, user, pwd).Result;
result = accessTokenSP;
}
return result;
}

Output Window

Execute this solution or press F5.

SharePoint List Screen Shot where data is going to read by a console app

Console Output

Finally, we got output using .NetCore 3.1 console app instead of .NetStandard framework.

I hope you enjoyed and learned something new in this article.

SharePoint Online, Viva , Teams, Power Platform, Azure, Identity

Microsoft Teams | Generate Deep Link To Custom MSTeams Tab

Introduction

Deep Linking with Tab

Delegate SharePoint Online CSOM (REST API) With .NET Core 3.1