public async Task GettingTurnCredentialsWithRequestedRouteType(AuthMethod authMethod, RouteType routeType)
{
CommunicationRelayClient client = authMethod switch
{
AuthMethod.ConnectionString => CreateClientWithConnectionString(),
AuthMethod.KeyCredential => CreateClientWithAzureKeyCredential(),
AuthMethod.TokenCredential => CreateClientWithTokenCredential(),
_ => throw new ArgumentOutOfRangeException(nameof(authMethod)),
};
CommunicationIdentityClient communicationIdentityClient = CreateInstrumentedCommunicationIdentityClient();
Response <CommunicationUserIdentifier> userResponse = await communicationIdentityClient.CreateUserAsync();
Response <CommunicationRelayConfiguration> turnCredentialsResponse = await client.GetRelayConfigurationAsync(userResponse.Value, routeType);
Assert.IsNotNull(turnCredentialsResponse.Value);
Assert.IsNotNull(turnCredentialsResponse.Value.ExpiresOn);
Assert.IsNotNull(turnCredentialsResponse.Value.IceServers);
foreach (CommunicationIceServer serverCredential in turnCredentialsResponse.Value.IceServers)
{
foreach (string url in serverCredential.Urls)
{
Assert.IsFalse(string.IsNullOrWhiteSpace(url));
}
Assert.IsFalse(string.IsNullOrWhiteSpace(serverCredential.Username));
Assert.IsFalse(string.IsNullOrWhiteSpace(serverCredential.Credential));
Assert.AreEqual(routeType, serverCredential.RouteType);
}
}
public async Task IssuingTokenGeneratesTokenAndIdentityWithScopes(AuthMethod authMethod, params string[] scopes)
{
CommunicationIdentityClient client = authMethod switch
{
AuthMethod.ConnectionString => CreateClientWithConnectionString(),
AuthMethod.KeyCredential => CreateClientWithAzureKeyCredential(),
AuthMethod.TokenCredential => CreateClientWithTokenCredential(),
_ => throw new ArgumentOutOfRangeException(nameof(authMethod)),
};
Response <CommunicationUserIdentifier> userResponse = await client.CreateUserAsync();
Response <CommunicationUserToken> tokenResponse = await client.IssueTokenAsync(userResponse.Value, scopes : scopes.Select(x => new CommunicationTokenScope(x)));
Assert.IsNotNull(tokenResponse.Value);
Assert.IsFalse(string.IsNullOrWhiteSpace(tokenResponse.Value.Token));
ValidateScopesIfNotSanitized();
void ValidateScopesIfNotSanitized()
{
if (Mode != RecordedTestMode.Playback)
{
JwtTokenParser.JwtPayload payload = JwtTokenParser.DecodeJwtPayload(tokenResponse.Value.Token);
CollectionAssert.AreEquivalent(scopes, payload.Scopes);
}
}
}
public async Task Participants_Async()
{
CommunicationIdentityClient communicationIdentityClient = new CommunicationIdentityClient(TestEnvironment.LiveTestDynamicConnectionString);
Response <CommunicationUserIdentifier> threadCreatorIdentifier = await communicationIdentityClient.CreateUserAsync();
Response <CommunicationUserIdentifier> participantIdentifier = await communicationIdentityClient.CreateUserAsync();
AccessToken communicationUserToken = await communicationIdentityClient.GetTokenAsync(threadCreatorIdentifier.Value, new[] { CommunicationTokenScope.Chat });
string userToken = communicationUserToken.Token;
ChatClient chatClient = new ChatClient(
TestEnvironment.LiveTestDynamicEndpoint,
new CommunicationTokenCredential(userToken));
CreateChatThreadResult createChatThreadResult = await chatClient.CreateChatThreadAsync(topic : "Hello world!", participants : new ChatParticipant[] { });
ChatThreadClient chatThreadClient = chatClient.GetChatThreadClient(createChatThreadResult.ChatThread.Id);
#region Snippet:Azure_Communication_Chat_Tests_Samples_AddParticipants_KeyConcepts
chatThreadClient.AddParticipants(participants: new[] { new ChatParticipant(participantIdentifier) });
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_AddParticipants_KeyConcepts
#region Snippet:Azure_Communication_Chat_Tests_Samples_GetParticipants_KeyConcepts
Pageable <ChatParticipant> chatParticipants = chatThreadClient.GetParticipants();
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_GetParticipants_KeyConcepts
#region Snippet:Azure_Communication_Chat_Tests_Samples_RemoveParticipant_KeyConcepts
chatThreadClient.RemoveParticipant(identifier: participantIdentifier);
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_RemoveParticipant_KeyConcepts
}
private async Task <CommunicationUserIdentifier> CreateUser()
{
var client = new CommunicationIdentityClient(connectionString);
var user = await client.CreateUserAsync().ConfigureAwait(false);
return(new CommunicationUserIdentifier(user.Value.Id));
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", Route = null)] HttpRequest req,
ILogger log)
{
string code = req.Query["entryCode"];
string correctCode = Environment.GetEnvironmentVariable("EntryCode");
if (correctCode != null && code.ToLower() == correctCode.ToLower())
{
CommunicationIdentityClient _client = new CommunicationIdentityClient(Environment.GetEnvironmentVariable("ACS_Connection_String"));
Response <CommunicationUser> userResponse = await _client.CreateUserAsync();
CommunicationUser user = userResponse.Value;
Response <CommunicationUserToken> tokenResponse =
await _client.IssueTokenAsync(user, scopes : new[] { CommunicationTokenScope.VoIP });
string token = tokenResponse.Value.Token;
DateTimeOffset expiresOn = tokenResponse.Value.ExpiresOn;
return(new OkObjectResult(tokenResponse));
}
else
{
Random rnd = new Random();
System.Threading.Thread.Sleep(rnd.Next(500, 5000));
return(new UnauthorizedResult());
}
}
private async Task <Response <CreateCallResponse> > CreateCallOperation(CallClient client)
{
CommunicationIdentityClient communicationIdentityClient = CreateInstrumentedCommunicationIdentityClient();
var source = await CreateUserAsync(communicationIdentityClient).ConfigureAwait(false);
var targets = new List <CommunicationIdentifier>()
{
new PhoneNumberIdentifier(TestEnvironment.TargetPhoneNumber)
};
var createCallOption = new CreateCallOptions(
new Uri(TestEnvironment.AppCallbackUrl),
new List <CallModality> {
CallModality.Audio
},
new List <EventSubscriptionType> {
EventSubscriptionType.ParticipantsUpdated, EventSubscriptionType.DtmfReceived
});
createCallOption.AlternateCallerId = new PhoneNumberIdentifier(TestEnvironment.SourcePhoneNumber);
Console.WriteLine("Performing CreateCall operation");
var createCallResponse = await client.CreateCallAsync(source : source, targets : targets, options : createCallOption).ConfigureAwait(false);
Console.WriteLine("Call initiated with Call Leg id: {0}", createCallResponse.Value.CallLegId);
Assert.IsFalse(string.IsNullOrWhiteSpace(createCallResponse.Value.CallLegId));
return(createCallResponse);
}
public void CreateCall()
{
CommunicationIdentityClient communicationIdentityClient = CreateInstrumentedCommunicationIdentityClient();
var source = communicationIdentityClient.CreateUser();
var targets = new[] { new PhoneNumberIdentifier(TestEnvironment.TargetPhoneNumber) };
var createCallOption = new CreateCallOptions(
new Uri(TestEnvironment.AppCallbackUrl),
new[] { MediaType.Audio },
new[] {
EventSubscriptionType.ParticipantsUpdated,
EventSubscriptionType.DtmfReceived
});
CallingServerClient callingServerClient = CreateInstrumentedCallingServerClient();
Console.WriteLine("Performing CreateCallConnection operation");
#region Snippet:Azure_Communication_Call_Tests_CreateCall
var callConnection = callingServerClient.CreateCallConnection(
//@@ source: new CommunicationUserIdentifier("<source-identifier>"), // Your Azure Communication Resource Guid Id used to make a Call
//@@ targets: new List<CommunicationIdentifier>() { new PhoneNumberIdentifier("<targets-phone-number>") }, // E.164 formatted recipient phone number
//@@ options: createCallOption // The options for creating a call.
/*@@*/ source: source,
/*@@*/ targets: targets,
/*@@*/ options: createCallOption
);
Console.WriteLine($"Call connection id: {callConnection.Value.CallConnectionId}");
#endregion Snippet:Azure_Communication_Call_Tests_CreateCall
}
private (CommunicationUserIdentifier user, string token) CreateUserAndToken(CommunicationIdentityClient communicationIdentityClient)
{
Response <CommunicationUserIdentifier> user = communicationIdentityClient.CreateUser();
IEnumerable <CommunicationTokenScope> scopes = new[] { CommunicationTokenScope.Chat };
Response <AccessToken> tokenResponseUser = communicationIdentityClient.GetToken(user.Value, scopes);
return(user, tokenResponseUser.Value.Token);
}
private (CommunicationUser user, string token) CreateUserAndToken(CommunicationIdentityClient communicationIdentityClient)
{
Response <CommunicationUser> threadMember = communicationIdentityClient.CreateUser();
IEnumerable <CommunicationTokenScope> scopes = new[] { CommunicationTokenScope.Chat };
Response <CommunicationUserToken> tokenResponseThreadMember = communicationIdentityClient.IssueToken(threadMember.Value, scopes);
return(tokenResponseThreadMember.Value.User, tokenResponseThreadMember.Value.Token);
}
public async Task <IHttpActionResult> ACSRefreshAsync(TokenRequest request)
{
var client = new CommunicationIdentityClient(connectionString);
var identitytoRefresh = new CommunicationUser(request.UserEmail);
var tokenResponse = await client.IssueTokenAsync(identitytoRefresh, scopes : new[] { CommunicationTokenScope.VoIP });
return(Ok(tokenResponse.Value));
}
public TokenController(ILogger <TokenController> logger, IConfiguration configuration)
{
_logger = logger;
_configuration = configuration;
//Azure Communication Services connection string
_connectionString = _configuration["ConnectionString"];
_endpoint = _configuration["EndPoint"];
_client = new CommunicationIdentityClient(_connectionString);
}
public async Task <IHttpActionResult> GetTokenAsync()
{
var client = new CommunicationIdentityClient(connectionString);
var identityResponse = await client.CreateUserAsync();
var identity = identityResponse.Value;
var tokenResponse = await client.IssueTokenAsync(identity, scopes : new[] { CommunicationTokenScope.VoIP });
return(Ok(tokenResponse.Value));
}
public Response <AccessToken> CreateIdentityAndGetTokenAsync(Uri resourceEndpoint)
{
var client = new CommunicationIdentityClient(resourceEndpoint, this.credential);
var identityResponse = client.CreateUser();
var identity = identityResponse.Value;
var tokenResponse = client.GetToken(identity, scopes: new[] { CommunicationTokenScope.VoIP });
return(tokenResponse);
}
static async System.Threading.Tasks.Task Main(string[] args)
{
Console.WriteLine("Azure Communication Services - Access Tokens Quickstart");
// Authenticate the client
// This code demonstrates how to fetch your connection string
// from an environment variable.
string connectionString = Environment.GetEnvironmentVariable("COMMUNICATION_SERVICES_CONNECTION_STRING");
var client = new CommunicationIdentityClient(connectionString);
// This code demonstrates how to fetch your endpoint and access key
// from an environment variable.
/*string endpoint = Environment.GetEnvironmentVariable("COMMUNICATION_SERVICES_ENDPOINT");
* string accessKey = Environment.GetEnvironmentVariable("COMMUNICATION_SERVICES_ACCESSKEY");
* var client = new CommunicationIdentityClient(new Uri(endpoint), new AzureKeyCredential(accessKey));*/
// Update documentation with URI details
/*TokenCredential tokenCredential = new DefaultAzureCredential();
* string endPoint = Environment.GetEnvironmentVariable("COMMUNICATION_SERVICES_ENDPOINT");
* var client = new CommunicationIdentityClient(new Uri(endPoint), tokenCredential);*/
// Create an identity
var identityResponse = await client.CreateUserAsync();
var identity = identityResponse.Value;
Console.WriteLine($"\nCreated an identity with ID: {identity.Id}");
// Issue an access token with the "voip" scope for an identity
var tokenResponse = await client.GetTokenAsync(identity, scopes : new[] { CommunicationTokenScope.VoIP });
var token = tokenResponse.Value.Token;
var expiresOn = tokenResponse.Value.ExpiresOn;
Console.WriteLine($"\nIssued an access token with 'voip' scope that expires at {expiresOn}:");
Console.WriteLine(token);
// Refresh access tokens
var identityToRefresh = new CommunicationUserIdentifier(identity.Id);
var refreshTokenResponse = await client.GetTokenAsync(identityToRefresh, scopes : new[] { CommunicationTokenScope.VoIP });
// Revoke access tokens
await client.RevokeTokensAsync(identity);
Console.WriteLine($"\nSuccessfully revoked all access tokens for identity with ID: {identity.Id}");
// Delete an identity
await client.DeleteUserAsync(identity);
Console.WriteLine($"\nDeleted the identity with ID: {identity.Id}");
}
public async Task GetTokenForTeamsUserWithValidParameters()
{
if (TestEnvironment.ShouldIgnoreIdentityExchangeTokenTest)
{
Assert.Ignore("Ignore exchange teams token test if flag is enabled.");
}
CommunicationIdentityClient client = CreateClientWithConnectionString();
Response <AccessToken> tokenResponse = await client.GetTokenForTeamsUserAsync(CTEOptions);
Assert.IsNotNull(tokenResponse.Value);
Assert.IsFalse(string.IsNullOrWhiteSpace(tokenResponse.Value.Token));
}
public async Task GetTokenForTeamsUserWithNullTokenShouldThrow()
{
try
{
CommunicationIdentityClient client = CreateClientWithConnectionString();
Response <AccessToken> tokenResponse = await client.GetTokenForTeamsUserAsync(null);
}
catch (ArgumentNullException ex)
{
Assert.AreEqual("token", ex.ParamName);
return;
}
Assert.Fail("An exception should have been thrown.");
}
public async Task MessagesNotificationsReadReceipts_Async()
{
CommunicationIdentityClient communicationIdentityClient = new CommunicationIdentityClient(TestEnvironment.ConnectionString);
Response <CommunicationUserIdentifier> threadCreatorIdentifier = await communicationIdentityClient.CreateUserAsync();
AccessToken communicationUserToken = await communicationIdentityClient.GetTokenAsync(threadCreatorIdentifier.Value, new[] { CommunicationTokenScope.Chat });
string userToken = communicationUserToken.Token;
string endpoint = TestEnvironment.ChatApiUrl();
ChatClient chatClient = new ChatClient(
new Uri(endpoint),
new CommunicationTokenCredential(userToken));
CreateChatThreadResult createChatThreadResult = await chatClient.CreateChatThreadAsync(topic : "Hello world!", participants : new ChatParticipant[] { });
ChatThreadClient chatThreadClient = chatClient.GetChatThreadClient(createChatThreadResult.ChatThread.Id);
#region Snippet:Azure_Communication_Chat_Tests_Samples_SendMessage_KeyConcepts
string messageId = chatThreadClient.SendMessage("Let's meet at 11am");
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_SendMessage_KeyConcepts
#region Snippet:Azure_Communication_Chat_Tests_Samples_GetMessage_KeyConcepts
ChatMessage message = chatThreadClient.GetMessage(messageId);
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_GetMessage_KeyConcepts
#region Snippet:Azure_Communication_Chat_Tests_Samples_GetMessages_KeyConcepts
Pageable <ChatMessage> messages = chatThreadClient.GetMessages();
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_GetMessages_KeyConcepts
#region Snippet:Azure_Communication_Chat_Tests_Samples_UpdateMessage_KeyConcepts
chatThreadClient.UpdateMessage(messageId, content: "Instead of 11am, let's meet at 2pm");
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_UpdateMessage_KeyConcepts
#region Snippet:Azure_Communication_Chat_Tests_Samples_DeleteMessage_KeyConcepts
chatThreadClient.DeleteMessage(messageId);
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_DeleteMessage_KeyConcepts
#region Snippet:Azure_Communication_Chat_Tests_Samples_SendReadReceipt_KeyConcepts
chatThreadClient.SendReadReceipt(messageId);
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_SendReadReceipt_KeyConcepts
#region Snippet:Azure_Communication_Chat_Tests_Samples_GetReadReceipts_KeyConcepts
Pageable <ChatMessageReadReceipt> readReceipts = chatThreadClient.GetReadReceipts();
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_GetReadReceipts_KeyConcepts
#region Snippet:Azure_Communication_Chat_Tests_Samples_SendTypingNotification_KeyConcepts
chatThreadClient.SendTypingNotification();
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_SendTypingNotification_KeyConcepts
}
public async Task ReadReceiptGSAsync()
{
//arr
Console.WriteLine($"ReadReceiptGSAsync Running on RecordedTestMode : {Mode}");
CommunicationIdentityClient communicationIdentityClient = CreateInstrumentedCommunicationIdentityClient();
(CommunicationUserIdentifier user1, string token1) = await CreateUserAndTokenAsync(communicationIdentityClient);
(CommunicationUserIdentifier user2, string token2) = await CreateUserAndTokenAsync(communicationIdentityClient);
var participants = new List <ChatParticipant>
{
new ChatParticipant(user1),
new ChatParticipant(user2)
};
ChatClient chatClient = CreateInstrumentedChatClient(token1);
ChatClient chatClient2 = CreateInstrumentedChatClient(token2);
string repeatabilityRequestId1 = "contoso-E0A747F1-6245-4307-8267-B974340677DE";
//act
CreateChatThreadResult createChatThreadResult = await chatClient.CreateChatThreadAsync("Thread topic - ReadReceipts Async Test", participants, repeatabilityRequestId1);
ChatThreadClient chatThreadClient = GetInstrumentedChatThreadClient(chatClient, createChatThreadResult.ChatThread.Id);
var threadId = chatThreadClient.Id;
ChatThreadClient chatThreadClient2 = GetInstrumentedChatThreadClient(chatClient2, threadId);
SendChatMessageResult sendChatMessageResult2 = await chatThreadClient.SendMessageAsync("This is message 1 content");
string messageId2 = sendChatMessageResult2.Id;
SendChatMessageResult sendChatMessageResult = await chatThreadClient2.SendMessageAsync("This is message 2 content");
string messageId = sendChatMessageResult.Id;
await chatThreadClient.SendReadReceiptAsync(messageId);
await chatThreadClient2.SendReadReceiptAsync(messageId2);
AsyncPageable <ChatMessageReadReceipt> readReceipts = chatThreadClient.GetReadReceiptsAsync();
AsyncPageable <ChatMessageReadReceipt> readReceipts2 = chatThreadClient2.GetReadReceiptsAsync();
var readReceiptsCount = readReceipts.ToEnumerableAsync().Result.Count;
var readReceiptsCount2 = readReceipts2.ToEnumerableAsync().Result.Count;
await chatClient.DeleteChatThreadAsync(threadId);
//assert
Assert.AreEqual(2, readReceiptsCount);
Assert.AreEqual(2, readReceiptsCount2);
}
public void GetAddRemoveMembers()
{
CommunicationIdentityClient communicationIdentityClient = new CommunicationIdentityClient(TestEnvironment.ConnectionString);
Response <CommunicationUser> threadCreator = communicationIdentityClient.CreateUser();
Response <CommunicationUser> threadMember2 = communicationIdentityClient.CreateUser();
Response <CommunicationUser> threadMember3 = communicationIdentityClient.CreateUser();
string userToken = communicationIdentityClient.IssueToken(threadCreator.Value, new[] { CommunicationTokenScope.Chat }).Value.Token;
string endpoint = TestEnvironment.ChatApiUrl();
ChatClient chatClient = new ChatClient(
new Uri(endpoint),
new CommunicationUserCredential(userToken));
var chatThreadMember = new ChatThreadMember(new CommunicationUser(threadCreator.Value.Id))
{
DisplayName = "UserDisplayName",
ShareHistoryTime = DateTime.MinValue
};
ChatThreadClient chatThreadClient = chatClient.CreateChatThread(topic: "Hello world!", members: new[] { chatThreadMember });
Pageable <ChatThreadMember> allMembers = chatThreadClient.GetMembers();
foreach (ChatThreadMember member in allMembers)
{
Console.WriteLine($"{member.User.Id}:{member.DisplayName}:{member.ShareHistoryTime}");
}
var members = new[]
{
new ChatThreadMember(threadCreator)
{
DisplayName = "display name thread creator"
},
new ChatThreadMember(threadMember2)
{
DisplayName = "display name member 2"
},
new ChatThreadMember(threadMember3)
{
DisplayName = "display name member 3"
}
};
chatThreadClient.AddMembers(members);
chatThreadClient.RemoveMember(new CommunicationUser(threadMember2.Value.Id));
chatClient.DeleteChatThread(chatThreadClient.Id);
}
public async Task <AccessToken> GenerateTokenAsync(string resourceConnectionString, string identity)
{
try
{
var communicationIdentityClient = new CommunicationIdentityClient(resourceConnectionString);
var userResponse = await communicationIdentityClient.GetTokenAsync(new CommunicationUserIdentifier(identity), scopes : new[] { CommunicationTokenScope.Chat });
return(userResponse.Value);
}
catch
{
throw;
}
}
public async Task RevokeTokenWithNullUserShouldThrow()
{
try
{
CommunicationIdentityClient client = CreateClientWithConnectionString();
Response deleteResponse = await client.RevokeTokensAsync(communicationUser : null);
}
catch (NullReferenceException ex)
{
Assert.NotNull(ex.Message);
Console.WriteLine(ex.Message);
return;
}
Assert.Fail("RevokeTokensAsync should have thrown an exception.");
}
public async Task GetTokenWithNullUserShouldThrow()
{
try
{
CommunicationIdentityClient client = CreateClientWithConnectionString();
Response <AccessToken> accessToken = await client.GetTokenAsync(communicationUser : null, scopes : new[] { CommunicationTokenScope.Chat });
}
catch (NullReferenceException ex)
{
Assert.NotNull(ex.Message);
Console.WriteLine(ex.Message);
return;
}
Assert.Fail("RevokeTokensAsync should have thrown an exception.");
}
public async Task <CommunicationUserToken> RefreshTokenAsync(string resourceConnectionString, string identity)
{
try
{
var communicationIdentityClient = new CommunicationIdentityClient(resourceConnectionString);
var user = new CommunicationUser(identity);
var tokenResponse = await communicationIdentityClient.IssueTokenAsync(user, scopes : new[] { CommunicationTokenScope.Chat });
return(tokenResponse);
}
catch
{
throw;
}
}
public async Task CreateUserAndTokenWithNullScopeShouldThrow()
{
try
{
CommunicationIdentityClient client = CreateClientWithConnectionString();
Response <CommunicationUserIdentifierAndToken> response = await client.CreateUserAndTokenAsync(scopes : null);
}
catch (NullReferenceException ex)
{
Assert.NotNull(ex.Message);
Console.WriteLine(ex.Message);
return;
}
Assert.Fail("CreateUserAndTokenAsync should have thrown an exception.");
}
public async Task ExchangeTeamsTokenWithValidToken()
{
if (TestEnvironment.ShouldIgnoreIdentityExchangeTokenTest)
{
Assert.Ignore("Ignore exchange teams token test if flag is enabled.");
}
string token = await generateTeamsToken();
CommunicationIdentityClient client = CreateClientWithConnectionString();
Response <AccessToken> tokenResponse = await client.ExchangeTeamsTokenAsync(token);
Assert.IsNotNull(tokenResponse.Value);
Assert.IsFalse(string.IsNullOrWhiteSpace(tokenResponse.Value.Token));
}
public async Task GetTokenForTeamsUserWithExpiredTokenShouldThrow()
{
try
{
CommunicationIdentityClient client = CreateClientWithConnectionString();
Response <AccessToken> tokenResponse = await client.GetTokenForTeamsUserAsync(new GetTokenForTeamsUserOptions(TestEnvironment.CommunicationExpiredTeamsToken, CTEOptions.ClientId, CTEOptions.UserObjectId));
}
catch (RequestFailedException ex)
{
Assert.NotNull(ex.Message);
Assert.True(ex.Message.Contains("401"));
Console.WriteLine(ex.Message);
return;
}
Assert.Fail("An exception should have been thrown.");
}
public async Task ExchangeTeamsTokenWithInvalidTokenShouldThrow()
{
try
{
CommunicationIdentityClient client = CreateClientWithConnectionString();
Response <AccessToken> tokenResponse = await client.ExchangeTeamsTokenAsync("invalid");
}
catch (RequestFailedException ex)
{
Assert.NotNull(ex.Message);
Assert.True(ex.Message.Contains("401"));
Console.WriteLine(ex.Message);
return;
}
Assert.Fail("An exception should have been thrown.");
}
public async Task GetTokenWithNullScopesShouldThrow()
{
try
{
CommunicationIdentityClient client = CreateClientWithConnectionString();
CommunicationUserIdentifier userIdentifier = await client.CreateUserAsync();
Response <AccessToken> accessToken = await client.GetTokenAsync(communicationUser : userIdentifier, scopes : null);
}
catch (ArgumentNullException ex)
{
Assert.AreEqual("scopes", ex.ParamName);
return;
}
Assert.Fail("RevokeTokensAsync should have thrown an exception.");
}
public void SendGetUpdateDeleteMessagesSendNotificationReadReceipts()
{
CommunicationIdentityClient communicationIdentityClient = new CommunicationIdentityClient(TestEnvironment.ConnectionString);
Response <CommunicationUser> threadMember = communicationIdentityClient.CreateUser();
CommunicationUserToken communicationUserToken = communicationIdentityClient.IssueToken(threadMember.Value, new[] { CommunicationTokenScope.Chat });
string userToken = communicationUserToken.Token;
string endpoint = TestEnvironment.ChatApiUrl();
string theadCreatorMemberId = communicationUserToken.User.Id;
ChatClient chatClient = new ChatClient(
new Uri(endpoint),
new CommunicationUserCredential(userToken));
var chatThreadMember = new ChatThreadMember(new CommunicationUser(theadCreatorMemberId))
{
DisplayName = "UserDisplayName",
ShareHistoryTime = DateTime.MinValue
};
ChatThreadClient chatThreadClient = chatClient.CreateChatThread(topic: "Hello world!", members: new[] { chatThreadMember });
string threadId = chatThreadClient.Id;
var content = "hello world";
var priority = ChatMessagePriority.Normal;
var senderDisplayName = "sender name";
SendChatMessageResult sendMessageResult = chatThreadClient.SendMessage(content, priority, senderDisplayName);
var messageId = sendMessageResult.Id;
ChatMessage chatMessage = chatThreadClient.GetMessage(messageId);
Pageable <ChatMessage> allMessages = chatThreadClient.GetMessages();
foreach (ChatMessage message in allMessages)
{
Console.WriteLine($"{message.Id}:{message.Sender.Id}:{message.Content}");
}
chatThreadClient.UpdateMessage(messageId, "updated message content");
chatThreadClient.SendReadReceipt(messageId);
Pageable <ReadReceipt> allReadReceipts = chatThreadClient.GetReadReceipts();
foreach (ReadReceipt readReceipt in allReadReceipts)
{
Console.WriteLine($"{readReceipt.ChatMessageId}:{readReceipt.Sender.Id}:{readReceipt.ReadOn}");
}
chatThreadClient.DeleteMessage(messageId);
chatThreadClient.SendTypingNotification();
chatClient.DeleteChatThread(threadId);
}
public async Task <CommunicationUserToken> GenerateTokenAsync(string resourceConnectionString)
{
try
{
var communicationIdentityClient = new CommunicationIdentityClient(resourceConnectionString);
var userResponse = await communicationIdentityClient.CreateUserAsync();
var user = userResponse.Value;
var tokenResponse = await communicationIdentityClient.IssueTokenAsync(user, scopes : new[] { CommunicationTokenScope.Chat });
return(tokenResponse);
}
catch
{
throw;
}
}
