/// Join the call using server call id.
/// <param name="serverCallId"> The server call id. </param>
/// <param name="source"> The source identity. </param>
/// <param name="callOptions"> The call Options. </param>
/// <param name="cancellationToken"> The cancellation token. </param>
/// <exception cref="RequestFailedException">The server returned an error. See <see cref="Exception.Message"/> for details returned from the server.</exception>
/// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
/// <exception cref="ArgumentNullException"><paramref name="serverCallId"/> is null.</exception>
/// <exception cref="ArgumentNullException"><paramref name="callOptions"/> is null.</exception>
public virtual Response <CallConnection> JoinCall(string serverCallId, CommunicationIdentifier source, JoinCallOptions callOptions, CancellationToken cancellationToken = default)
{
using DiagnosticScope scope = _clientDiagnostics.CreateScope($"{nameof(CallingServerClient)}.{nameof(JoinCall)}");
scope.Start();
try
{
Argument.AssertNotNull(source, nameof(source));
Argument.AssertNotNull(callOptions, nameof(callOptions));
var joinCallResponse = ServerCallRestClient.JoinCall(
serverCallId: serverCallId,
source: CommunicationIdentifierSerializer.Serialize(source),
callbackUri: callOptions.CallbackUri?.AbsoluteUri,
requestedMediaTypes: callOptions.RequestedMediaTypes,
requestedCallEvents: callOptions.RequestedCallEvents,
subject: null,
cancellationToken: cancellationToken
);
return(Response.FromValue(
new CallConnection(joinCallResponse.Value.CallConnectionId, CallConnectionRestClient, _clientDiagnostics),
joinCallResponse.GetRawResponse()));
}
catch (Exception ex)
{
scope.Failed(ex);
throw;
}
}
/// Create an outgoing call from source to target identities.
/// <param name="source"> The source identity </param>
/// <param name="targets"> The target identities. </param>
/// <param name="options"> The call options. </param>
/// <param name="cancellationToken"> The cancellation token. </param>
/// <exception cref="RequestFailedException">The server returned an error. See <see cref="Exception.Message"/> for details returned from the server.</exception>
/// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
/// <exception cref="ArgumentNullException"><paramref name="targets"/> is null.</exception>
/// <exception cref="ArgumentNullException"><paramref name="options"/> is null.</exception>
public virtual async Task <Response <CallConnection> > CreateCallConnectionAsync(CommunicationIdentifier source, IEnumerable <CommunicationIdentifier> targets, CreateCallOptions options, CancellationToken cancellationToken = default)
{
using DiagnosticScope scope = _clientDiagnostics.CreateScope($"{nameof(CallingServerClient)}.{nameof(CreateCallConnection)}");
scope.Start();
try
{
Argument.AssertNotNull(source, nameof(source));
Argument.AssertNotNullOrEmpty(targets, nameof(targets));
Argument.AssertNotNull(options, nameof(options));
var createCallResponse = await CallConnectionRestClient.CreateCallAsync(
source : CommunicationIdentifierSerializer.Serialize(source),
targets : targets.Select(t => CommunicationIdentifierSerializer.Serialize(t)),
callbackUri : options.CallbackUri?.AbsoluteUri,
requestedMediaTypes : options.RequestedMediaTypes,
requestedCallEvents : options.RequestedCallEvents,
alternateCallerId : options.AlternateCallerId == null?null : new PhoneNumberIdentifierModel(options.AlternateCallerId.PhoneNumber),
subject : options.Subject,
cancellationToken : cancellationToken
).ConfigureAwait(false);
return(Response.FromValue(
new CallConnection(createCallResponse.Value.CallConnectionId, CallConnectionRestClient, _clientDiagnostics),
createCallResponse.GetRawResponse()));
}
catch (Exception ex)
{
scope.Failed(ex);
throw;
}
}
/// Create an outgoing call from source to target identities.
/// <param name="source"> The source identity </param>
/// <param name="targets"> The target identities. </param>
/// <param name="options"> The call options. </param>
/// <param name="cancellationToken"> The cancellation token. </param>
/// <exception cref="RequestFailedException">The server returned an error. See <see cref="Exception.Message"/> for details returned from the server.</exception>
/// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
/// <exception cref="ArgumentNullException"><paramref name="targets"/> is null.</exception>
/// <exception cref="ArgumentNullException"><paramref name="options"/> is null.</exception>
public virtual Response <CreateCallResponse> CreateCall(CommunicationIdentifier source, IEnumerable <CommunicationIdentifier> targets, CreateCallOptions options, CancellationToken cancellationToken = default)
{
using DiagnosticScope scope = _clientDiagnostics.CreateScope($"{nameof(CallClient)}.{nameof(CreateCall)}");
scope.Start();
try
{
Argument.AssertNotNull(source, nameof(source));
Argument.AssertNotNullOrEmpty(targets, nameof(targets));
Argument.AssertNotNull(options, nameof(options));
var sourceAlternateIdentity = options.AlternateCallerId == null ? null : new PhoneNumberIdentifierModel(options.AlternateCallerId.PhoneNumber);
return(RestClient.CreateCall(
targets: targets.Select(t => CommunicationIdentifierSerializer.Serialize(t)),
source: CommunicationIdentifierSerializer.Serialize(source),
callbackUri: options.CallbackUri?.AbsoluteUri,
requestedModalities: options.RequestedModalities,
requestedCallEvents: options.RequestedCallEvents,
sourceAlternateIdentity: sourceAlternateIdentity,
subject: options.Subject,
cancellationToken: cancellationToken
));
}
catch (Exception ex)
{
scope.Failed(ex);
throw;
}
}
/// <summary> Add a participant to the call. </summary>
/// <param name="callLegId"> The call leg id. </param>
/// <param name="participant"> The identity of participant to be added to the call. </param>
/// <param name="alternateCallerId">The phone number to use when adding a pstn participant.</param>
/// <param name="operationContext">The operation context. </param>
/// <param name="cancellationToken"> The cancellation token. </param>
/// <exception cref="RequestFailedException">The server returned an error. See <see cref="Exception.Message"/> for details returned from the server.</exception>
/// <exception cref="ArgumentNullException"> <paramref name="participant"/> is null. </exception>
public virtual Response AddParticipant(string callLegId, CommunicationIdentifier participant, string alternateCallerId = default, string operationContext = default, CancellationToken cancellationToken = default)
{
using DiagnosticScope scope = _clientDiagnostics.CreateScope($"{nameof(CallClient)}.{nameof(AddParticipant)}");
scope.Start();
try
{
Argument.AssertNotNull(participant, nameof(participant));
Argument.AssertNotNullOrEmpty(alternateCallerId, nameof(alternateCallerId));
return(RestClient.InviteParticipants(
callId: callLegId,
participants: new List <CommunicationIdentifierModel>()
{
CommunicationIdentifierSerializer.Serialize(participant)
},
alternateCallerId: new PhoneNumberIdentifierModel(alternateCallerId),
operationContext: operationContext,
callbackUri: null,
cancellationToken: cancellationToken
));
}
catch (Exception ex)
{
scope.Failed(ex);
throw;
}
}
/// Join the call using conversation id.
/// <param name="conversationId"> The conversation id that can be a group id or a encoded conversation url retrieve from client. </param>
/// <param name="source"> The source identity. </param>
/// <param name="callOptions"> The call Options. </param>
/// <param name="cancellationToken"> The cancellation token. </param>
/// <exception cref="RequestFailedException">The server returned an error. See <see cref="Exception.Message"/> for details returned from the server.</exception>
/// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
/// <exception cref="ArgumentNullException"><paramref name="conversationId"/> is null.</exception>
/// <exception cref="ArgumentNullException"><paramref name="callOptions"/> is null.</exception>
public virtual Response <JoinCallResponse> JoinCall(string conversationId, CommunicationIdentifier source, JoinCallOptions callOptions, CancellationToken cancellationToken = default)
{
using DiagnosticScope scope = _clientDiagnostics.CreateScope($"{nameof(CallClient)}.{nameof(JoinCall)}");
scope.Start();
try
{
Argument.AssertNotNull(source, nameof(source));
Argument.AssertNotNull(callOptions, nameof(callOptions));
return(RestClient.JoinCall(
conversationId: conversationId,
source: CommunicationIdentifierSerializer.Serialize(source),
callbackUri: callOptions.CallbackUri?.AbsoluteUri,
requestedModalities: callOptions.RequestedModalities,
requestedCallEvents: callOptions.RequestedCallEvents,
subject: null,
cancellationToken: cancellationToken
));
}
catch (Exception ex)
{
scope.Failed(ex);
throw;
}
}
/// <summary>
/// Add participant to the call.
/// </summary>
/// <param name="conversationId"> The conversation id that can be a group id or a encoded conversation url retrieve from client. </param>
/// <param name="participant"> The identity of participant to be added to the call. </param>
/// <param name="callbackUri"></param>
/// <param name="alternateCallerId">The phone number to use when adding a pstn participant.</param>
/// <param name="operationContext">The operation context.</param>
/// <param name="cancellationToken">The cancellation token.</param>
public virtual async Task <Response> AddParticipantAsync(string conversationId, CommunicationIdentifier participant, Uri callbackUri, string alternateCallerId = default, string operationContext = default, CancellationToken cancellationToken = default)
{
using DiagnosticScope scope = _clientDiagnostics.CreateScope($"{nameof(ConversationClient)}.{nameof(AddParticipant)}");
scope.Start();
try
{
Argument.AssertNotNull(participant, nameof(participant));
var participantsInternal = new List <CommunicationIdentifierModel> {
CommunicationIdentifierSerializer.Serialize(participant)
};
var alternateCallerIdInternal = string.IsNullOrEmpty(alternateCallerId) ? null : new PhoneNumberIdentifierModel(alternateCallerId);
return(await RestClient.InviteParticipantsAsync(
conversationId : conversationId,
participants : participantsInternal,
alternateCallerId : alternateCallerIdInternal,
callbackUri : callbackUri?.AbsoluteUri,
operationContext : operationContext,
cancellationToken : cancellationToken
).ConfigureAwait(false));
}
catch (Exception ex)
{
scope.Failed(ex);
throw;
}
}
internal ChatThread(ChatThreadInternal chatThreadInternal)
{
Id = chatThreadInternal.Id;
Topic = chatThreadInternal.Topic;
CreatedOn = chatThreadInternal.CreatedOn;
CreatedBy = CommunicationIdentifierSerializer.Deserialize(chatThreadInternal.CreatedByCommunicationIdentifier);
DeletedOn = chatThreadInternal.DeletedOn;
}
internal ChatMessageContent(ChatMessageContentInternal chatMessageContentInternal)
{
if (chatMessageContentInternal.InitiatorCommunicationIdentifier != null)
{
Initiator = CommunicationIdentifierSerializer.Deserialize(chatMessageContentInternal.InitiatorCommunicationIdentifier);
}
Message = chatMessageContentInternal.Message;
Topic = chatMessageContentInternal.Topic;
Participants = chatMessageContentInternal.Participants.Select(x => new ChatParticipant(x)).ToList().AsReadOnly();
}
/// <summary>
/// Deserialize <see cref="ParticipantsUpdatedEvent"/> event.
/// </summary>
/// <param name="content">The json content.</param>
/// <returns>The new <see cref="ParticipantsUpdatedEvent"/> object.</returns>
public static ParticipantsUpdatedEvent Deserialize(string content)
{
using var document = JsonDocument.Parse(content);
JsonElement element = document.RootElement;
var participantsUpdatedEventInternal = ParticipantsUpdatedEventInternal.DeserializeParticipantsUpdatedEventInternal(element);
return(new ParticipantsUpdatedEvent
{
CallLegId = participantsUpdatedEventInternal.CallLegId,
Participants = participantsUpdatedEventInternal.Participants?.Select(x => new CommunicationParticipant {
Identifier = CommunicationIdentifierSerializer.Deserialize(x.Identifier), IsMuted = x.IsMuted, ParticipantId = x.ParticipantId
})
});
}
internal ChatMessage(ChatMessageInternal chatMessageInternal)
{
Id = chatMessageInternal.Id;
Type = chatMessageInternal.Type;
SequenceId = chatMessageInternal.SequenceId;
Version = chatMessageInternal.Version;
Content = new ChatMessageContent(chatMessageInternal.Content);
SenderDisplayName = chatMessageInternal.SenderDisplayName;
CreatedOn = chatMessageInternal.CreatedOn;
if (chatMessageInternal.SenderCommunicationIdentifier != null)
{
Sender = CommunicationIdentifierSerializer.Deserialize(chatMessageInternal.SenderCommunicationIdentifier);
}
DeletedOn = chatMessageInternal.DeletedOn;
EditedOn = chatMessageInternal.EditedOn;
}
/// <summary> Remove a member from a thread .</summary>
/// <param name="identifier"><see cref="CommunicationIdentifier" /> to be removed from the chat thread participants.</param>
/// <param name="cancellationToken"> The cancellation token to use. </param>
/// <exception cref="RequestFailedException">The server returned an error. See <see cref="Exception.Message"/> for details returned from the server.</exception>
public virtual Response RemoveParticipant(CommunicationIdentifier identifier, CancellationToken cancellationToken = default)
{
using DiagnosticScope scope = _clientDiagnostics.CreateScope($"{nameof(ChatThreadClient)}.{nameof(RemoveParticipant)}");
scope.Start();
try
{
CommunicationIdentifierModel communicationIdentifierModel = CommunicationIdentifierSerializer.Serialize(identifier);
return(_chatThreadRestClient.RemoveChatParticipant(Id, communicationIdentifierModel.RawId,
communicationIdentifierModel.CommunicationUser,
communicationIdentifierModel.PhoneNumber,
communicationIdentifierModel.MicrosoftTeamsUser,
cancellationToken));
}
catch (Exception ex)
{
scope.Failed(ex);
throw;
}
}
public async Task GetParticipantsShouldSucceed()
{
//arrange
ChatThreadClient chatThreadClient = CreateMockChatThreadClient(200, GetParticipantsApiResponsePayload);
//act
AsyncPageable <ChatParticipant> chatParticipants = chatThreadClient.GetParticipantsAsync();
//assert
int idCounter = 0;
await foreach (ChatParticipant chatParticipant in chatParticipants)
{
idCounter++;
Assert.AreEqual($"{idCounter}", CommunicationIdentifierSerializer.Serialize(chatParticipant.User).CommunicationUser.Id);
Assert.AreEqual($"Display Name {idCounter}", chatParticipant.DisplayName);
}
Assert.AreEqual(2, idCounter);
}
/// <summary> Add a participant to the call. </summary>
/// <param name="participant"> The identity of participant to be added to the call. </param>
/// <param name="alternateCallerId">The phone number to use when adding a pstn participant.</param>
/// <param name="operationContext">The operation context. </param>
/// <param name="cancellationToken"> The cancellation token. </param>
/// <exception cref="RequestFailedException">The server returned an error. See <see cref="Exception.Message"/> for details returned from the server.</exception>
/// <exception cref="ArgumentNullException"> <paramref name="participant"/> is null. </exception>
public virtual async Task <Response <AddParticipantResult> > AddParticipantAsync(CommunicationIdentifier participant, string alternateCallerId = default, string operationContext = default, CancellationToken cancellationToken = default)
{
using DiagnosticScope scope = _clientDiagnostics.CreateScope($"{nameof(CallConnection)}.{nameof(AddParticipant)}");
scope.Start();
try
{
Argument.AssertNotNull(participant, nameof(participant));
return(await RestClient.AddParticipantAsync(
callConnectionId : CallConnectionId,
participant : CommunicationIdentifierSerializer.Serialize(participant),
alternateCallerId : alternateCallerId == null?null : new PhoneNumberIdentifierModel(alternateCallerId),
operationContext : operationContext,
callbackUri : null,
cancellationToken : cancellationToken
).ConfigureAwait(false));
}
catch (Exception ex)
{
scope.Failed(ex);
throw;
}
}
/// <summary>
/// Add participant to the call.
/// </summary>
/// <param name="participant"> The identity of participant to be added to the call. </param>
/// <param name="callbackUri">The callback uri to receive the notification.</param>
/// <param name="alternateCallerId">The phone number to use when adding a pstn participant.</param>
/// <param name="operationContext">The operation context.</param>
/// <param name="cancellationToken">The cancellation token.</param>
public virtual Response <AddParticipantResult> AddParticipant(CommunicationIdentifier participant, Uri callbackUri, string alternateCallerId = default, string operationContext = default, CancellationToken cancellationToken = default)
{
using DiagnosticScope scope = _clientDiagnostics.CreateScope($"{nameof(ServerCall)}.{nameof(AddParticipant)}");
scope.Start();
try
{
Argument.AssertNotNull(participant, nameof(participant));
return(RestClient.AddParticipant(
serverCallId: ServerCallId,
participant: CommunicationIdentifierSerializer.Serialize(participant),
alternateCallerId: string.IsNullOrEmpty(alternateCallerId) ? null : new PhoneNumberIdentifierModel(alternateCallerId),
callbackUri: callbackUri?.AbsoluteUri,
operationContext: operationContext,
cancellationToken: cancellationToken
));
}
catch (Exception ex)
{
scope.Failed(ex);
throw;
}
}
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);
}
internal ChatMessageReadReceipt(ChatMessageReadReceiptInternal chatMessageReadReceiptInternal)
{
Sender = CommunicationIdentifierSerializer.Deserialize(chatMessageReadReceiptInternal.SenderCommunicationIdentifier);
ChatMessageId = chatMessageReadReceiptInternal.ChatMessageId;
ReadOn = chatMessageReadReceiptInternal.ReadOn;
}
internal ChatParticipantInternal ToChatParticipantInternal()
{
return(new ChatParticipantInternal(CommunicationIdentifierSerializer.Serialize(User), DisplayName, ShareHistoryTime));
}
internal ChatParticipant(ChatParticipantInternal chatParticipantInternal)
{
User = CommunicationIdentifierSerializer.Deserialize(chatParticipantInternal.CommunicationIdentifier);
DisplayName = chatParticipantInternal.DisplayName;
ShareHistoryTime = chatParticipantInternal.ShareHistoryTime;
}
/// <summary>
/// Deserialize <see cref="ParticipantsUpdatedEvent"/> event.
/// </summary>
/// <param name="content">The json content.</param>
/// <returns>The new <see cref="ParticipantsUpdatedEvent"/> object.</returns>
public static ParticipantsUpdatedEvent Deserialize(string content)
{
using var document = JsonDocument.Parse(content);
JsonElement element = document.RootElement;
var participantsUpdatedEventInternal = ParticipantsUpdatedEventInternal.DeserializeParticipantsUpdatedEventInternal(element);
var callParticipants = participantsUpdatedEventInternal.Participants?.Select(x => new CallParticipant(identifier: CommunicationIdentifierSerializer.Deserialize(x.Identifier), isMuted: x.IsMuted, participantId: x.ParticipantId));
return(new ParticipantsUpdatedEvent(participantsUpdatedEventInternal.CallConnectionId, callParticipants));
}
public async Task CreateChatThreadShouldExposePartialErrors()
{
//arrange
ChatClient chatClient = CreateMockChatClient(201, CreateChatThreadWithErrorsApiResponsePayload);
var chatParticipant = new ChatParticipant(new CommunicationUserIdentifier("8:acs:46849534-eb08-4ab7-bde7-c36928cd1547_00000007-165c-9b10-b0b7-3a3a0d00076c"));
//act
CreateChatThreadResult createChatThreadResult = await chatClient.CreateChatThreadAsync("", new List <ChatParticipant>() { chatParticipant });
//assert
AsssertParticipantError(createChatThreadResult.InvalidParticipants.First(x => x.Code == "401"), "Authentication failed", "8:acs:1b5cc06b-f352-4571-b1e6-d9b259b7c776_00000007-1234-1234-1234-223a12345678");
AsssertParticipantError(createChatThreadResult.InvalidParticipants.First(x => x.Code == "403"), "Permissions check failed", "8:acs:1b5cc06b-f352-4571-b1e6-d9b259b7c776_00000007-1234-1234-1234-223a12345679");
AsssertParticipantError(createChatThreadResult.InvalidParticipants.First(x => x.Code == "404"), "Not found", "8:acs:1b5cc06b-f352-4571-b1e6-d9b259b7c776_00000007-1234-1234-1234-223a12345677");
Assert.AreEqual(3, createChatThreadResult.InvalidParticipants.Count);
Assert.AreEqual("8:acs:46849534-eb08-4ab7-bde7-c36928cd1547_00000007-165c-9b10-b0b7-3a3a0d00076c", CommunicationIdentifierSerializer.Serialize(createChatThreadResult.ChatThread.CreatedBy).RawId);
Assert.AreEqual("Topic for testing errors", createChatThreadResult.ChatThread.Topic);
Assert.AreEqual("19:[email protected]", createChatThreadResult.ChatThread.Id);
}
public async Task GetThreadShouldSucceed()
{
//arrange
var threadId = "19:[email protected]";
ChatThreadClient chatThreadClient = CreateMockChatThreadClient(200, GetThreadApiResponsePayload);
//act
ChatThreadProperties chatThread = await chatThreadClient.GetPropertiesAsync();
//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 async Task CreateChatThreadShouldSucceed()
{
//act
var chatClient = CreateMockChatClient(201, CreateChatThreadSuccessApiResponsePayload);
var chatParticipant = new ChatParticipant(new CommunicationUserIdentifier("8:acs:46849534-eb08-4ab7-bde7-c36928cd1547_00000007-165c-9b10-b0b7-3a3a0d00076c"));
CreateChatThreadResult createChatThreadResult = await chatClient.CreateChatThreadAsync("", new List <ChatParticipant>() { chatParticipant });
//assert
Assert.AreEqual("8:acs:46849534-eb08-4ab7-bde7-c36928cd1547_00000007-165c-9b10-b0b7-3a3a0d00076c", CommunicationIdentifierSerializer.Serialize(createChatThreadResult.ChatThread.CreatedBy).CommunicationUser.Id);
Assert.AreEqual("Topic for testing success", createChatThreadResult.ChatThread.Topic);
Assert.AreEqual("19:[email protected]", createChatThreadResult.ChatThread.Id);
}