public async Task Participants_Async()
{
CommunicationIdentityClient communicationIdentityClient = new CommunicationIdentityClient(TestEnvironment.ConnectionString);
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;
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_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(user: participantIdentifier);
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_RemoveParticipant_KeyConcepts
}
/// <summary>
/// Creates a <see cref="ChatClient" /> with a static token and instruments it to make use of
/// the Azure Core Test Framework functionalities.
/// </summary>
/// <returns>The instrumented <see cref="ChatClient" />.</returns>
protected ChatClient CreateInstrumentedChatClient(string token)
{
if (Mode == RecordedTestMode.Playback)
{
token = ChatRecordedTestSanitizer.SanitizedChatAuthHeaderValue;
}
CommunicationUserCredential communicationUserCredential = new CommunicationUserCredential(token);
return(InstrumentClient(new ChatClient(new Uri(TestEnvironment.ChatApiUrl()), communicationUserCredential,
InstrumentClientOptions(new ChatClientOptions()))));
}
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 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 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 void CreateGetUpdateDeleteThread()
{
CommunicationIdentityClient communicationIdentityClient = new CommunicationIdentityClient(TestEnvironment.ConnectionString);
Response <CommunicationUser> threadCreator = communicationIdentityClient.CreateUser();
CommunicationUserToken communicationUserToken = communicationIdentityClient.IssueToken(threadCreator.Value, new[] { CommunicationTokenScope.Chat });
string userToken = communicationUserToken.Token;
string endpoint = TestEnvironment.ChatApiUrl();
string threadCreatorId = communicationUserToken.User.Id;
ChatClient chatClient = new ChatClient(
new Uri(endpoint),
new CommunicationUserCredential(userToken));
var chatThreadMember = new ChatThreadMember(threadCreator)
{
DisplayName = "UserDisplayName"
};
ChatThreadClient chatThreadClient = chatClient.CreateChatThread(topic: "Hello world!", members: new[] { chatThreadMember });
string threadId = chatThreadClient.Id;
ChatThread chatThread = chatClient.GetChatThread(threadId);
Pageable <ChatThreadInfo> chatThreadsInfo = chatClient.GetChatThreadsInfo();
foreach (ChatThreadInfo chatThreadInfo in chatThreadsInfo)
{
Console.WriteLine($"{ chatThreadInfo.Id}");
}
var topic = "new topic";
chatThreadClient.UpdateThread(topic);
chatClient.DeleteChatThread(threadId);
try
{
chatThreadMember = new ChatThreadMember(new CommunicationUser("invalid user"));
ChatThreadClient chatThreadClient_ = chatClient.CreateChatThread(topic: "Hello world!", members: new[] { chatThreadMember });
Assert.Fail("CreateChatThread did not fail");
}
catch (RequestFailedException ex)
{
Console.WriteLine(ex.Message);
}
catch (Exception ex)
{
Assert.Fail($"Unexpected error: {ex}");
}
}
public async Task Threads_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));
#region Snippet:Azure_Communication_Chat_Tests_Samples_CreateThread_KeyConcepts
CreateChatThreadResult createChatThreadResult = await chatClient.CreateChatThreadAsync(topic : "Hello world!", participants : new ChatParticipant[] { });
ChatThread chatThread = createChatThreadResult.ChatThread;
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_CreateThread_KeyConcepts
#region Snippet:Azure_Communication_Chat_Tests_Samples_GetChatThreadClient_KeyConcepts
ChatThreadClient chatThreadClient = chatClient.GetChatThreadClient(chatThread.Id);
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_GetChatThreadClient_KeyConcepts
#region Snippet:Azure_Communication_Chat_Tests_Samples_UpdateThread_KeyConcepts
chatThreadClient.UpdateTopic(topic: "Launch meeting");
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_UpdateThread_KeyConcepts
#region Snippet:Azure_Communication_Chat_Tests_Samples_GetChatThread_KeyConcepts
//@@ChatThread chatThread = chatClient.GetChatThread(chatThread.Id);
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_GetChatThread_KeyConcepts
#region Snippet:Azure_Communication_Chat_Tests_Samples_GetChatThreadsInfo_KeyConcepts
Pageable <ChatThreadInfo> threads = chatClient.GetChatThreadsInfo();
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_GetChatThreadsInfo_KeyConcepts
#region Snippet:Azure_Communication_Chat_Tests_Samples_DeleteThread_KeyConcepts
chatClient.DeleteChatThread(chatThread.Id);
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_DeleteThread_KeyConcepts
}
public async Task GetAddRemoveMembersAsync()
{
CommunicationIdentityClient communicationIdentityClient = new CommunicationIdentityClient(TestEnvironment.ConnectionString);
Response <CommunicationUserIdentifier> threadMember1 = await communicationIdentityClient.CreateUserAsync();
Response <CommunicationUserIdentifier> threadMember2 = await communicationIdentityClient.CreateUserAsync();
Response <CommunicationUserIdentifier> threadMember3 = await communicationIdentityClient.CreateUserAsync();
CommunicationUserToken communicationUserToken1 = await communicationIdentityClient.IssueTokenAsync(threadMember1.Value, new[] { CommunicationTokenScope.Chat });
CommunicationUserToken communicationUserToken2 = await communicationIdentityClient.IssueTokenAsync(threadMember2.Value, new[] { CommunicationTokenScope.Chat });
CommunicationUserToken communicationUserToken3 = await communicationIdentityClient.IssueTokenAsync(threadMember3.Value, new[] { CommunicationTokenScope.Chat });
string userToken = communicationUserToken1.Token;
string endpoint = TestEnvironment.ChatApiUrl();
string theadCreatorMemberId = communicationUserToken1.User.Id;
ChatClient chatClient = new ChatClient(
new Uri(endpoint),
new CommunicationTokenCredential(userToken));
var chatThreadMember = new ChatThreadMember(new CommunicationUserIdentifier(theadCreatorMemberId))
{
DisplayName = "UserDisplayName",
ShareHistoryTime = DateTime.MinValue
};
ChatThreadClient chatThreadClient = await chatClient.CreateChatThreadAsync(topic : "Hello world!", members : new[] { chatThreadMember });
string threadId = chatThreadClient.Id;
#region Snippet:Azure_Communication_Chat_Tests_Samples_GetMembers
AsyncPageable <ChatThreadMember> allMembers = chatThreadClient.GetMembersAsync();
await foreach (ChatThreadMember member in allMembers)
{
Console.WriteLine($"{member.User.Id}:{member.DisplayName}:{member.ShareHistoryTime}");
}
#endregion Snippet:Azure_Communication_Chat_Tests_GetMembers
var memberId1 = theadCreatorMemberId;
var memberId2 = communicationUserToken2.User.Id;
var memberId3 = communicationUserToken3.User.Id;
#region Snippet:Azure_Communication_Chat_Tests_Samples_AddMembers
var members = new[]
{
new ChatThreadMember(new CommunicationUserIdentifier(memberId1))
{
DisplayName = "display name member 1"
},
new ChatThreadMember(new CommunicationUserIdentifier(memberId2))
{
DisplayName = "display name member 2"
},
new ChatThreadMember(new CommunicationUserIdentifier(memberId3))
{
DisplayName = "display name member 3"
}
};
await chatThreadClient.AddMembersAsync(members);
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_AddMembers
var memberId = memberId2;
#region Snippet:Azure_Communication_Chat_Tests_Samples_RemoveMember
await chatThreadClient.RemoveMemberAsync(new CommunicationUserIdentifier(memberId));
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_RemoveMember
await chatClient.DeleteChatThreadAsync(threadId);
}
public async Task SendGetUpdateDeleteMessagesSendNotificationReadReceiptsAsync()
{
CommunicationIdentityClient communicationIdentityClient = new CommunicationIdentityClient(TestEnvironment.ConnectionString);
Response <CommunicationUserIdentifier> threadMember = await communicationIdentityClient.CreateUserAsync();
CommunicationUserToken communicationUserToken = await communicationIdentityClient.IssueTokenAsync(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 CommunicationTokenCredential(userToken));
var chatThreadMember = new ChatThreadMember(new CommunicationUserIdentifier(theadCreatorMemberId))
{
DisplayName = "UserDisplayName",
ShareHistoryTime = DateTime.MinValue
};
ChatThreadClient chatThreadClient = await chatClient.CreateChatThreadAsync(topic : "Hello world!", members : new[] { chatThreadMember });
string threadId = chatThreadClient.Id;
#region Snippet:Azure_Communication_Chat_Tests_Samples_SendMessage
var content = "hello world";
var priority = ChatMessagePriority.Normal;
var senderDisplayName = "sender name";
SendChatMessageResult sendMessageResult = await chatThreadClient.SendMessageAsync(content, priority, senderDisplayName);
#endregion Snippet:Azure_Communication_Chat_Tests_SendMessage
var messageId = sendMessageResult.Id;
#region Snippet:Azure_Communication_Chat_Tests_Samples_GetMessage
ChatMessage chatMessage = await chatThreadClient.GetMessageAsync(messageId);
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_GetMessage
#region Snippet:Azure_Communication_Chat_Tests_Samples_GetMessages
AsyncPageable <ChatMessage> allMessages = chatThreadClient.GetMessagesAsync();
await foreach (ChatMessage message in allMessages)
{
Console.WriteLine($"{message.Id}:{message.Sender.Id}:{message.Content}");
}
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_GetMessages
#region Snippet:Azure_Communication_Chat_Tests_Samples_UpdateMessage
await chatThreadClient.UpdateMessageAsync(messageId, "updated message content");
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_UpdateMessage
//Note : Due to the async nature of the storage, moving coverage to CI tests
#region Snippet:Azure_Communication_Chat_Tests_Samples_SendReadReceipt
//@@await chatThreadClient.SendReadReceiptAsync(messageId);
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_SendReadReceipt
#region Snippet:Azure_Communication_Chat_Tests_Samples_GetReadReceipts
AsyncPageable <ReadReceipt> allReadReceipts = chatThreadClient.GetReadReceiptsAsync();
await foreach (ReadReceipt readReceipt in allReadReceipts)
{
Console.WriteLine($"{readReceipt.ChatMessageId}:{readReceipt.Sender.Id}:{readReceipt.ReadOn}");
}
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_GetReadReceipts
#region Snippet:Azure_Communication_Chat_Tests_Samples_DeleteMessage
await chatThreadClient.DeleteMessageAsync(messageId);
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_DeleteMessage
#region Snippet:Azure_Communication_Chat_Tests_Samples_SendTypingNotification
await chatThreadClient.SendTypingNotificationAsync();
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_SendTypingNotification
await chatClient.DeleteChatThreadAsync(threadId);
}
public async Task CreateGetUpdateDeleteThreadAsync()
{
CommunicationIdentityClient communicationIdentityClient = new CommunicationIdentityClient(TestEnvironment.ConnectionString);
Response <CommunicationUserIdentifier> threadMember = await communicationIdentityClient.CreateUserAsync();
CommunicationUserToken communicationUserToken = await communicationIdentityClient.IssueTokenAsync(threadMember.Value, new[] { CommunicationTokenScope.Chat });
string userToken = communicationUserToken.Token;
string endpoint = TestEnvironment.ChatApiUrl();
string threadCreatorId = threadMember.Value.Id;
#region Snippet:Azure_Communication_Chat_Tests_Samples_CreateChatClient
ChatClient chatClient = new ChatClient(
new Uri(endpoint),
new CommunicationTokenCredential(userToken));
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_CreateChatClient
#region Snippet:Azure_Communication_Chat_Tests_Samples_CreateThread
var chatThreadMember = new ChatThreadMember(new CommunicationUserIdentifier(threadCreatorId))
{
DisplayName = "UserDisplayName"
};
ChatThreadClient chatThreadClient = await chatClient.CreateChatThreadAsync(topic : "Hello world!", members : new[] { chatThreadMember });
string threadId = chatThreadClient.Id;
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_CreateThread
#region Snippet:Azure_Communication_Chat_Tests_Samples_GetThread
ChatThread chatThread = await chatClient.GetChatThreadAsync(threadId);
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_GetThread
#region Snippet:Azure_Communication_Chat_Tests_Samples_GetThreads
AsyncPageable <ChatThreadInfo> chatThreadsInfo = chatClient.GetChatThreadsInfoAsync();
await foreach (ChatThreadInfo chatThreadInfo in chatThreadsInfo)
{
Console.WriteLine($"{ chatThreadInfo.Id}");
}
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_GetThreads
#region Snippet:Azure_Communication_Chat_Tests_Samples_UpdateThread
var topic = "new topic";
await chatThreadClient.UpdateThreadAsync(topic);
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_UpdateThread
#region Snippet:Azure_Communication_Chat_Tests_Samples_DeleteThread
await chatClient.DeleteChatThreadAsync(threadId);
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_DeleteThread
#region Snippet:Azure_Communication_Chat_Tests_Samples_Troubleshooting
try
{
/*@@*/ chatThreadMember = new ChatThreadMember(new CommunicationUserIdentifier("invalid user"));
ChatThreadClient chatThreadClient_ = await chatClient.CreateChatThreadAsync(topic : "Hello world!", members : new[] { chatThreadMember });
}
catch (RequestFailedException ex)
{
Console.WriteLine(ex.Message);
}
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_Troubleshooting
catch (Exception ex)
{
Assert.Fail($"Unexpected error: {ex}");
}
}
public async Task GetAddRemoveMembersAsync()
{
CommunicationIdentityClient communicationIdentityClient = new CommunicationIdentityClient(TestEnvironment.ConnectionString);
Response <CommunicationUserIdentifier> joshResponse = await communicationIdentityClient.CreateUserAsync();
CommunicationUserIdentifier josh = joshResponse.Value;
Response <CommunicationUserIdentifier> gloriaResponse = await communicationIdentityClient.CreateUserAsync();
CommunicationUserIdentifier gloria = gloriaResponse.Value;
Response <CommunicationUserIdentifier> amyResponse = await communicationIdentityClient.CreateUserAsync();
CommunicationUserIdentifier amy = amyResponse.Value;
AccessToken joshTokenResponse = await communicationIdentityClient.IssueTokenAsync(josh, new[] { CommunicationTokenScope.Chat });
ChatClient chatClient = new ChatClient(
new Uri(TestEnvironment.ChatApiUrl()),
new CommunicationTokenCredential(joshTokenResponse.Token));
var chatParticipant = new ChatParticipant(josh)
{
DisplayName = "Josh",
ShareHistoryTime = DateTime.MinValue
};
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_GetParticipants
AsyncPageable <ChatParticipant> allParticipants = chatThreadClient.GetParticipantsAsync();
await foreach (ChatParticipant participant in allParticipants)
{
Console.WriteLine($"{((CommunicationUserIdentifier)participant.User).Id}:{participant.DisplayName}:{participant.ShareHistoryTime}");
}
#endregion Snippet:Azure_Communication_Chat_Tests_GetMembers
#region Snippet:Azure_Communication_Chat_Tests_Samples_AddParticipants
var participants = new[]
{
new ChatParticipant(josh)
{
DisplayName = "Josh"
},
new ChatParticipant(gloria)
{
DisplayName = "Gloria"
},
new ChatParticipant(amy)
{
DisplayName = "Amy"
}
};
await chatThreadClient.AddParticipantsAsync(participants);
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_AddParticipants
#region Snippet:Azure_Communication_Chat_Tests_Samples_RemoveParticipant
await chatThreadClient.RemoveParticipantAsync(gloria);
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_RemoveParticipant
await chatClient.DeleteChatThreadAsync(chatThreadClient.Id);
}
