public async Task <ActionResult> TryAddUserToThread(string threadId, [FromBody] ContosoMemberModel user) { try { var moderator = _store.Store[threadId]; var userCredential = new CommunicationUserCredential(moderator.token); ChatClient chatClient = new ChatClient(new Uri(_chatGatewayUrl), userCredential); ChatThread chatThread = chatClient.GetChatThread(threadId); ChatThreadClient chatThreadClient = chatClient.GetChatThreadClient(threadId); var chatThreadMember = new ChatThreadMember(new CommunicationUser(user.Id)); chatThreadMember.DisplayName = user.DisplayName; chatThreadMember.ShareHistoryTime = chatThread.CreatedOn; List <ChatThreadMember> chatThreadMembers = new List <ChatThreadMember> { chatThreadMember }; try { var response = await chatThreadClient.AddMembersAsync(chatThreadMembers); return(StatusCode(response.Status)); } catch (RequestFailedException e) { Console.WriteLine($"Unexpected error occurred while adding user from thread: {e}"); return(StatusCode(e.Status)); } } catch (Exception e) { Console.WriteLine($"Unexpected error occurred while adding user from thread: {e}"); } return(Ok()); }
/// <summary> /// AddUserToChatThread() - add a new member to an existing chat thread /// </summary> /// <returns></returns> private static async Task AddUserToChatThread() { Console.WriteLine("# Adding a user to a chat thread"); Console.Write("Enter thread id: "); var threadId = Console.ReadLine(); Console.Write("Enter user id: "); var userToAdd = Console.ReadLine(); Console.Write("Enter display name: "); var userDisplayname = Console.ReadLine(); Uri endpoint = new Uri("https://ACS-INSTANCE.communication.azure.com/"); CommunicationUserCredential communicationUserCredential = new CommunicationUserCredential(token); ChatClient chatClient = new ChatClient(endpoint, communicationUserCredential); var chatThreadMember = new ChatThreadMember(new CommunicationUser(userToAdd)) { DisplayName = userDisplayname }; ChatThreadClient chatThreadClient = chatClient.GetChatThreadClient(threadId); await chatThreadClient.AddMembersAsync(members : new[] { chatThreadMember }); Console.WriteLine($"User {userDisplayname} added to thread"); }
public User(string userId, CommunicationUser communicationUser) { UserId = userId; CommunicationUser = communicationUser; ChatThreadMember = new ChatThreadMember(CommunicationUser) { DisplayName = UserId, ShareHistoryTime = new System.DateTimeOffset(), User = communicationUser }; }
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 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}"); } }
/// <summary> /// CreateNewChatThread() - provision a new chat thread (like a channel or a group chat) /// </summary> /// <returns></returns> private static async Task <string> CreateNewChatThread() { Console.WriteLine("\n# Creating a new chat thread"); Console.WriteLine("Enter thread topic: "); var topic = Console.ReadLine(); Uri endpoint = new Uri("https://ACS-INSTANCE.communication.azure.com/"); CommunicationUserCredential communicationUserCredential = new CommunicationUserCredential(token); ChatClient chatClient = new ChatClient(endpoint, communicationUserCredential); var chatThreadMember = new ChatThreadMember(new CommunicationUser(userid)) { DisplayName = displayname }; ChatThreadClient chatThreadClient = await chatClient.CreateChatThreadAsync(topic : topic, members : new[] { chatThreadMember }); Console.WriteLine($"Chat thread ID: {chatThreadClient.Id}"); return(chatThreadClient.Id); }
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 void E2E_ThreadCreateUpdateGetDelete_MemberAddUpdateRemove_MessageGetSendUpdate_NotificationTyping_ReadReceiptGetSend() { //arr CommunicationUser user1, user2, user3; string token1, token2, token3; CommunicationIdentityClient communicationIdentityClient = CreateInstrumentedCommunicationIdentityClient(); (user1, token1) = CreateUserAndToken(communicationIdentityClient); (user2, token2) = CreateUserAndToken(communicationIdentityClient); (user3, token3) = CreateUserAndToken(communicationIdentityClient); var topic = "Thread sync from C# sdk"; var messageContent = "This is message 1 content"; var updatedMessageContent = "This is message 1 content updated"; var displayNameMessage = "DisplayName sender message 1"; var updatedTopic = "Updated topic - C# sdk"; var members = new List <ChatThreadMember> { new ChatThreadMember(user1), new ChatThreadMember(user2) }; ChatClient chatClient = CreateInstrumentedChatClient(token1); ChatClient chatClient2 = CreateInstrumentedChatClient(token2); //act #region Snippet:Azure_Communication_Chat_Tests_E2E_InitializeChatThreadClient //@@ChatThreadClient chatThreadClient1 = chatClient.CreateChatThread("Thread topic", members); // Alternatively, if you have created a chat thread before and you have its threadId, you can create a ChatThreadClient instance using: //@@ChatThreadClient chatThreadClient2 = chatClient.GetChatThreadClient("threadId"); #endregion Snippet:Azure_Communication_Chat_Tests_E2E_InitializeChatThreadClient ChatThreadClient chatThreadClient = CreateInstrumentedChatThreadClient(chatClient, topic, members); ChatThreadClient chatThreadClient2 = CreateInstrumentedChatThreadClient(chatClient, topic, members); #region Snippet:Azure_Communication_Chat_Tests_E2E_UpdateThread chatThreadClient.UpdateThread("Updated topic - C# sdk"); #endregion Snippet:Azure_Communication_Chat_Tests_E2E_UpdateThread var threadId = chatThreadClient.Id; #region Snippet:Azure_Communication_Chat_Tests_E2E_GetChatThread ChatThread chatThread = chatClient.GetChatThread(threadId); #endregion Snippet:Azure_Communication_Chat_Tests_E2E_GetChatThread #region Snippet:Azure_Communication_Chat_Tests_E2E_GetChatThreadsInfo Pageable <ChatThreadInfo> threads = chatClient.GetChatThreadsInfo(); #endregion Snippet:Azure_Communication_Chat_Tests_E2E_GetChatThreadsInfo var threadsCount = threads.Count(); #region Snippet:Azure_Communication_Chat_Tests_E2E_SendMessage SendChatMessageResult sendChatMessageResult = chatThreadClient.SendMessage("This is message 1 content", ChatMessagePriority.High, displayNameMessage); #endregion Snippet:Azure_Communication_Chat_Tests_E2E_SendMessage SendChatMessageResult sendChatMessageResult2 = chatThreadClient.SendMessage(messageContent, ChatMessagePriority.High, displayNameMessage); var messageId = sendChatMessageResult.Id; #region Snippet:Azure_Communication_Chat_Tests_E2E_GetMessage ChatMessage message = chatThreadClient.GetMessage(messageId); #endregion Snippet:Azure_Communication_Chat_Tests_E2E_GetMessage #region Snippet:Azure_Communication_Chat_Tests_E2E_GetMessages Pageable <ChatMessage> messages = chatThreadClient.GetMessages(); #endregion Snippet:Azure_Communication_Chat_Tests_E2E_GetMessages var getMessagesCount = messages.Count(); #region Snippet:Azure_Communication_Chat_Tests_E2E_UpdateMessage chatThreadClient.UpdateMessage(messageId, "This is message 1 content updated"); #endregion Snippet:Azure_Communication_Chat_Tests_E2E_UpdateMessage Response <ChatMessage> actualUpdateMessage = chatThreadClient.GetMessage(messageId); #region Snippet:Azure_Communication_Chat_Tests_E2E_DeleteMessage chatThreadClient.DeleteMessage(messageId); #endregion Snippet:Azure_Communication_Chat_Tests_E2E_DeleteMessage Pageable <ChatMessage> messagesAfterOneDeleted = chatThreadClient.GetMessages(); ChatMessage deletedChatMessage = messagesAfterOneDeleted.First(x => x.Id == messageId); #region Snippet:Azure_Communication_Chat_Tests_E2E_GetMembers Pageable <ChatThreadMember> chatThreadMembers = chatThreadClient.GetMembers(); #endregion Snippet:Azure_Communication_Chat_Tests_E2E_GetMembers var chatThreadMembersCount = chatThreadMembers.Count(); var newMember = new ChatThreadMember(user3); #region Snippet:Azure_Communication_Chat_Tests_E2E_AddMembers chatThreadClient.AddMembers(members: new[] { newMember }); #endregion Snippet:Azure_Communication_Chat_Tests_E2E_AddMembers Pageable <ChatThreadMember> chatThreadMembersAfterOneAdded = chatThreadClient.GetMembers(); var chatThreadMembersAfterOneAddedCount = chatThreadMembersAfterOneAdded.Count(); CommunicationUser memberToBeRemoved = user3; //Better name for the snippet #region Snippet:Azure_Communication_Chat_Tests_E2E_RemoveMember chatThreadClient.RemoveMember(user: memberToBeRemoved); #endregion Snippet:Azure_Communication_Chat_Tests_E2E_RemoveMember Pageable <ChatThreadMember> chatThreadMembersAfterOneDeleted = chatThreadClient.GetMembers(); var chatThreadMembersAfterOneDeletedCount = chatThreadMembersAfterOneDeleted.Count(); Response typingNotificationResponse = chatThreadClient.SendTypingNotification(); #region Snippet:Azure_Communication_Chat_Tests_E2E_SendTypingNotification chatThreadClient.SendTypingNotification(); #endregion Snippet:Azure_Communication_Chat_Tests_E2E_SendTypingNotification #region Snippet:Azure_Communication_Chat_Tests_E2E_SendReadReceipt chatThreadClient.SendReadReceipt(messageId); #endregion Snippet:Azure_Communication_Chat_Tests_E2E_SendReadReceipt chatThreadClient.SendReadReceipt(sendChatMessageResult2.Id); #region Snippet:Azure_Communication_Chat_Tests_E2E_GetReadReceipts Pageable <ReadReceipt> readReceipts = chatThreadClient.GetReadReceipts(); #endregion Snippet:Azure_Communication_Chat_Tests_E2E_GetReadReceipts var readReceiptsCount = readReceipts.Count(); #region Snippet:Azure_Communication_Chat_Tests_E2E_DeleteChatThread chatClient.DeleteChatThread(threadId); #endregion Snippet:Azure_Communication_Chat_Tests_E2E_DeleteChatThread //assert Assert.AreEqual(updatedTopic, chatThread.Topic); Assert.AreEqual(2, chatThread.Members.Count); Assert.AreEqual(messageContent, message.Content); Assert.AreEqual(displayNameMessage, message.SenderDisplayName); Assert.AreEqual(ChatMessagePriority.High, message.Priority); Assert.AreEqual(2, threadsCount); Assert.AreEqual(5, getMessagesCount); //Including all types Assert.AreEqual(updatedMessageContent, actualUpdateMessage.Value.Content); Assert.IsTrue(deletedChatMessage.DeletedOn.HasValue); Assert.AreEqual(2, chatThreadMembersCount); Assert.AreEqual(3, chatThreadMembersAfterOneAddedCount); Assert.AreEqual(2, chatThreadMembersAfterOneDeletedCount); Assert.AreEqual((int)HttpStatusCode.OK, typingNotificationResponse.Status); // TODO: Commenting out the assert below for now as it is flakey due to server-side delay; currently in investigation // Assert.AreEqual(1, readReceiptsCount); }
public async Task E2E_ThreadCreateUpdateGetDelete_MemberAddUpdateRemove_MessageGetSendUpdate_NotificationTyping_ReadReceiptGetSend_Async() { //arr CommunicationUser user1, user2, user3; string token1, token2, token3; CommunicationIdentityClient communicationIdentityClient = CreateInstrumentedCommunicationIdentityClient(); (user1, token1) = await CreateUserAndTokenAsync(communicationIdentityClient); (user2, token2) = await CreateUserAndTokenAsync(communicationIdentityClient); (user3, token3) = await CreateUserAndTokenAsync(communicationIdentityClient); var topic = "Thread Async from C# sdk"; var contentMessage = "This is message 1"; var updatedMessageContent = "This is message 1 updated"; var displayNameMessage = "DisplayName sender message 1"; var updatedTopic = "Updated topic - C# sdk"; var members = new List <ChatThreadMember> { new ChatThreadMember(user1), new ChatThreadMember(user2) }; ChatClient chatClient = CreateInstrumentedChatClient(token1); ChatClient chatClient2 = CreateInstrumentedChatClient(token2); //act ChatThreadClient chatThreadClient = await CreateInstrumentedChatThreadClientAsync(chatClient, topic, members); ChatThreadClient chatThreadClient2 = await CreateInstrumentedChatThreadClientAsync(chatClient, topic, members); await chatThreadClient.UpdateThreadAsync(updatedTopic); ChatThread chatThread = await chatClient.GetChatThreadAsync(chatThreadClient.Id); AsyncPageable <ChatThreadInfo> threads = chatClient.GetChatThreadsInfoAsync(); var threadsCount = threads.ToEnumerableAsync().Result.Count; SendChatMessageResult sendChatMessageResult = await chatThreadClient.SendMessageAsync(contentMessage, ChatMessagePriority.High, displayNameMessage); SendChatMessageResult sendChatMessageResult2 = await chatThreadClient.SendMessageAsync(contentMessage, ChatMessagePriority.High, displayNameMessage); ChatMessage message = await chatThreadClient.GetMessageAsync(sendChatMessageResult.Id); AsyncPageable <ChatMessage> messages = chatThreadClient.GetMessagesAsync(); var getMessagesCount = messages.ToEnumerableAsync().Result.Count; var messageId = sendChatMessageResult.Id; await chatThreadClient.UpdateMessageAsync(messageId, updatedMessageContent); Response <ChatMessage> actualUpdateMessage = await chatThreadClient.GetMessageAsync(messageId); await chatThreadClient.DeleteMessageAsync(messageId); AsyncPageable <ChatMessage> messagesAfterOneDeleted = chatThreadClient.GetMessagesAsync(); ChatMessage deletedChatMessage = messagesAfterOneDeleted.ToEnumerableAsync().Result.First(x => x.Id == messageId); AsyncPageable <ChatThreadMember> chatThreadMembers = chatThreadClient.GetMembersAsync(); var chatThreadMembersCount = chatThreadMembers.ToEnumerableAsync().Result.Count; var newMember = new ChatThreadMember(user3); await chatThreadClient.AddMembersAsync(new List <ChatThreadMember> { newMember }); AsyncPageable <ChatThreadMember> chatThreadMembersAfterOneAdded = chatThreadClient.GetMembersAsync(); var chatThreadMembersAfterOneAddedCount = chatThreadMembersAfterOneAdded.ToEnumerableAsync().Result.Count(); CommunicationUser userToBeRemoved = user3; //Better name for the snippet await chatThreadClient.RemoveMemberAsync(userToBeRemoved); AsyncPageable <ChatThreadMember> chatThreadMembersAfterOneDeleted = chatThreadClient.GetMembersAsync(); var chatThreadMembersAfterOneDeletedCount = chatThreadMembersAfterOneDeleted.ToEnumerableAsync().Result.Count(); Response typingNotificationResponse = await chatThreadClient.SendTypingNotificationAsync(); await chatThreadClient.SendTypingNotificationAsync(); await chatThreadClient.SendReadReceiptAsync(messageId); await chatThreadClient.SendReadReceiptAsync(sendChatMessageResult2.Id); AsyncPageable <ReadReceipt> readReceipts = chatThreadClient.GetReadReceiptsAsync(); var readReceiptsCount = readReceipts.ToEnumerableAsync().Result.Count(); await chatClient.DeleteChatThreadAsync(chatThreadClient.Id); //assert Assert.AreEqual(updatedTopic, chatThread.Topic); Assert.AreEqual(2, chatThread.Members.Count); Assert.AreEqual(contentMessage, message.Content); Assert.AreEqual(displayNameMessage, message.SenderDisplayName); Assert.AreEqual(ChatMessagePriority.High, message.Priority); Assert.AreEqual(2, threadsCount); Assert.AreEqual(5, getMessagesCount); //Including all types Assert.AreEqual(updatedMessageContent, actualUpdateMessage.Value.Content); Assert.IsTrue(deletedChatMessage.DeletedOn.HasValue); Assert.AreEqual(2, chatThreadMembersCount); Assert.AreEqual(3, chatThreadMembersAfterOneAddedCount); Assert.AreEqual(2, chatThreadMembersAfterOneDeletedCount); Assert.AreEqual((int)HttpStatusCode.OK, typingNotificationResponse.Status); //TODO: Commenting out the assert below for now as it is flakey due to server-side delay; currently in investigation // Assert.AreEqual(1, readReceiptsCount); }
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}"); } }