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)); }