public async Task <ActionResult> TryAddUserToThread(string threadId, [FromBody] ContosoMemberModel user)
{
try
{
var moderator = _store.Store[threadId];
var userCredential = new CommunicationUserCredential(moderator.token);
ChatClient chatClient = new ChatClient(new Uri(_chatGatewayUrl), userCredential);
ChatThread chatThread = chatClient.GetChatThread(threadId);
ChatThreadClient chatThreadClient = chatClient.GetChatThreadClient(threadId);
var chatThreadMember = new ChatThreadMember(new CommunicationUser(user.Id));
chatThreadMember.DisplayName = user.DisplayName;
chatThreadMember.ShareHistoryTime = chatThread.CreatedOn;
List <ChatThreadMember> chatThreadMembers = new List <ChatThreadMember>
{
chatThreadMember
};
try
{
var response = await chatThreadClient.AddMembersAsync(chatThreadMembers);
return(StatusCode(response.Status));
}
catch (RequestFailedException e)
{
Console.WriteLine($"Unexpected error occurred while adding user from thread: {e}");
return(StatusCode(e.Status));
}
}
catch (Exception e)
{
Console.WriteLine($"Unexpected error occurred while adding user from thread: {e}");
}
return(Ok());
}
/// <summary>
/// SendMessageToChatThreadAsync() - send a new message to an existing chat thread
/// </summary>
/// <returns></returns>
private static async Task SendMessageToChatThreadAsync()
{
Console.WriteLine("\n# Sending a new message to a thread");
Console.Write("Enter thread id: ");
var threadId = Console.ReadLine();
Console.Write("Enter message: ");
var message = Console.ReadLine();
Uri endpoint = new Uri("https://ACS-INSTANCE.communication.azure.com/");
CommunicationUserCredential communicationUserCredential = new CommunicationUserCredential(token);
ChatClient chatClient = new ChatClient(endpoint, communicationUserCredential);
ChatThreadClient chatThreadClient = chatClient.GetChatThreadClient(threadId);
var priority = ChatMessagePriority.Normal;
SendChatMessageResult sendChatMessageResult = await chatThreadClient.SendMessageAsync(message, priority, displayname);
string messageId = sendChatMessageResult.Id;
Console.WriteLine($"Message sent: { messageId}");
}
/// <summary>
/// AddUserToChatThread() - add a new member to an existing chat thread
/// </summary>
/// <returns></returns>
private static async Task AddUserToChatThread()
{
Console.WriteLine("# Adding a user to a chat thread");
Console.Write("Enter thread id: ");
var threadId = Console.ReadLine();
Console.Write("Enter user id: ");
var userToAdd = Console.ReadLine();
Console.Write("Enter display name: ");
var userDisplayname = Console.ReadLine();
Uri endpoint = new Uri("https://ACS-INSTANCE.communication.azure.com/");
CommunicationUserCredential communicationUserCredential = new CommunicationUserCredential(token);
ChatClient chatClient = new ChatClient(endpoint, communicationUserCredential);
var chatThreadMember = new ChatThreadMember(new CommunicationUser(userToAdd))
{
DisplayName = userDisplayname
};
ChatThreadClient chatThreadClient = chatClient.GetChatThreadClient(threadId);
await chatThreadClient.AddMembersAsync(members : new[] { chatThreadMember });
Console.WriteLine($"User {userDisplayname} added to thread");
}
/// <summary>Initializes a new instance of <see cref="ChatClient"/> for mocking.</summary>
protected ChatClient()
{
_clientDiagnostics = null !;
_chatRestClient = null !;
_endpointUrl = null !;
_communicationUserCredential = null !;
_chatClientOptions = null !;
}
public async Task CommunicationTokenCredential_StaticTokenAsyncReturnsExpiredToken()
{
var userCredential = new CommunicationUserCredential(ExpiredToken);
var communicationTokenCredential = new CommunicationTokenCredential(userCredential);
var accessToken = await communicationTokenCredential.GetTokenAsync(MockTokenRequestContext(), CancellationToken.None);
Assert.AreEqual(ExpiredToken, accessToken.Token);
}
public async Task CommunicationTokenCredential_CreateStaticToken()
{
var token = ExpiredToken;
using var userCredential = new CommunicationUserCredential(token);
var communicationTokenCredential = new CommunicationTokenCredential(userCredential);
await communicationTokenCredential.GetTokenAsync(MockTokenRequestContext(), CancellationToken.None);
}
public ThreadService(IServiceProvider serviceProvider)
: base(serviceProvider)
{
Utils.IsNotNull(serviceProvider, nameof(serviceProvider));
CommunicationUserCredential adminThreadCredential = new CommunicationUserCredential(UserService.ChatBotUser.CommunicationUserToken.Token);
Client = new ChatClient(AccessTokens.UriEndpoint, adminThreadCredential);
UserStore = (Store <User>)serviceProvider.GetService(typeof(Store <User>));
}
public async Task CommunicationTokenCredential_CreateRefreshableWithoutInitialToken()
{
var userCredential = new CommunicationUserCredential(
refreshProactively: true, // Indicates if the token should be proactively refreshed in the background or only on-demand
tokenRefresher: cancellationToken => FetchTokenForUserFromMyServer("*****@*****.**", cancellationToken),
asyncTokenRefresher: cancellationToken => FetchTokenForUserFromMyServerAsync("*****@*****.**", cancellationToken));
var communicationTokenCredential = new CommunicationTokenCredential(userCredential);
await communicationTokenCredential.GetTokenAsync(MockTokenRequestContext(), CancellationToken.None);
}
public async Task CommunicationTokenCredential_DecodesToken()
{
var initialToken = SampleToken;
var userCredential = new CommunicationUserCredential(initialToken);
var communicationTokenCredential = new CommunicationTokenCredential(userCredential);
var accessToken = await communicationTokenCredential.GetTokenAsync(MockTokenRequestContext(), CancellationToken.None);
Assert.AreEqual(initialToken, accessToken.Token);
Assert.AreEqual(SampleTokenExpiry, accessToken.ExpiresOn.ToUnixTimeSeconds());
}
/// <summary> Initializes a new instance of <see cref="ChatClient"/>.</summary>
/// <param name="endpointUrl">The uri for the Azure Communication Services Chat.</param>
/// <param name="communicationUserCredential">Instance of <see cref="CommunicationUserCredential"/>.</param>
/// <param name="options">Chat client options exposing <see cref="ClientOptions.Diagnostics"/>, <see cref="ClientOptions.Retry"/>, <see cref="ClientOptions.Transport"/>, etc.</param>
public ChatClient(Uri endpointUrl, CommunicationUserCredential communicationUserCredential, ChatClientOptions?options = default)
{
Argument.AssertNotNull(communicationUserCredential, nameof(communicationUserCredential));
Argument.AssertNotNull(endpointUrl, nameof(endpointUrl));
_chatClientOptions = options ?? new ChatClientOptions();
_communicationUserCredential = communicationUserCredential;
_endpointUrl = endpointUrl;
_clientDiagnostics = new ClientDiagnostics(_chatClientOptions);
HttpPipeline pipeline = CreatePipelineFromOptions(_chatClientOptions, communicationUserCredential);
_chatRestClient = new ChatRestClient(_clientDiagnostics, pipeline, endpointUrl.AbsoluteUri, _chatClientOptions.ApiVersion);
}
/// <summary>
/// Creates a <see cref="ChatClient" /> with a static token and instruments it to make use of
/// the Azure Core Test Framework functionalities.
/// </summary>
/// <returns>The instrumented <see cref="ChatClient" />.</returns>
protected ChatClient CreateInstrumentedChatClient(string token)
{
if (Mode == RecordedTestMode.Playback)
{
token = ChatRecordedTestSanitizer.SanitizedChatAuthHeaderValue;
}
CommunicationUserCredential communicationUserCredential = new CommunicationUserCredential(token);
return(InstrumentClient(new ChatClient(new Uri(TestEnvironment.ChatApiUrl()), communicationUserCredential,
InstrumentClientOptions(new ChatClientOptions()))));
}
/// <summary> Initializes a new instance of <see cref="ChatThreadClient"/>.</summary>
/// <param name="threadId"></param>
/// <param name="endpointUrl">The uri for the Azure Communication Services Chat.</param>
/// <param name="communicationUserCredential">Instance of <see cref="CommunicationUserCredential"/>.</param>
/// <param name="options">Chat client options exposing <see cref="ClientOptions.Diagnostics"/>, <see cref="ClientOptions.Retry"/>, <see cref="ClientOptions.Transport"/>, etc.</param>
/// <exception cref="ArgumentNullException"> This occurs when one of the required arguments is null. </exception>
internal ChatThreadClient(string threadId, Uri endpointUrl, CommunicationUserCredential communicationUserCredential, ChatClientOptions?options = default)
{
Argument.AssertNotNull(threadId, nameof(threadId));
Argument.AssertNotNull(communicationUserCredential, nameof(communicationUserCredential));
Argument.AssertNotNull(endpointUrl, nameof(endpointUrl));
options ??= new ChatClientOptions();
Id = threadId;
_clientDiagnostics = new ClientDiagnostics(options);
HttpPipeline pipeline = CreatePipelineFromOptions(options, communicationUserCredential);
_chatRestClient = new ChatRestClient(_clientDiagnostics, pipeline, endpointUrl.AbsoluteUri, options.ApiVersion);
}
private async Task <string> InternalGenerateNewModeratorAndThread()
{
var moderator = await InternalGenerateAdhocUser();
var userCredential = new CommunicationUserCredential(moderator.token);
ChatClient chatClient = new ChatClient(new Uri(_chatGatewayUrl), userCredential);
List <ChatThreadMember> chatThreadMembers = new List <ChatThreadMember>
{
new ChatThreadMember(new CommunicationUser(moderator.identity))
};
ChatThreadClient chatThreadClient = await chatClient.CreateChatThreadAsync(GUID_FOR_INITIAL_TOPIC_NAME, chatThreadMembers);
_store.Store.Add(chatThreadClient.Id, moderator);
return(chatThreadClient.Id);
}
public async Task OrderInGetMessagesIteratorIsNotAlteredByPaging()
{
//arrange
var threadId = "19:[email protected]";
var uri = new Uri("https://localHostTest");
var responseItemsPage1 = new MockResponse(200);
responseItemsPage1.SetContent(_page1MessagesApiResponsePayload);
var responseItemsPage2 = new MockResponse(200);
responseItemsPage2.SetContent(_page2MessagesApiResponsePayload);
var chatClientOptions = new ChatClientOptions
{
Transport = new MockTransport(responseItemsPage1, responseItemsPage2)
};
//act
var communicationUserCredential = new CommunicationUserCredential(ChatRecordedTestSanitizer.SanitizedUnsignedUserTokenValue);
var chatThreadClient = new ChatThreadClient(threadId, uri, communicationUserCredential, chatClientOptions);
AsyncPageable <ChatMessage> allMessages = chatThreadClient.GetMessagesAsync();
//assert
int pages = 0;
int idCounter = 0;
int textMessagesCounter = 0;
await foreach (Page <ChatMessage> page in allMessages.AsPages(pageSizeHint: 4))
{
pages++;
foreach (ChatMessage message in page.Values)
{
idCounter++;
Assert.AreEqual($"{idCounter}", message.Id);
Assert.AreEqual($"{idCounter}", message.Version);
if (message.Type == "Text")
{
textMessagesCounter++;
Assert.AreEqual($"Content for async message {idCounter}", message.Content);
}
}
}
Assert.AreEqual(2, pages);
Assert.AreEqual(8, idCounter);
Assert.AreEqual(5, textMessagesCounter);
}
/// <summary>
/// ViewAllThreads() - see all chat threads provisioned
/// </summary>
/// <returns></returns>
private static void ViewAllThreads()
{
Console.WriteLine("\n# Viewing all threads");
Uri endpoint = new Uri("https://ACS-INSTANCE.communication.azure.com/");
CommunicationUserCredential communicationUserCredential = new CommunicationUserCredential(token);
ChatClient chatClient = new ChatClient(endpoint, communicationUserCredential);
var offset = DateTime.Now.AddDays(-5);
Pageable <ChatThreadInfo> allThreads = chatClient.GetChatThreadsInfo(offset);
foreach (ChatThreadInfo thread in allThreads)
{
Console.WriteLine($"{thread.Id}: {thread.Topic}");
}
}
/// <summary>
/// ViewMembersInAThread() - view existing members in a chat thread
/// </summary>
/// <returns></returns>
private static async Task ViewMembersInAThread()
{
Console.WriteLine("\n# Viewing members in a thread");
Console.Write("Enter thread id: ");
var threadId = Console.ReadLine();
Uri endpoint = new Uri("https://ACS-INSTANCE.communication.azure.com/");
CommunicationUserCredential communicationUserCredential = new CommunicationUserCredential(token);
ChatClient chatClient = new ChatClient(endpoint, communicationUserCredential);
ChatThreadClient chatThreadClient = chatClient.GetChatThreadClient(threadId);
AsyncPageable <ChatThreadMember> allMembers = chatThreadClient.GetMembersAsync();
await foreach (ChatThreadMember member in allMembers)
{
Console.WriteLine($"{member.DisplayName}");
}
}
public async Task CommunicationTokenCredential_PassesAsyncCancelToken(bool refreshProactively)
{
var cancellationToken = new CancellationToken();
CancellationToken?actualCancellationToken = null;
var userCredential = new CommunicationUserCredential(
refreshProactively,
RefreshToken,
c => new ValueTask <string>(RefreshToken(c)),
ExpiredToken);
var communicationTokenCredential = new CommunicationTokenCredential(userCredential);
var accessToken = await communicationTokenCredential.GetTokenAsync(MockTokenRequestContext(), cancellationToken);
Assert.AreEqual(cancellationToken.GetHashCode(), actualCancellationToken.GetHashCode());
string RefreshToken(CancellationToken token)
{
actualCancellationToken = token;
return(SampleToken);
}
}
/// <summary>
/// CreateNewChatThread() - provision a new chat thread (like a channel or a group chat)
/// </summary>
/// <returns></returns>
private static async Task <string> CreateNewChatThread()
{
Console.WriteLine("\n# Creating a new chat thread");
Console.WriteLine("Enter thread topic: ");
var topic = Console.ReadLine();
Uri endpoint = new Uri("https://ACS-INSTANCE.communication.azure.com/");
CommunicationUserCredential communicationUserCredential = new CommunicationUserCredential(token);
ChatClient chatClient = new ChatClient(endpoint, communicationUserCredential);
var chatThreadMember = new ChatThreadMember(new CommunicationUser(userid))
{
DisplayName = displayname
};
ChatThreadClient chatThreadClient = await chatClient.CreateChatThreadAsync(topic : topic, members : new[] { chatThreadMember });
Console.WriteLine($"Chat thread ID: {chatThreadClient.Id}");
return(chatThreadClient.Id);
}
private static HttpPipeline CreatePipelineFromOptions(ChatClientOptions options, CommunicationUserCredential communicationUserCredential)
{
var httpPipelinePolicy = new CommunicationUserAuthenticationPolicy(communicationUserCredential);
HttpPipeline httpPipeline = HttpPipelineBuilder.Build(options, httpPipelinePolicy);
return(httpPipeline);
}
public CommunicationUserAuthenticationPolicy(CommunicationUserCredential communicationUserCredential)
{
_communicationUserCredential = communicationUserCredential;
}
public CommunicationTokenCredential(CommunicationUserCredential credential) => _credential = credential;
private static HttpPipeline CreatePipelineFromOptions(ChatClientOptions options, CommunicationUserCredential communicationUserCredential)
{
var tokenCredential = new CommunicationTokenCredential(communicationUserCredential);
var authenticationPolicy = new BearerTokenAuthenticationPolicy(tokenCredential, "");
return(HttpPipelineBuilder.Build(options, authenticationPolicy));
}
