def remove_participant(self): thread_id = self._thread_id chat_client = self._chat_client identity_client = self.identity_client from azure.communication.chat import ChatParticipant, CommunicationUserIdentifier from datetime import datetime # create 2 new users using CommunicationIdentityClient.create_user method user1 = identity_client.create_user() user2 = identity_client.create_user() # set `thread_id` to an existing thread id chat_thread_client = chat_client.get_chat_thread_client( thread_id=thread_id) # add user1 and user2 to chat thread participant1 = ChatParticipant(identifier=user1, display_name='Fred Flinstone', share_history_time=datetime.utcnow()) participant2 = ChatParticipant(identifier=user2, display_name='Wilma Flinstone', share_history_time=datetime.utcnow()) thread_participants = [participant1, participant2] chat_thread_client.add_participants(thread_participants) # [START remove_participant] # Option 1 : Iterate through all participants, find and delete Fred Flinstone chat_thread_participants = chat_thread_client.list_participants() for chat_thread_participant_page in chat_thread_participants.by_page(): for chat_thread_participant in chat_thread_participant_page: print("ChatParticipant: ", chat_thread_participant) if chat_thread_participant.identifier.properties[ 'id'] == user1.properties['id']: print("Found Fred!") chat_thread_client.remove_participant( chat_thread_participant.identifier) print("Fred has been removed from the thread...") break # Option 2: Directly remove Wilma Flinstone unique_identifier = user2.properties[ 'id'] # in real scenario the identifier would need to be retrieved from elsewhere chat_thread_client.remove_participant( CommunicationUserIdentifier(unique_identifier)) print("Wilma has been removed from the thread...") # [END remove_participant] # clean up temporary users self.identity_client.delete_user(user1) self.identity_client.delete_user(user2) print("remove_chat_participant succeeded")
async def test_create_chat_thread_raises_error(): async def mock_send(*_, **__): return mock_response(status_code=400, json_payload={"msg": "some error"}) chat_client = ChatClient("https://endpoint", credential, transport=Mock(send=mock_send)) topic = "test topic", user = CommunicationUserIdentifier( "8:acs:57b9bac9-df6c-4d39-a73b-26e944adf6ea_9b0110-08007f1041") participants = [ ChatParticipant(identifier=user, display_name='name', share_history_time=datetime.utcnow()) ] raised = False try: await chat_client.create_chat_thread(topic=topic, thread_participants=participants) except: raised = True assert raised == True
async def add_participants_w_check_async(self): thread_id = self._thread_id chat_client = self._chat_client user = self.new_user # [START add_participants] def decide_to_retry(error): """ Custom logic to decide whether to retry to add or not """ return True async with chat_client: # set `thread_id` to an existing thread id chat_thread_client = chat_client.get_chat_thread_client( thread_id=thread_id) async with chat_thread_client: from azure.communication.chat import ChatParticipant from datetime import datetime new_participant = ChatParticipant( identifier=self.new_user, display_name='name', share_history_time=datetime.utcnow()) thread_participants = [new_participant] result = await chat_thread_client.add_participants( thread_participants) # list of participants which were unsuccessful to be added to chat thread retry = [p for p, e in result if decide_to_retry(e)] if retry: await chat_thread_client.add_participants(retry) # [END add_participants] print("add_participants_w_check_async succeeded")
def test_list_participants(self): self._create_thread() # add another participant share_history_time = datetime.utcnow() share_history_time = share_history_time.replace(tzinfo=TZ_UTC) new_participant = ChatParticipant( identifier=self.new_user, display_name='name', share_history_time=share_history_time) self.chat_thread_client.add_participants([new_participant]) # fetch list of participants chat_thread_participants = self.chat_thread_client.list_participants( results_per_page=1, skip=1) participant_count = 0 for chat_thread_participant_page in chat_thread_participants.by_page(): li = list(chat_thread_participant_page) assert len(li) <= 1 participant_count += len(li) li[0].identifier.properties['id'] = self.user.properties['id'] assert participant_count == 1
async def create_chat_thread_client_async(self): token = self.token endpoint = self.endpoint user = self.user # [START create_chat_thread_client] from datetime import datetime from azure.communication.chat.aio import ChatClient, CommunicationTokenCredential from azure.communication.chat import ChatParticipant, CommunicationUserIdentifier # set `endpoint` to an existing ACS endpoint chat_client = ChatClient(endpoint, CommunicationTokenCredential(token)) async with chat_client: topic = "test topic" participants = [ ChatParticipant(identifier=user, display_name='name', share_history_time=datetime.utcnow()) ] create_chat_thread_result = await chat_client.create_chat_thread( topic, thread_participants=participants) chat_thread_client = chat_client.get_chat_thread_client( create_chat_thread_result.chat_thread.id) # [END create_chat_thread_client] self._thread_id = create_chat_thread_result.chat_thread.id print("thread created, id: " + self._thread_id) print("create_chat_thread_client_async succeeded")
def create_chat_thread_client(self): token = self.token endpoint = self.endpoint user = self.user # [START create_chat_thread_client] from datetime import datetime from azure.communication.chat import (ChatClient, ChatParticipant, CommunicationUserIdentifier, CommunicationTokenCredential) # retrieve `token` using CommunicationIdentityClient.get_token method # set `endpoint` to ACS service endpoint # create `user` using CommunicationIdentityClient.create_user method for new users; # else for existing users set `user` = CommunicationUserIdentifier(some_user_id) chat_client = ChatClient(endpoint, CommunicationTokenCredential(token)) topic = "test topic" participants = [ ChatParticipant(identifier=user, display_name='name', share_history_time=datetime.utcnow()) ] create_chat_thread_result = chat_client.create_chat_thread( topic, thread_participants=participants) chat_thread_client = chat_client.get_chat_thread_client( create_chat_thread_result.chat_thread.id) # [END create_chat_thread_client] self._thread_id = create_chat_thread_result.chat_thread.id print("chat_thread_client created")
async def create_thread_async(self): token = self.token endpoint = self.endpoint thread_id = self._thread_id # [START create_thread] from datetime import datetime from azure.communication.chat.aio import ChatClient, CommunicationTokenCredential from azure.communication.chat import ChatParticipant # set `endpoint` to an existing ACS endpoint chat_client = ChatClient(endpoint, CommunicationTokenCredential(token)) async with chat_client: topic = "test topic" participants = [ChatParticipant( identifier=self.user, display_name='name', share_history_time=datetime.utcnow() )] # creates a new chat_thread everytime create_chat_thread_result = await chat_client.create_chat_thread(topic, thread_participants=participants) # creates a new chat_thread if not exists idempotency_token = 'b66d6031-fdcc-41df-8306-e524c9f226b8' # unique identifier create_chat_thread_result_w_repeatability_id = await chat_client.create_chat_thread( topic, thread_participants=participants, idempotency_token=idempotency_token) # [END create_thread] self._thread_id = create_chat_thread_result.chat_thread.id print("thread created, id: " + self._thread_id)
async def test_list_participants(self): async with self.chat_client: await self._create_thread() async with self.chat_thread_client: # add another participant share_history_time = datetime.utcnow() share_history_time = share_history_time.replace(tzinfo=TZ_UTC) new_participant = ChatParticipant( identifier=self.new_user, display_name='name', share_history_time=share_history_time) await self.chat_thread_client.add_participants( [new_participant]) chat_thread_participants = self.chat_thread_client.list_participants( results_per_page=1, skip=1) items = [] async for item in chat_thread_participants: items.append(item) assert len(items) == 1 # delete chat threads if not self.is_playback(): await self.chat_client.delete_chat_thread(self.thread_id)
async def test_create_chat_thread(): thread_id = "19:[email protected]" async def mock_send(*_, **__): return mock_response( status_code=201, json_payload={ "chatThread": { "id": thread_id, "topic": "test topic", "createdOn": "2020-12-03T21:09:17Z", "createdBy": "8:acs:57b9bac9-df6c-4d39-a73b-26e944adf6ea_9b0110-08007f1041" } }) chat_client = ChatClient("https://endpoint", credential, transport=Mock(send=mock_send)) topic = "test topic" user = CommunicationUserIdentifier( "8:acs:57b9bac9-df6c-4d39-a73b-26e944adf6ea_9b0110-08007f1041") participants = [ ChatParticipant(identifier=user, display_name='name', share_history_time=datetime.utcnow()) ] create_chat_thread_result = await chat_client.create_chat_thread( topic, thread_participants=participants) assert create_chat_thread_result.chat_thread.id == thread_id
def test_add_participants(self): thread_id = "19:[email protected]" new_participant_id = "8:acs:57b9bac9-df6c-4d39-a73b-26e944adf6ea_9b0110-08007f1041" raised = False def mock_send(*_, **__): return mock_response(status_code=201) chat_thread_client = ChatThreadClient("https://endpoint", TestChatThreadClient.credential, thread_id, transport=Mock(send=mock_send)) new_participant = ChatParticipant( identifier=CommunicationUserIdentifier(new_participant_id), display_name='name', share_history_time=datetime.utcnow()) participants = [new_participant] try: result = chat_thread_client.add_participants(participants) except: raised = True self.assertFalse(raised, 'Expected is no excpetion raised') self.assertTrue(len(result) == 0)
async def _create_thread_w_two_users(self): # create chat thread topic = "test topic" share_history_time = datetime.utcnow() share_history_time = share_history_time.replace(tzinfo=TZ_UTC) participants = [ ChatParticipant(identifier=self.user, display_name='name', share_history_time=share_history_time), ChatParticipant(identifier=self.new_user, display_name='name', share_history_time=share_history_time) ] create_chat_thread_result = await self.chat_client.create_chat_thread( topic, thread_participants=participants) self.chat_thread_client = self.chat_client.get_chat_thread_client( create_chat_thread_result.chat_thread.id) self.thread_id = self.chat_thread_client.thread_id
def _create_thread(self, idempotency_token=None): # create chat thread topic = "test topic" share_history_time = datetime.utcnow() share_history_time = share_history_time.replace(tzinfo=TZ_UTC) participants = [ChatParticipant( identifier=self.user, display_name='name', share_history_time=share_history_time )] create_chat_thread_result = self.chat_client.create_chat_thread(topic, thread_participants=participants, idempotency_token=idempotency_token) self.thread_id = create_chat_thread_result.chat_thread.id
def test_add_participants(self): self._create_thread() share_history_time = datetime.utcnow() share_history_time = share_history_time.replace(tzinfo=TZ_UTC) new_participant = ChatParticipant( identifier=self.new_user, display_name='name', share_history_time=share_history_time) participants = [new_participant] failed_participants = self.chat_thread_client.add_participants(participants) # no error occured while adding participants assert len(failed_participants) == 0
def _create_thread(self, **kwargs): # create chat thread, and ChatThreadClient topic = "test topic" share_history_time = datetime.utcnow() share_history_time = share_history_time.replace(tzinfo=TZ_UTC) participants = [ ChatParticipant(identifier=self.user, display_name='name', share_history_time=share_history_time) ] create_chat_thread_result = self.chat_client.create_chat_thread( topic, thread_participants=participants) self.chat_thread_client = self.chat_client.get_chat_thread_client( create_chat_thread_result.chat_thread.id) self.thread_id = self.chat_thread_client.thread_id
def communication_chat_add_participant(client, thread_id, user_id, display_name=None, start_time=None): from azure.communication.chat import ChatParticipant from azure.communication.identity import CommunicationUserIdentifier chat_thread_client = client.get_chat_thread_client(thread_id) participant = ChatParticipant( identifier=CommunicationUserIdentifier(user_id), display_name=display_name, share_history_time=start_time) res = chat_thread_client.add_participants([participant]) return [r[1] for r in res]
def test_remove_participant(self): self._create_thread() # add participant first share_history_time = datetime.utcnow() share_history_time = share_history_time.replace(tzinfo=TZ_UTC) new_participant = ChatParticipant( identifier=self.new_user, display_name='name', share_history_time=share_history_time) participants = [new_participant] self.chat_thread_client.add_participants(participants) # test remove participant self.chat_thread_client.remove_participant(self.new_user)
def test_add_participants_w_failed_participants_returns_nonempty_list( self): thread_id = "19:[email protected]" new_participant_id = "8:acs:57b9bac9-df6c-4d39-a73b-26e944adf6ea_9b0110-08007f1041" raised = False error_message = "some error message" def mock_send(*_, **__): return mock_response(status_code=201, json_payload={ "invalidParticipants": [{ "code": "string", "message": error_message, "target": new_participant_id, "details": [] }] }) chat_thread_client = ChatThreadClient("https://endpoint", TestChatThreadClient.credential, thread_id, transport=Mock(send=mock_send)) new_participant = ChatParticipant( identifier=CommunicationUserIdentifier(new_participant_id), display_name='name', share_history_time=datetime.utcnow()) participants = [new_participant] try: result = chat_thread_client.add_participants(participants) except: raised = True self.assertFalse(raised, 'Expected is no excpetion raised') self.assertTrue(len(result) == 1) failed_participant = result[0][0] communication_error = result[0][1] self.assertEqual(new_participant.identifier.properties['id'], failed_participant.identifier.properties['id']) self.assertEqual(new_participant.display_name, failed_participant.display_name) self.assertEqual(new_participant.share_history_time, failed_participant.share_history_time) self.assertEqual(error_message, communication_error.message)
def test_create_chat_thread_w_repeatability_request_id(self): thread_id = "19:[email protected]" chat_thread_client = None raised = False idempotency_token = "b66d6031-fdcc-41df-8306-e524c9f226b8" def mock_send(*_, **__): return mock_response( status_code=201, json_payload={ "chatThread": { "id": thread_id, "topic": "test topic", "createdOn": "2020-12-03T21:09:17Z", "createdBy": "8:acs:57b9bac9-df6c-4d39-a73b-26e944adf6ea_9b0110-08007f1041" } }) chat_client = ChatClient("https://endpoint", TestChatClient.credential, transport=Mock(send=mock_send)) topic = "test topic" user = CommunicationUserIdentifier( "8:acs:57b9bac9-df6c-4d39-a73b-26e944adf6ea_9b0110-08007f1041") participants = [ ChatParticipant(identifier=user, display_name='name', share_history_time=datetime.utcnow()) ] try: create_chat_thread_result = chat_client.create_chat_thread( topic=topic, thread_participants=participants, idempotency_token=idempotency_token) except: raised = True raise self.assertFalse(raised, 'Expected is no excpetion raised') assert create_chat_thread_result.chat_thread.id == thread_id
async def test_add_participants(self): async with self.chat_client: await self._create_thread() async with self.chat_thread_client: share_history_time = datetime.utcnow() share_history_time = share_history_time.replace(tzinfo=TZ_UTC) new_participant = ChatParticipant( identifier=self.new_user, display_name='name', share_history_time=share_history_time) participants = [new_participant] failed_participants = await self.chat_thread_client.add_participants(participants) # no error occured while adding participants assert len(failed_participants) == 0 if not self.is_playback(): await self.chat_client.delete_chat_thread(self.thread_id)
async def test_remove_participant(self): async with self.chat_client: await self._create_thread() async with self.chat_thread_client: # add participant first share_history_time = datetime.utcnow() share_history_time = share_history_time.replace(tzinfo=TZ_UTC) new_participant = ChatParticipant( identifier=self.new_user, display_name='name', share_history_time=share_history_time) participants = [new_participant] await self.chat_thread_client.add_participants(participants) # test remove participant await self.chat_thread_client.remove_participant(self.new_user) if not self.is_playback(): await self.chat_client.delete_chat_thread(self.thread_id)
def add_participants_w_check(self): # initially remove already added user thread_id = self._thread_id chat_client = self._chat_client user = self.new_user chat_thread_client = chat_client.get_chat_thread_client( thread_id=thread_id) chat_thread_client.remove_participant(user) # [START add_participants] from azure.communication.chat import ChatParticipant from datetime import datetime def decide_to_retry(error): """ Custom logic to decide whether to retry to add or not """ return True # set `thread_id` to an existing thread id chat_thread_client = chat_client.get_chat_thread_client( thread_id=thread_id) # create `user` using CommunicationIdentityClient.create_user method for new users; # else for existing users set `user` = CommunicationUserIdentifier(some_user_id) new_participant = ChatParticipant(identifier=user, display_name='name', share_history_time=datetime.utcnow()) # create list containing one or more participants thread_participants = [new_participant] result = chat_thread_client.add_participants(thread_participants) # list of participants which were unsuccessful to be added to chat thread retry = [p for p, e in result if decide_to_retry(e)] if retry: chat_thread_client.add_participants(retry) # [END add_participants] print("add_participants_w_check succeeded")
def test_create_chat_thread_raises_error(self): def mock_send(*_, **__): return mock_response(status_code=400, json_payload={"msg": "some error"}) chat_client = ChatClient("https://endpoint", TestChatClient.credential, transport=Mock(send=mock_send)) topic = "test topic", user = CommunicationUserIdentifier( "8:acs:57b9bac9-df6c-4d39-a73b-26e944adf6ea_9b0110-08007f1041") thread_participants = [ ChatParticipant(identifier=user, display_name='name', share_history_time=datetime.utcnow()) ] self.assertRaises(HttpResponseError, chat_client.create_chat_thread, topic=topic, thread_participants=thread_participants)
# # conversely, you can also add an existing user to a chat thread; provided the user_id is known # from azure.communication.identity import CommunicationUserIdentifier # # user_id = 'some user id' # user_display_name = "Wilma Flinstone" # new_user = CommunicationUserIdentifier(user_id) # participant = ChatParticipant( # user=new_user, # display_name=user_display_name, # share_history_time=datetime.utcnow()) participants = [] for _user in new_users: chat_thread_participant = ChatParticipant( identifier=_user, display_name='Fred Flinstone', share_history_time=datetime.utcnow()) participants.append(chat_thread_participant) response = chat_thread_client.add_participants(participants) def decide_to_retry(error, **kwargs): """ Insert some custom logic to decide if retry is applicable based on error """ return True # verify if all users has been successfully added or not # in case of partial failures, you can retry to add all the failed participants retry = [p for p, e in response if decide_to_retry(e)] if retry: