public bool SaveOrUpdateChatThread(ChatThread record, DbActionFlag flag)
{
try
{
if (DbActionFlag.Create == flag)
{
_context.ChatThread.Add(record);
}
else if (DbActionFlag.Update == flag)
{
_context.Entry(record).State = System.Data.Entity.EntityState.Modified;
}
else if (DbActionFlag.Delete == flag)
{
_context.ChatThread.Remove(record);
}
_context.SaveChanges();
return(true);
}
catch (Exception ex)
{
return(false);
}
}
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());
}
public void RemoveOldCenterSectionsFromThread()
{
var sectionsToRemove = ChatThread.Where(x => x.Direction == MessageDirection.AwkwardCenter && ChatThread.LastOrDefault() != x).ToList();
foreach (var section in sectionsToRemove)
{
ChatThread.Remove(section);
}
}
public async Task GetThreadShouldSucceed()
{
//arrange
var threadId = "19:[email protected]";
ChatClient chatClient = CreateMockChatClient(200, GetThreadApiResponsePayload);
//act
ChatThread chatThread = await chatClient.GetChatThreadAsync(threadId);
//assert
Assert.AreEqual(threadId, chatThread.Id);
Assert.AreEqual("Test Thread", chatThread.Topic);
Assert.AreEqual("8:acs:1b5cc06b-f352-4571-b1e6-d9b259b7c776_00000007-8f5e-776d-ea7c-5a3a0d0027b7", CommunicationIdentifierSerializer.Serialize(chatThread.CreatedBy).CommunicationUser.Id);
}
public void AddOutgoingSection(Section sec)
{
if (sec == null)
{
return;
}
sec.Direction = MessageDirection.Out;
sec.DelayInMs = 0;
sec.Hidden = false;
if (sec is TextSection textSec)
{
textSec.Text = VerbProcessor.Process(textSec.Text);
}
ChatThread.Add(sec);
}
public void AddIncommingSection(Section sec)
{
if (sec == null)
{
return;
}
sec.Direction = MessageDirection.In;
if (sec is TextSection textSec)
{
textSec.Text = VerbProcessor.Process(textSec.Text);
}
ChatThread.Add(sec);
}
public async Task <IActionResult> User(InputMessage input)
{
User user = new User();
string connectionString = Environment.GetEnvironmentVariable("COMMUNICATION_SERVICES_CONNECTION_STRING");
var client = new CommunicationIdentityClient(connectionString);
var identity = new Azure.Communication.CommunicationUserIdentifier(user.UserID);
var tokenResponse = await client.GetTokenAsync(identity, scopes : new[] { CommunicationTokenScope.Chat });
user.AccessToken = tokenResponse.Value.Token;
Console.WriteLine(user.AccessToken);
Uri endpoint = new Uri("https://haroldtest.communication.azure.com");
CommunicationTokenCredential communicationTokenCredential = new CommunicationTokenCredential(user.AccessToken);
ChatClient chatClient = new ChatClient(endpoint, communicationTokenCredential);
Azure.Pageable <ChatThreadItem> threadItems = chatClient.GetChatThreads();
List <ChatThreadClient> ctclients = new List <ChatThreadClient>();
foreach (ChatThreadItem item in threadItems)
{
ChatThreadClient chatThreadClient = chatClient.GetChatThreadClient(item.Id);
ctclients.Add(chatThreadClient);
}
SendChatMessageResult sendChatMessageResult = await ctclients[input.ThreadIndex].SendMessageAsync(content: input.Message, type: ChatMessageType.Text, senderDisplayName: user.Name);
string messageId = sendChatMessageResult.Id;
Console.WriteLine(messageId);
foreach (ChatThreadItem item in threadItems)
{
ChatThreadClient chatThreadClient = chatClient.GetChatThreadClient(item.Id);
Azure.Pageable <ChatMessage> messages = chatThreadClient.GetMessages();
List <ChatMessage> messageList = new List <ChatMessage>();
foreach (ChatMessage message in messages)
{
messageList.Add(message);
}
ChatThread thread = new ChatThread(item.Id, item.Topic, messageList);
user.Threads.Add(thread);
}
Console.WriteLine(user.Threads[0].Topic);
Console.WriteLine(user.Threads[1].Topic);
ViewBag.user = user;
return(View());
}
public void ToggleTyping(bool show)
{
var incommingChat = ChatThread.Where(x => x.Direction == MessageDirection.In);
var alreadyVisible = incommingChat.Count() > 0 && incommingChat.Last().SectionType == SectionTypeEnum.Typing;
if (!alreadyVisible && show)
{
ChatThread.Add(new Section()
{
SectionType = SectionTypeEnum.Typing, _id = Guid.NewGuid().ToString()
});
}
if (alreadyVisible && !show)
{
ChatThread.Remove(incommingChat.Last());
}
}
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 void AddOutgoingSection(Section sec)
{
if (sec == null)
{
return;
}
sec.Direction = MessageDirection.Out;
sec.DelayInMs = 0;
sec.Hidden = false;
if (sec is TextSection textSec)
{
textSec.Text = VerbProcessor.Process(textSec.Text);
}
sec.Sno = (ChatThread.Count + 1);
ChatThread.Add(sec);
RemoveOldCenterSectionsFromThread();
}
public void AddCenterSection(Section sec)
{
if (sec == null)
{
return;
}
sec.Direction = MessageDirection.AwkwardCenter;
if (sec is TextSection textSec)
{
textSec.Text = VerbProcessor.Process(textSec.Text);
}
sec.Sno = (ChatThread.Count + 1);
ChatThread.Add(sec);
RemoveOldCenterSectionsFromThread();
}
public async Task <IActionResult> User()
{
User user = new User();
async System.Threading.Tasks.Task UserThreads()
{
string connectionString = Environment.GetEnvironmentVariable("COMMUNICATION_SERVICES_CONNECTION_STRING");
var client = new CommunicationIdentityClient(connectionString);
//var identityResponse = await client.CreateUserAsync();
//var identity = identityResponse.Value;
//Console.WriteLine(identity);
var identity = new Azure.Communication.CommunicationUserIdentifier(user.UserID);
var tokenResponse = await client.GetTokenAsync(identity, scopes : new[] { CommunicationTokenScope.Chat });
user.AccessToken = tokenResponse.Value.Token;
Console.WriteLine(user.AccessToken);
Uri endpoint = new Uri("https://haroldtest.communication.azure.com");
CommunicationTokenCredential communicationTokenCredential = new CommunicationTokenCredential(user.AccessToken);
ChatClient chatClient = new ChatClient(endpoint, communicationTokenCredential);
Azure.Pageable <ChatThreadItem> threadItems = chatClient.GetChatThreads();
foreach (ChatThreadItem item in threadItems)
{
ChatThreadClient chatThreadClient = chatClient.GetChatThreadClient(item.Id);
Azure.Pageable <ChatMessage> messages = chatThreadClient.GetMessages();
List <ChatMessage> messageList = new List <ChatMessage>();
foreach (ChatMessage message in messages)
{
messageList.Add(message);
}
ChatThread thread = new ChatThread(item.Id, item.Topic, messageList);
user.Threads.Add(thread);
}
Console.WriteLine(user.Threads[0].Topic);
Console.WriteLine(user.Threads[1].Topic);
}
await UserThreads();
Console.WriteLine(user.Threads[0].Topic);
ViewBag.user = user;
return(View());
}
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
}
private static async Task PostTeamChatNotification(GraphService graphClient, string groupId, string newDepartureGate)
{
// Get channels
var channels = await graphClient.GetTeamChannelsAsync(groupId);
// Create notification thread
var notificationThread = new ChatThread
{
RootMessage = new ChatMessage
{
Body = new ItemBody {
Content = $"Your flight will now depart from gate {newDepartureGate}"
}
}
};
// Post to all channels
foreach (var channel in channels.Value)
{
await graphClient.CreateChatThreadAsync(groupId, channel.Id, notificationThread);
}
}
public void ThreadCGUD_MemberAUR_MessageGSU_NotificationT()
{
//arr
Console.WriteLine($"ThreadCGUD_MemberAUR_MessageGSU_NotificationT Running on RecordedTestMode : {Mode}");
CommunicationIdentityClient communicationIdentityClient = CreateInstrumentedCommunicationIdentityClient();
(CommunicationUser user1, string token1) = CreateUserAndToken(communicationIdentityClient);
(CommunicationUser user2, string token2) = CreateUserAndToken(communicationIdentityClient);
(CommunicationUser user3, string token3) = CreateUserAndToken(communicationIdentityClient);
(CommunicationUser user4, string token4) = CreateUserAndToken(communicationIdentityClient);
var topic = "Thread sync from C# sdk";
var displayNameMessage = "DisplayName sender message 1";
var members = new List <ChatThreadMember>
{
new ChatThreadMember(user1),
new ChatThreadMember(user2),
new ChatThreadMember(user3)
};
ChatClient chatClient = CreateInstrumentedChatClient(token1);
ChatClient chatClient2 = CreateInstrumentedChatClient(token2);
ChatClient chatClient3 = CreateInstrumentedChatClient(token3);
//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);
var threadId = chatThreadClient.Id;
ChatThreadClient chatThreadClient2 = CreateInstrumentedChatThreadClient(chatClient, topic, members);
ChatThreadClient chatThreadClient3 = GetInstrumentedChatThreadClient(chatClient3, threadId);
string updatedTopic = "Launch meeting";
#region Snippet:Azure_Communication_Chat_Tests_E2E_UpdateThread
chatThreadClient.UpdateThread(topic: "Launch meeting");
#endregion Snippet:Azure_Communication_Chat_Tests_E2E_UpdateThread
#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();
string messageContent = "Let's meet at 11am";
#region Snippet:Azure_Communication_Chat_Tests_E2E_SendMessage
SendChatMessageResult sendChatMessageResult = chatThreadClient.SendMessage("Let's meet at 11am");
#endregion Snippet:Azure_Communication_Chat_Tests_E2E_SendMessage
var messageContent2 = "Content for message 2";
SendChatMessageResult sendChatMessageResult2 = chatThreadClient2.SendMessage(messageContent2, ChatMessagePriority.High, displayNameMessage);
var messageContent3 = "Content for message 3";
SendChatMessageResult sendChatMessageResult3 = chatThreadClient3.SendMessage(messageContent3, ChatMessagePriority.High, displayNameMessage);
var messageContent4 = "Content for message 4";
SendChatMessageResult sendChatMessageResult4 = chatThreadClient3.SendMessage(messageContent4, ChatMessagePriority.High, displayNameMessage);
var messageContent5 = "Content for message 5";
SendChatMessageResult sendChatMessageResult5 = chatThreadClient3.SendMessage(messageContent5, ChatMessagePriority.High, displayNameMessage);
var messageContent6 = "Content for message 6";
SendChatMessageResult sendChatMessageResult6 = chatThreadClient3.SendMessage(messageContent6, ChatMessagePriority.High, displayNameMessage);
var messageId = sendChatMessageResult.Id;
var messageId2 = sendChatMessageResult2.Id;
var messageId3 = sendChatMessageResult3.Id;
var messageId4 = sendChatMessageResult4.Id;
var messageId5 = sendChatMessageResult5.Id;
var messageId6 = sendChatMessageResult6.Id;
#region Snippet:Azure_Communication_Chat_Tests_E2E_GetMessage
ChatMessage message = chatThreadClient.GetMessage(messageId);
#endregion Snippet:Azure_Communication_Chat_Tests_E2E_GetMessage
ChatMessage message2 = chatThreadClient2.GetMessage(messageId2);
ChatMessage message3 = chatThreadClient3.GetMessage(messageId3);
ChatMessage message4 = chatThreadClient3.GetMessage(messageId4);
ChatMessage message5 = chatThreadClient3.GetMessage(messageId5);
ChatMessage message6 = chatThreadClient3.GetMessage(messageId6);
#region Snippet:Azure_Communication_Chat_Tests_E2E_GetMessages
Pageable <ChatMessage> messages = chatThreadClient.GetMessages();
#endregion Snippet:Azure_Communication_Chat_Tests_E2E_GetMessages
Pageable <ChatMessage> messages2 = chatThreadClient2.GetMessages();
var getMessagesCount = messages.Count();
var getMessagesCount2 = messages2.Count();
# region Pagination assertions
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 void ClearChatThread()
{
ChatThread.Clear();
ClearButtonTimer();
ClearButtons();
}
public async void ProcessNode(JToken node, JToken section = null)
{
if (node == null)
{
return;
}
ClearButtonTimer();
//Replaceing verbs
node = JToken.Parse(VerbProcessor.Process(node.ToString()));
var parsedNode = node.ToObject <ChatNode>();
if (parsedNode.Buttons != null && parsedNode.Buttons.Count > 0)
{
ClearButtons();
}
if (parsedNode.NodeType == NodeTypeEnum.ApiCall)
{
ToggleTyping(true);
try
{
var paramDict = new Dictionary <string, object>();
foreach (var reqParam in parsedNode.RequiredVariables)
{
if (reqParam == "HISTORY") //Custom Variable
{
paramDict[reqParam] = ChatThread.Where(x => x.SectionType != SectionTypeEnum.Typing).ToArray();
}
else
{
paramDict[reqParam] = ButtonActionHelper.GetSavedValue(reqParam);
}
}
var nextNodeId = parsedNode.NextNodeId; //Default
switch (parsedNode.ApiMethod.ToUpper())
{
case "GET":
{
var query = string.Join("&", paramDict.Select(x => $"{x.Key}={Uri.EscapeDataString(x.Value + "")}"));
var api = string.IsNullOrWhiteSpace(query) ? parsedNode.ApiUrl : parsedNode.ApiUrl + "?" + query;
var resp = await APIHelper.HitAsync <Dictionary <string, object> >(api);
if (resp.ContainsKey("NextNodeId"))
{
nextNodeId = resp["NextNodeId"] + "";
}
ButtonActionHelper.HandleSaveMultiple(resp);
}
break;
case "POST":
{
var resp = await APIHelper.HitPostAsync <Dictionary <string, object>, Dictionary <string, object> >(parsedNode.ApiUrl, paramDict);
if (resp.ContainsKey("NextNodeId"))
{
nextNodeId = resp["NextNodeId"] + "";
}
}
break;
default:
Utils.ShowDialog($"{parsedNode.ApiMethod} ApiType Unknown!");
break;
}
NavigateToNode(nextNodeId);
}
catch (HttpRequestException ex)
{
ToggleTyping(false);
Utils.ShowDialog(ex.ToString());
NavigateToNode(parsedNode.NextNodeId);
}
catch (Exception ex)
{
ToggleTyping(false);
Utils.ShowDialog(ex.ToString());
NavigateToNode(parsedNode.NextNodeId);
}
}
else if (node["Sections"] == null || node["Sections"].Children().Count() == 0)
{
ToggleTyping(false);
await ProcessButtonsAsync(node);
}
else if (node["Sections"] != null && node["Sections"].Children().Count() > 0)
{
var sectionsSource = node["Sections"];
var currentSectionSource = section ?? sectionsSource.First;
//Replaceing verbs
currentSectionSource = JToken.Parse(VerbProcessor.Process(currentSectionSource.ToString()));
SectionTypeEnum secType = (SectionTypeEnum)Enum.Parse(typeof(SectionTypeEnum), currentSectionSource["SectionType"].ToString());
Section parsedSection = null;
bool showTyping = false;
switch (secType)
{
case SectionTypeEnum.Image:
parsedSection = currentSectionSource.ToObject <ImageSection>();
showTyping = true;
break;
case SectionTypeEnum.Text:
parsedSection = currentSectionSource.ToObject <TextSection>();
break;
case SectionTypeEnum.Gif:
parsedSection = currentSectionSource.ToObject <GifSection>();
showTyping = true;
break;
case SectionTypeEnum.Video:
parsedSection = currentSectionSource.ToObject <VideoSection>();
break;
case SectionTypeEnum.Audio:
parsedSection = currentSectionSource.ToObject <AudioSection>();
break;
case SectionTypeEnum.EmbeddedHtml:
parsedSection = currentSectionSource.ToObject <EmbeddedHtmlSection>();
break;
case SectionTypeEnum.Link:
case SectionTypeEnum.Graph:
case SectionTypeEnum.Carousel:
Utils.ShowDialog($"{secType} Coming soon!");
break;
default:
break;
}
if (parsedSection != null)
{
if (parsedSection.DelayInMs > 50 || showTyping) //Add 'typing' bubble if delay is grather than 50 ms
{
ToggleTyping(true);
}
//Wait for delay MilliSeconds and then continue with chat
Dispatcher.Dispatch(async() =>
{
var precacheSucess = await PrecacheSection(parsedSection);
//Remove 'typing' bubble
ToggleTyping(false);
var sectionIndex = (sectionsSource.Children().ToList().FindIndex(x => x["_id"].ToString() == parsedSection._id));
if (precacheSucess)
{
if (sectionIndex == 0) //First section in node, send View Event
{
await Task.Run(async() =>
{
try
{
await APIHelper.TrackEvent(Utils.GetViewEvent(parsedNode.Id, Utils.DeviceId));
}
catch (Exception ex)
{
await Utils.ShowDialogAsync(ex.ToString());
}
});
}
AddIncommingSection(parsedSection);
}
var remainingSections = sectionsSource.Children().Count() - (sectionIndex + 1);
if (remainingSections > 0)
{
var nextSection = sectionsSource.ElementAt(sectionIndex + 1);
ProcessNode(node, nextSection);
}
else
{
await ProcessButtonsAsync(node);
}
}, parsedSection.DelayInMs);
}
}
}
public void ThreadCGUD_ParticipantAUR_MessageGSU_NotificationT()
{
//arr
Console.WriteLine($"ThreadCGUD_ParticipantAUR_MessageGSU_NotificationT Running on RecordedTestMode : {Mode}");
CommunicationIdentityClient communicationIdentityClient = CreateInstrumentedCommunicationIdentityClient();
(CommunicationUserIdentifier user1, string token1) = CreateUserAndToken(communicationIdentityClient);
(CommunicationUserIdentifier user2, _) = CreateUserAndToken(communicationIdentityClient);
(CommunicationUserIdentifier user3, string token3) = CreateUserAndToken(communicationIdentityClient);
(CommunicationUserIdentifier user4, _) = CreateUserAndToken(communicationIdentityClient);
(CommunicationUserIdentifier user5, _) = CreateUserAndToken(communicationIdentityClient);
string repeatabilityRequestId1 = "contoso-F0A747F1-6245-4307-8267-B974340677D2";
string repeatabilityRequestId2 = "contoso-A0A747F1-6245-4307-8267-B974340677DA";
var topic = "Thread sync from C# sdk";
var displayNameMessage = "DisplayName sender message 1";
var participants = new[]
{
new ChatParticipant(user1)
{
DisplayName = "user1"
},
new ChatParticipant(user2)
{
DisplayName = "user2"
},
new ChatParticipant(user3)
{
DisplayName = "user3"
}
};
ChatClient chatClient = CreateInstrumentedChatClient(token1);
ChatClient chatClient3 = CreateInstrumentedChatClient(token3);
//act
CreateChatThreadResult createChatThreadResult = chatClient.CreateChatThread(topic, participants, repeatabilityRequestId1);
ChatThreadClient chatThreadClient = GetInstrumentedChatThreadClient(chatClient, createChatThreadResult.ChatThread.Id);
var threadId = chatThreadClient.Id;
CreateChatThreadResult createChatThreadResult2 = chatClient.CreateChatThread(topic, participants, repeatabilityRequestId2);
ChatThreadClient chatThreadClient2 = GetInstrumentedChatThreadClient(chatClient, createChatThreadResult2.ChatThread.Id);
ChatThreadClient chatThreadClient3 = GetInstrumentedChatThreadClient(chatClient3, threadId);
Pageable <ChatParticipant> chatParticipantsOnCreation = chatThreadClient.GetParticipants();
var chatParticipantsOnCreationCount = chatParticipantsOnCreation.Count();
string updatedTopic = "Launch meeting";
chatThreadClient.UpdateTopic(topic: "Launch meeting");
ChatThread chatThread = chatClient.GetChatThread(threadId);
string messageContent = "Let's meet at 11am";
string messageId = chatThreadClient.SendMessage("Let's meet at 11am");
string messageContent2 = "Content for message 2";
string messageId2 = chatThreadClient2.SendMessage(messageContent2, ChatMessageType.Text, displayNameMessage);
string messageContent3 = "Content for message 3";
string messageId3 = chatThreadClient3.SendMessage(messageContent3, ChatMessageType.Html, displayNameMessage);
string messageContent4 = "Content for message 4";
string messageId4 = chatThreadClient3.SendMessage(messageContent4, ChatMessageType.Text, displayNameMessage);
string messageContent5 = "Content for message 5";
string messageId5 = chatThreadClient3.SendMessage(messageContent5, ChatMessageType.Html, displayNameMessage);
string messageContent6 = "Content for message 6";
string messageId6 = chatThreadClient3.SendMessage(messageContent6, ChatMessageType.Text, displayNameMessage);
ChatMessage message = chatThreadClient.GetMessage(messageId);
ChatMessage message2 = chatThreadClient2.GetMessage(messageId2);
ChatMessage message3 = chatThreadClient3.GetMessage(messageId3);
ChatMessage message4 = chatThreadClient3.GetMessage(messageId4);
ChatMessage message5 = chatThreadClient3.GetMessage(messageId5);
ChatMessage message6 = chatThreadClient3.GetMessage(messageId6);
Pageable <ChatMessage> messages = chatThreadClient.GetMessages();
Pageable <ChatMessage> messages2 = chatThreadClient2.GetMessages();
var getMessagesCount = messages.Count();
var getMessagesCount2 = messages2.Count();
Pageable <ChatMessage> pageableMessages = chatThreadClient.GetMessages();
PageableTester <ChatMessage> .AssertPagination(enumerableResource : pageableMessages, expectedPageSize : 2, expectedTotalResources : 8);
string updatedMessageContent = "Instead of 11am, let's meet at 2pm";
chatThreadClient.UpdateMessage(messageId, content: "Instead of 11am, let's meet at 2pm");
Response <ChatMessage> actualUpdateMessage = chatThreadClient.GetMessage(messageId);
chatThreadClient.DeleteMessage(messageId);
Pageable <ChatMessage> messagesAfterOneDeleted = chatThreadClient.GetMessages();
ChatMessage deletedChatMessage = messagesAfterOneDeleted.First(x => x.Id == messageId);
Pageable <ChatParticipant> chatParticipants = chatThreadClient.GetParticipants();
var chatParticipantsCount = chatParticipants.Count();
var newParticipant = new ChatParticipant(user4)
{
DisplayName = "user4"
};
var newParticipant2 = new ChatParticipant(user5)
{
DisplayName = "user5"
};
chatThreadClient.AddParticipants(participants: new[] { newParticipant });
AddChatParticipantsResult addChatParticipantsResult = chatThreadClient.AddParticipant(newParticipant2);
Pageable <ChatParticipant> chatParticipantsAfterTwoAdded = chatThreadClient.GetParticipants();
PageableTester <ChatParticipant> .AssertPagination(enumerableResource : chatParticipantsAfterTwoAdded, expectedPageSize : 2, expectedTotalResources : 5);
var chatParticipantsAfterTwoAddedCount = chatParticipantsAfterTwoAdded.Count();
Pageable <ChatMessage> messagesAfterParticipantsAdded = chatThreadClient.GetMessages();
ChatMessage participantAddedMessage = messagesAfterParticipantsAdded.First(x => x.Type == ChatMessageType.ParticipantAdded);
CommunicationUserIdentifier participantToBeRemoved = user4;
chatThreadClient.RemoveParticipant(identifier: participantToBeRemoved);
Pageable <ChatParticipant> chatParticipantAfterOneDeleted = chatThreadClient.GetParticipants();
var chatParticipantAfterOneDeletedCount = chatParticipantAfterOneDeleted.Count();
Pageable <ChatMessage> messagesAfterParticipantRemoved = chatThreadClient.GetMessages();
ChatMessage participantRemovedMessage = messagesAfterParticipantRemoved.First(x => x.Type == ChatMessageType.ParticipantRemoved);
Response typingNotificationResponse = chatThreadClient.SendTypingNotification();
chatThreadClient.SendTypingNotification();
Pageable <ChatThreadInfo> threads = chatClient.GetChatThreadsInfo();
var threadsCount = threads.Count();
chatClient.DeleteChatThread(threadId);
//assert
Assert.AreEqual(updatedTopic, chatThread.Topic);
Assert.AreEqual(3, chatParticipantsOnCreationCount);
Assert.AreEqual(messageContent, message.Content.Message);
Assert.AreEqual(updatedMessageContent, actualUpdateMessage.Value.Content.Message);
Assert.AreEqual(ChatMessageType.Text, message.Type);
Assert.AreEqual(messageContent2, message2.Content.Message);
Assert.AreEqual(displayNameMessage, message2.SenderDisplayName);
Assert.AreEqual(messageContent3, message3.Content.Message);
Assert.AreEqual(messageContent4, message4.Content.Message);
Assert.AreEqual(messageContent5, message5.Content.Message);
Assert.AreEqual(messageContent6, message6.Content.Message);
Assert.AreEqual(2, threadsCount);
Assert.AreEqual(8, getMessagesCount); //Including all types : 5 text message, 3 control messages
Assert.AreEqual(3, getMessagesCount2); //Including all types : 1 text message, 2 control messages
Assert.AreEqual(1, participantAddedMessage.Content.Participants.Count);
Assert.AreEqual(user5.Id, CommunicationIdentifierSerializer.Serialize(participantAddedMessage.Content.Participants[0].User).CommunicationUser.Id);
Assert.AreEqual("user5", participantAddedMessage.Content.Participants[0].DisplayName);
Assert.AreEqual(1, participantRemovedMessage.Content.Participants.Count);
Assert.AreEqual(user4.Id, CommunicationIdentifierSerializer.Serialize(participantRemovedMessage.Content.Participants[0].User).CommunicationUser.Id);
Assert.AreEqual("user4", participantRemovedMessage.Content.Participants[0].DisplayName);
Assert.IsTrue(deletedChatMessage.DeletedOn.HasValue);
Assert.AreEqual(3, chatParticipantsCount);
Assert.AreEqual(5, chatParticipantsAfterTwoAddedCount);
Assert.AreEqual(4, chatParticipantAfterOneDeletedCount);
Assert.IsNull(addChatParticipantsResult.Errors);
Assert.AreEqual((int)HttpStatusCode.OK, typingNotificationResponse.Status);
}
public async Task ThreadCGUD_ParticipantAUR_MessageGSU_NotificationT_Async()
{
//arr
Console.WriteLine($"ThreadCGUD_ParticipantAUR_MessageGSU_NotificationT_Async Running on RecordedTestMode : {Mode}");
CommunicationIdentityClient communicationIdentityClient = CreateInstrumentedCommunicationIdentityClient();
(CommunicationUserIdentifier user1, string token1) = await CreateUserAndTokenAsync(communicationIdentityClient);
(CommunicationUserIdentifier user2, _) = await CreateUserAndTokenAsync(communicationIdentityClient);
(CommunicationUserIdentifier user3, string token3) = await CreateUserAndTokenAsync(communicationIdentityClient);
(CommunicationUserIdentifier user4, _) = await CreateUserAndTokenAsync(communicationIdentityClient);
(CommunicationUserIdentifier user5, _) = await CreateUserAndTokenAsync(communicationIdentityClient);
string repeatabilityRequestId1 = "contoso-C0A747F1-6245-4307-8267-B974340677DC";
string repeatabilityRequestId2 = "contoso-D0A747F1-6245-4307-8267-B974340677DD";
var topic = "Thread async from C# sdk";
var displayNameMessage = "DisplayName sender message 1";
var participants = new List <ChatParticipant>
{
new ChatParticipant(user1)
{
DisplayName = "user1"
},
new ChatParticipant(user2)
{
DisplayName = "user2"
},
new ChatParticipant(user3)
{
DisplayName = "user3"
}
};
ChatClient chatClient = CreateInstrumentedChatClient(token1);
ChatClient chatClient3 = CreateInstrumentedChatClient(token3);
//act
CreateChatThreadResult createChatThreadResult = await chatClient.CreateChatThreadAsync(topic, participants, repeatabilityRequestId1);
ChatThreadClient chatThreadClient = GetInstrumentedChatThreadClient(chatClient, createChatThreadResult.ChatThread.Id);
var threadId = chatThreadClient.Id;
CreateChatThreadResult createChatThreadResult2 = await chatClient.CreateChatThreadAsync(topic, participants, repeatabilityRequestId2);
ChatThreadClient chatThreadClient2 = GetInstrumentedChatThreadClient(chatClient, createChatThreadResult2.ChatThread.Id);
ChatThreadClient chatThreadClient3 = GetInstrumentedChatThreadClient(chatClient3, threadId);
AsyncPageable <ChatParticipant> chatParticipantsOnCreation = chatThreadClient.GetParticipantsAsync();
var chatParticipantsOnCreationCount = chatParticipantsOnCreation.ToEnumerableAsync().Result.Count;
var updatedTopic = "Updated topic - C# sdk";
await chatThreadClient.UpdateTopicAsync(updatedTopic);
ChatThread chatThread = await chatClient.GetChatThreadAsync(threadId);
string messageContent = "Content for message 1";
string messageId = await chatThreadClient.SendMessageAsync(messageContent, ChatMessageType.Text, displayNameMessage);
string messageContent2 = "Content for message 2";
string messageId2 = await chatThreadClient2.SendMessageAsync(messageContent2, ChatMessageType.Html, displayNameMessage);
string messageContent3 = "Content for message 3";
string messageId3 = await chatThreadClient3.SendMessageAsync(messageContent3, ChatMessageType.Text, displayNameMessage);
string messageContent4 = "Content for message 4";
string messageId4 = await chatThreadClient3.SendMessageAsync(messageContent4, ChatMessageType.Html, displayNameMessage);
string messageContent5 = "Content for message 5";
string messageId5 = await chatThreadClient3.SendMessageAsync(messageContent5, ChatMessageType.Text, displayNameMessage);
string messageContent6 = "Content for message 6";
string messageId6 = await chatThreadClient3.SendMessageAsync(messageContent6, ChatMessageType.Html, displayNameMessage);
ChatMessage message = await chatThreadClient.GetMessageAsync(messageId);
ChatMessage message2 = await chatThreadClient2.GetMessageAsync(messageId2);
ChatMessage message3 = await chatThreadClient3.GetMessageAsync(messageId3);
ChatMessage message4 = await chatThreadClient3.GetMessageAsync(messageId4);
ChatMessage message5 = await chatThreadClient3.GetMessageAsync(messageId5);
ChatMessage message6 = await chatThreadClient3.GetMessageAsync(messageId6);
AsyncPageable <ChatMessage> messages = chatThreadClient.GetMessagesAsync();
AsyncPageable <ChatMessage> messages2 = chatThreadClient2.GetMessagesAsync();
var getMessagesCount = messages.ToEnumerableAsync().Result.Count;
var getMessagesCount2 = messages2.ToEnumerableAsync().Result.Count;
#region Messages Pagination assertions
AsyncPageable <ChatMessage> messagesPaginationTest = chatThreadClient.GetMessagesAsync();
await PageableTester <ChatMessage> .AssertPaginationAsync(enumerableResource : messagesPaginationTest, expectedPageSize : 2, expectedTotalResources : 8);
#endregion
var updatedMessageContent = "This is message 1 content updated";
await chatThreadClient.UpdateMessageAsync(messageId, updatedMessageContent);
Response <ChatMessage> actualUpdateMessage = await chatThreadClient.GetMessageAsync(messageId);
await chatThreadClient.DeleteMessageAsync(messageId);
List <ChatMessage> messagesAfterOneDeleted = chatThreadClient.GetMessagesAsync().ToEnumerableAsync().Result;
ChatMessage deletedChatMessage = messagesAfterOneDeleted.First(x => x.Id == messageId);
#region Participants Pagination assertions
AsyncPageable <ChatParticipant> chatParticipants = chatThreadClient.GetParticipantsAsync();
var chatParticipantsCount = chatParticipants.ToEnumerableAsync().Result.Count;
#endregion
var newParticipant = new ChatParticipant(user4)
{
DisplayName = "user4"
};
var newParticipant2 = new ChatParticipant(user5)
{
DisplayName = "user5"
};
AddChatParticipantsResult addChatParticipantsResult = await chatThreadClient.AddParticipantsAsync(participants : new[] { newParticipant });
AddChatParticipantsResult addChatParticipantsResult2 = await chatThreadClient.AddParticipantAsync(newParticipant2);
AsyncPageable <ChatParticipant> chatParticipantsAfterTwoOneAdded = chatThreadClient.GetParticipantsAsync();
await PageableTester <ChatParticipant> .AssertPaginationAsync(enumerableResource : chatParticipantsAfterTwoOneAdded, expectedPageSize : 2, expectedTotalResources : 5);
var chatParticipantsAfterTwoOneAddedCount = chatParticipantsAfterTwoOneAdded.ToEnumerableAsync().Result.Count;
List <ChatMessage> messagesAfterParticipantsAdded = chatThreadClient.GetMessagesAsync().ToEnumerableAsync().Result;
ChatMessage participantAddedMessage = messagesAfterParticipantsAdded.First(x => x.Type == ChatMessageType.ParticipantAdded);
CommunicationUserIdentifier participantToBeRemoved = user4;
await chatThreadClient.RemoveParticipantAsync(identifier : participantToBeRemoved);
AsyncPageable <ChatParticipant> chatParticipantAfterOneDeleted = chatThreadClient.GetParticipantsAsync();
var chatParticipantAfterOneDeletedCount = chatParticipantAfterOneDeleted.ToEnumerableAsync().Result.Count;
List <ChatMessage> messagesAfterParticipantRemoved = chatThreadClient.GetMessagesAsync().ToEnumerableAsync().Result;
ChatMessage participantRemovedMessage = messagesAfterParticipantRemoved.First(x => x.Type == ChatMessageType.ParticipantRemoved);
ChatMessage participantRemovedMessage2 = await chatThreadClient.GetMessageAsync(participantRemovedMessage.Id);
Response typingNotificationResponse = await chatThreadClient.SendTypingNotificationAsync();
await chatThreadClient.SendTypingNotificationAsync();
AsyncPageable <ChatThreadInfo> threads = chatClient.GetChatThreadsInfoAsync();
var threadsCount = threads.ToEnumerableAsync().Result.Count;
await chatClient.DeleteChatThreadAsync(threadId);
//assert
Assert.AreEqual(updatedTopic, chatThread.Topic);
Assert.AreEqual(3, chatParticipantsOnCreationCount);
Assert.AreEqual(messageContent, message.Content.Message);
Assert.AreEqual(displayNameMessage, message.SenderDisplayName);
Assert.AreEqual(updatedMessageContent, actualUpdateMessage.Value.Content.Message);
Assert.AreEqual(ChatMessageType.Text, message.Type);
Assert.AreEqual(messageContent2, message2.Content.Message);
Assert.AreEqual(messageContent3, message3.Content.Message);
Assert.AreEqual(messageContent4, message4.Content.Message);
Assert.AreEqual(messageContent5, message5.Content.Message);
Assert.AreEqual(messageContent6, message6.Content.Message);
Assert.AreEqual(2, threadsCount);
Assert.AreEqual(8, getMessagesCount); //Including all types : 5 text message, 3 control messages
Assert.AreEqual(3, getMessagesCount2); //Including all types : 1 text message, 2 control messages
Assert.AreEqual(1, participantAddedMessage.Content.Participants.Count);
Assert.AreEqual(user5.Id, CommunicationIdentifierSerializer.Serialize(participantAddedMessage.Content.Participants[0].User).CommunicationUser.Id);
Assert.AreEqual("user5", participantAddedMessage.Content.Participants[0].DisplayName);
Assert.AreEqual(1, participantRemovedMessage.Content.Participants.Count);
Assert.AreEqual(user4.Id, CommunicationIdentifierSerializer.Serialize(participantRemovedMessage.Content.Participants[0].User).CommunicationUser.Id);
Assert.AreEqual("user4", participantRemovedMessage.Content.Participants[0].DisplayName);
Assert.IsTrue(deletedChatMessage.DeletedOn.HasValue);
Assert.AreEqual(3, chatParticipantsCount);
Assert.AreEqual(5, chatParticipantsAfterTwoOneAddedCount);
Assert.AreEqual(4, chatParticipantAfterOneDeletedCount);
Assert.IsNull(addChatParticipantsResult.Errors);
Assert.IsNull(addChatParticipantsResult2.Errors);
Assert.AreEqual((int)HttpStatusCode.OK, typingNotificationResponse.Status);
}
private static async Task <Channel> InitializeTeamInGroupAsync(GraphService graphClient, string groupId, string welcomeMessage)
{
// Create the team
var team = new Team
{
GuestSettings = new TeamGuestSettings
{
AllowCreateUpdateChannels = false,
AllowDeleteChannels = false
}
};
await graphClient.CreateTeamAsync(groupId, team);
logger.Info("Created team");
// Get channels
var channels = await graphClient.GetTeamChannelsAsync(groupId);
// Get "General" channel. Since it is created by default and is the only
// channel after creation, just get the first result.
var generalChannel = channels.Value.First();
// Create welcome message (new thread)
var welcomeThread = new ChatThread
{
RootMessage = new ChatMessage
{
Body = new ItemBody {
Content = welcomeMessage
}
}
};
await graphClient.CreateChatThreadAsync(groupId, generalChannel.Id, welcomeThread);
logger.Info("Posted welcome message");
// Provision pilot channel
var pilotChannel = new Channel
{
DisplayName = "Pilots",
Description = "Discussion about flightpath, weather, etc."
};
await graphClient.CreateTeamChannelAsync(groupId, pilotChannel);
logger.Info("Created Pilots channel");
// Provision flight attendants channel
var flightAttendantsChannel = new Channel
{
DisplayName = "Flight Attendants",
Description = "Discussion about duty assignments, etc."
};
await graphClient.CreateTeamChannelAsync(groupId, flightAttendantsChannel);
logger.Info("Created FA channel");
// Add the requested team app
if (!string.IsNullOrEmpty(teamAppId))
{
var teamsApp = new TeamsApp
{
Id = teamAppId
};
await graphClient.AddAppToTeam(groupId, teamsApp);
}
logger.Info("Added app to team");
// Return the general channel
return(generalChannel);
}
public async Task CreateGetUpdateDeleteThreadAsync()
{
CommunicationIdentityClient communicationIdentityClient = new CommunicationIdentityClient(TestEnvironment.ConnectionString);
Response <CommunicationUserIdentifier> threadCreatorIdentifier = await communicationIdentityClient.CreateUserAsync();
CommunicationUserIdentifier kimberly = await communicationIdentityClient.CreateUserAsync();
AccessToken communicationUserToken = await communicationIdentityClient.GetTokenAsync(threadCreatorIdentifier.Value, new[] { CommunicationTokenScope.Chat });
string userToken = communicationUserToken.Token;
var endpoint = TestEnvironment.Endpoint;
#region Snippet:Azure_Communication_Chat_Tests_Samples_CreateChatClient
ChatClient chatClient = new ChatClient(
endpoint,
new CommunicationTokenCredential(userToken));
#endregion Snippet:Azure_Communication_Chat_Tests_Samples_CreateChatClient
#region Snippet:Azure_Communication_Chat_Tests_Samples_CreateThread
var chatParticipant = new ChatParticipant(communicationIdentifier: kimberly)
{
DisplayName = "Kim"
};
CreateChatThreadResult createChatThreadResult = await chatClient.CreateChatThreadAsync(topic : "Hello world!", participants : new[] { chatParticipant });
string threadId = createChatThreadResult.ChatThread.Id;
ChatThreadClient chatThreadClient = chatClient.GetChatThreadClient(threadId);
#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
await chatThreadClient.UpdateTopicAsync(topic : "new 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
var josh = new ChatParticipant(new CommunicationUserIdentifier("invalid user"));
#region Snippet:Azure_Communication_Chat_Tests_Samples_Troubleshooting
try
{
CreateChatThreadResult createChatThreadErrorResult = await chatClient.CreateChatThreadAsync(topic : "Hello world!", participants : new[] { josh });
}
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 void ProcessNode(JToken node, JToken section = null)
{
if (node == null)
{
Utils.ShowDialog("Node not found!");
return;
}
ClearButtonTimer();
//Replacing verbs
node = JToken.Parse(VerbProcessor.Process(node.ToString()));
var parsedNode = node.ToObject <ChatNode>();
if (parsedNode.Buttons != null && parsedNode.Buttons.Count > 0)
{
ClearButtons();
}
if (parsedNode.NodeType == NodeTypeEnum.HandoffToAgent)
{
await Utils.ShowDialogAsync("'HandoffToAgent' not supported in simulator");
}
else if (parsedNode.NodeType == NodeTypeEnum.ApiCall)
{
ToggleTyping(true);
try
{
var paramDict = new Dictionary <string, object>();
if (parsedNode.RequiredVariables != null)
{
foreach (var reqParam in parsedNode.RequiredVariables)
{
if (reqParam == "HISTORY") //Custom Variable
{
paramDict[reqParam] = ChatThread.Where(x => x.SectionType != SectionTypeEnum.Typing).ToArray();
}
else
{
paramDict[reqParam] = ButtonActionHelper.GetSavedValue(reqParam);
}
}
}
var nextNodeId = parsedNode.NextNodeId; //Default
switch (parsedNode.ApiMethod.ToUpper())
{
case "GET":
{
var query = string.Join("&", paramDict.Select(x => $"{x.Key}={Uri.EscapeDataString(x.Value + "")}"));
var api = string.IsNullOrWhiteSpace(query) ? parsedNode.ApiUrl : parsedNode.ApiUrl + (parsedNode.ApiUrl?.Contains("?") == true ? "&" : "?") + query;
var resp = await APIHelper.HitAsync <JObject>(api);
if (!string.IsNullOrWhiteSpace(resp["NextNodeId"] + ""))
{
nextNodeId = resp["NextNodeId"] + "";
}
ButtonActionHelper.HandleSaveMultiple(resp.ToObject <Dictionary <string, object> >());
var apiNextNodeId = ExtractNextNodeIdFromAPIResp(parsedNode, resp);
if (!string.IsNullOrWhiteSpace(apiNextNodeId))
{
nextNodeId = apiNextNodeId;
}
}
break;
case "POST":
{
var resp = await APIHelper.HitPostAsync <Dictionary <string, object>, JObject>(parsedNode.ApiUrl, paramDict);
if (!string.IsNullOrWhiteSpace(resp["NextNodeId"] + ""))
{
nextNodeId = resp["NextNodeId"] + "";
}
var apiNextNodeId = ExtractNextNodeIdFromAPIResp(parsedNode, resp);
if (!string.IsNullOrWhiteSpace(apiNextNodeId))
{
nextNodeId = apiNextNodeId;
}
}
break;
default:
Utils.ShowDialog($"{parsedNode.ApiMethod} ApiMethod Unsupported!");
break;
}
NavigateToNode(nextNodeId);
}
catch (Exception ex)
{
ToggleTyping(false);
Utils.ShowDialog($"API[{parsedNode.ApiMethod}]: {parsedNode.ApiUrl }\r\nRequired Vars: {(parsedNode.RequiredVariables == null ? "" : string.Join(",", parsedNode.RequiredVariables))}\r\nError: " + ex.Message);
NavigateToNode(parsedNode.NextNodeId);
}
}
else if (node["Sections"] == null || node["Sections"].Children().Count() == 0)
{
ToggleTyping(false);
await ProcessButtonsAsync(node);
}
else if (node["Sections"] != null && node["Sections"].Children().Count() > 0)
{
var sectionsSource = node["Sections"];
var currentSectionSource = section ?? sectionsSource.First;
//Replacing verbs
currentSectionSource = JToken.Parse(VerbProcessor.Process(currentSectionSource.ToString()));
SectionTypeEnum secType = (SectionTypeEnum)Enum.Parse(typeof(SectionTypeEnum), currentSectionSource["SectionType"].ToString());
Section parsedSection = null;
bool showTyping = false;
switch (secType)
{
case SectionTypeEnum.Image:
parsedSection = currentSectionSource.ToObject <ImageSection>();
showTyping = true;
break;
case SectionTypeEnum.Text:
parsedSection = currentSectionSource.ToObject <TextSection>();
break;
case SectionTypeEnum.Gif:
parsedSection = currentSectionSource.ToObject <GifSection>();
showTyping = true;
break;
case SectionTypeEnum.Video:
parsedSection = currentSectionSource.ToObject <VideoSection>();
break;
case SectionTypeEnum.Audio:
parsedSection = currentSectionSource.ToObject <AudioSection>();
break;
case SectionTypeEnum.EmbeddedHtml:
parsedSection = currentSectionSource.ToObject <EmbeddedHtmlSection>();
break;
case SectionTypeEnum.PrintOTP:
parsedSection = currentSectionSource.ToObject <PrintOTPSection>();
break;
case SectionTypeEnum.Carousel:
{
parsedSection = currentSectionSource.ToObject <CarouselSection>();
(parsedSection as CarouselSection).Items = VerbProcessor.ProcessCarousalItems((parsedSection as CarouselSection).Items, parsedNode);
}
break;
case SectionTypeEnum.Link:
case SectionTypeEnum.Graph:
Utils.ShowDialog($"{secType} Coming soon!");
break;
default:
break;
}
#if DEBUG
if (Debugger.IsAttached)
{
if (parsedSection != null)
{
parsedSection.DelayInMs = 0;
}
}
else
{
if (parsedSection != null && parsedSection.DelayInMs <= 0)
{
parsedSection.DelayInMs = 2000;
}
}
#endif
if (parsedSection != null)
{
if (parsedSection.DelayInMs > 50 || showTyping) //Add 'typing' bubble if delay is greater than 50 ms
{
ToggleTyping(true);
}
//Wait for delay MilliSeconds and then continue with chat
Dispatcher.Dispatch(async() =>
{
var precacheSucess = await PrecacheSection(parsedSection);
//Remove 'typing' bubble
ToggleTyping(false);
var sectionIndex = (sectionsSource.Children().ToList().FindIndex(x => x["_id"].ToString() == parsedSection._id));
if (precacheSucess)
{
if (parsedNode.NodeType == NodeTypeEnum.Card)
{
parsedSection.Title = VerbProcessor.Process(parsedNode.CardHeader);
parsedSection.Caption = VerbProcessor.Process(parsedNode.CardFooter);
if (parsedNode.Placement == null || parsedNode.Placement == Placement.Incoming)
{
AddIncommingSection(parsedSection);
}
else if (parsedNode.Placement == Placement.Outgoing)
{
AddOutgoingSection(parsedSection);
}
else if (parsedNode.Placement == Placement.Center)
{
AddCenterSection(parsedSection);
}
}
else
{
AddIncommingSection(parsedSection);
}
}
var remainingSections = sectionsSource.Children().Count() - (sectionIndex + 1);
if (remainingSections > 0)
{
var nextSection = sectionsSource.ElementAt(sectionIndex + 1);
ProcessNode(node, nextSection);
}
else
{
await ProcessButtonsAsync(node);
}
}, parsedSection.DelayInMs);
}
}
}
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}");
}
}
/// <summary> Initializes a new instance of CreateChatThreadResult. </summary>
/// <param name="createChatThreadResultInternal"> Chat thread. </param>
internal CreateChatThreadResult(CreateChatThreadResultInternal createChatThreadResultInternal)
{
ChatThread = new ChatThread(createChatThreadResultInternal.ChatThread);
Errors = createChatThreadResultInternal.Errors;
}
