def setUp(self): super(ChatThreadClientTestAsync, self).setUp() self.recording_processors.extend([ BodyReplacerProcessor(keys=["id", "token", "senderId", "chatMessageId", "nextLink", "participants", "multipleStatus", "value"]), URIIdentityReplacer(), ResponseReplacerProcessor(keys=[self._resource_name]), ChatURIReplacer()]) endpoint, _ = parse_connection_str(self.connection_str) self.endpoint = endpoint self.identity_client = CommunicationIdentityClient.from_connection_string(self.connection_str) self.users = [] self.user_tokens = [] self.chat_clients = [] # create user 1 self.user = self.identity_client.create_user() token_response = self.identity_client.get_token(self.user, scopes=["chat"]) self.token = token_response.token # create user 2 self.new_user = self.identity_client.create_user() token_response = self.identity_client.get_token(self.new_user, scopes=["chat"]) self.token_new_user = token_response.token # create ChatClient refresh_option = CommunicationTokenRefreshOptions(self.token) refresh_option_new_user = CommunicationTokenRefreshOptions(self.token_new_user) self.chat_client = ChatClient(self.endpoint, CommunicationTokenCredential(refresh_option)) self.chat_client_new_user = ChatClient(self.endpoint, CommunicationTokenCredential(refresh_option_new_user))
async def create_thread_async(self): from datetime import datetime from azure.communication.chat.aio import ChatClient, CommunicationTokenCredential, CommunicationTokenRefreshOptions from azure.communication.chat import ChatThreadParticipant, CommunicationUserIdentifier refresh_options = CommunicationTokenRefreshOptions(self.token) chat_client = ChatClient(self.endpoint, CommunicationTokenCredential(refresh_options)) async with chat_client: # [START create_thread] topic = "test topic" participants = [ChatThreadParticipant( user=self.user, display_name='name', share_history_time=datetime.utcnow() )] # creates a new chat_thread everytime chat_thread_client = await chat_client.create_chat_thread(topic, participants) # creates a new chat_thread if not exists repeatability_request_id = 'b66d6031-fdcc-41df-8306-e524c9f226b8' # unique identifier chat_thread_client_w_repeatability_id = await chat_client.create_chat_thread(topic, participants, repeatability_request_id) # [END create_thread] self._thread_id = chat_thread_client.thread_id print("thread created, id: " + self._thread_id)
async def send_message_async(self): from azure.communication.chat.aio import ChatThreadClient, CommunicationTokenCredential, CommunicationTokenRefreshOptions refresh_options = CommunicationTokenRefreshOptions(self.token) chat_thread_client = ChatThreadClient( self.endpoint, CommunicationTokenCredential(refresh_options), self._thread_id) async with chat_thread_client: # [START send_message] from azure.communication.chat import ChatMessagePriority priority = ChatMessagePriority.NORMAL content = 'hello world' sender_display_name = 'sender name' send_message_result_id = await chat_thread_client.send_message( content, priority=priority, sender_display_name=sender_display_name) send_message_result_w_type_id = await chat_thread_client.send_message( content, sender_display_name=sender_display_name, chat_message_type=ChatMessageType.TEXT) # [END send_message] self._message_id = send_message_result_id print("send_message succeeded, message id:", self._message_id) print("send_message succeeded with type specified, message id:", send_message_result_w_type_id)
def create_chat_client(self): # [START create_chat_client] from azure.communication.chat.aio import ChatClient, CommunicationTokenCredential, CommunicationTokenRefreshOptions refresh_options = CommunicationTokenRefreshOptions(self.token) chat_client = ChatClient(self.endpoint, CommunicationTokenCredential(refresh_options)) # [END create_chat_client] print("chat_client created")
async def get_thread_async(self): from azure.communication.chat.aio import ChatClient, CommunicationTokenCredential, CommunicationTokenRefreshOptions refresh_options = CommunicationTokenRefreshOptions(self.token) chat_client = ChatClient(self.endpoint, CommunicationTokenCredential(refresh_options)) async with chat_client: # [START get_thread] chat_thread = await chat_client.get_chat_thread(self._thread_id) # [END get_thread] print("get_thread succeeded, thread id: " + chat_thread.id + ", thread topic: " + chat_thread.topic)
def get_chat_thread_client(self): # [START get_chat_thread_client] from azure.communication.chat.aio import ChatClient, CommunicationTokenCredential, CommunicationTokenRefreshOptions refresh_options = CommunicationTokenRefreshOptions(self.token) chat_client = ChatClient(self.endpoint, CommunicationTokenCredential(refresh_options)) chat_thread_client = chat_client.get_chat_thread_client(self._thread_id) # [END get_chat_thread_client] print("chat_thread_client created with thread id: ", chat_thread_client.thread_id)
async def delete_thread_async(self): from azure.communication.chat.aio import ChatClient, CommunicationTokenCredential, CommunicationTokenRefreshOptions refresh_options = CommunicationTokenRefreshOptions(self.token) chat_client = ChatClient(self.endpoint, CommunicationTokenCredential(refresh_options)) async with chat_client: # [START delete_thread] await chat_client.delete_chat_thread(self._thread_id) # [END delete_thread] print("delete_thread succeeded")
async def send_typing_notification_async(self): from azure.communication.chat.aio import ChatThreadClient, CommunicationTokenCredential, CommunicationTokenRefreshOptions refresh_options = CommunicationTokenRefreshOptions(self.token) chat_thread_client = ChatThreadClient( self.endpoint, CommunicationTokenCredential(refresh_options), self._thread_id) async with chat_thread_client: # [START send_typing_notification] await chat_thread_client.send_typing_notification() # [END send_typing_notification] print("send_typing_notification succeeded")
async def remove_member_async(self): from azure.communication.chat.aio import ChatThreadClient, CommunicationTokenCredential, CommunicationTokenRefreshOptions refresh_options = CommunicationTokenRefreshOptions(self.token) chat_thread_client = ChatThreadClient( self.endpoint, CommunicationTokenCredential(refresh_options), self._thread_id) async with chat_thread_client: # [START remove_member] await chat_thread_client.remove_member(self.new_user) # [END remove_member] print("remove_member_async succeeded")
async def list_participants_async(self): from azure.communication.chat.aio import ChatThreadClient, CommunicationTokenCredential, CommunicationTokenRefreshOptions refresh_options = CommunicationTokenRefreshOptions(self.token) chat_thread_client = ChatThreadClient( self.endpoint, CommunicationTokenCredential(refresh_options), self._thread_id) async with chat_thread_client: # [START list_participants] chat_thread_participants = chat_thread_client.list_participants() print("list_participants succeeded, participants:") async for chat_thread_participant in chat_thread_participants: print(chat_thread_participant)
async def list_read_receipts_async(self): from azure.communication.chat.aio import ChatThreadClient, CommunicationTokenCredential, CommunicationTokenRefreshOptions refresh_options = CommunicationTokenRefreshOptions(self.token) chat_thread_client = ChatThreadClient( self.endpoint, CommunicationTokenCredential(refresh_options), self._thread_id) async with chat_thread_client: # [START list_read_receipts] read_receipts = chat_thread_client.list_read_receipts() # [END list_read_receipts] print("list_read_receipts succeeded, receipts:") async for read_receipt in read_receipts: print(read_receipt)
async def update_message_async(self): from azure.communication.chat.aio import ChatThreadClient, CommunicationTokenCredential, CommunicationTokenRefreshOptions refresh_options = CommunicationTokenRefreshOptions(self.token) chat_thread_client = ChatThreadClient( self.endpoint, CommunicationTokenCredential(refresh_options), self._thread_id) async with chat_thread_client: # [START update_message] content = "updated message content" await chat_thread_client.update_message(self._message_id, content=content) # [END update_message] print("update_message succeeded")
async def get_message_async(self): from azure.communication.chat.aio import ChatThreadClient, CommunicationTokenCredential, CommunicationTokenRefreshOptions refresh_options = CommunicationTokenRefreshOptions(self.token) chat_thread_client = ChatThreadClient( self.endpoint, CommunicationTokenCredential(refresh_options), self._thread_id) async with chat_thread_client: # [START get_message] chat_message = await chat_thread_client.get_message( self._message_id) # [END get_message] print("get_message succeeded, message id:", chat_message.id, \ "content: ", chat_message.content)
async def update_thread_async(self): from azure.communication.chat.aio import ChatThreadClient, CommunicationTokenCredential, CommunicationTokenRefreshOptions refresh_options = CommunicationTokenRefreshOptions(self.token) chat_thread_client = ChatThreadClient( self.endpoint, CommunicationTokenCredential(refresh_options), self._thread_id) async with chat_thread_client: # [START update_thread] topic = "updated thread topic" await chat_thread_client.update_thread(topic=topic) # [END update_thread] print("update_thread succeeded")
async def list_threads_async(self): from azure.communication.chat.aio import ChatClient, CommunicationTokenCredential, CommunicationTokenRefreshOptions refresh_options = CommunicationTokenRefreshOptions(self.token) chat_client = ChatClient(self.endpoint, CommunicationTokenCredential(refresh_options)) async with chat_client: # [START list_threads] from datetime import datetime, timedelta import pytz start_time = datetime.utcnow() - timedelta(days=2) start_time = start_time.replace(tzinfo=pytz.utc) chat_thread_infos = chat_client.list_chat_threads(results_per_page=5, start_time=start_time) print("list_threads succeeded with results_per_page is 5, and were created since 2 days ago.") async for info in chat_thread_infos: print("thread id: ", info.id)
async def add_members_async(self): from azure.communication.chat.aio import ChatThreadClient, CommunicationTokenCredential, CommunicationTokenRefreshOptions refresh_options = CommunicationTokenRefreshOptions(self.token) chat_thread_client = ChatThreadClient( self.endpoint, CommunicationTokenCredential(refresh_options), self._thread_id) async with chat_thread_client: # [START add_members] from azure.communication.chat import ChatThreadMember, CommunicationUser from datetime import datetime new_member = ChatThreadMember(user=self.new_user, display_name='name', share_history_time=datetime.utcnow()) members = [new_member] await chat_thread_client.add_members(members) # [END add_members] print("add_members succeeded")
async def add_participant_async(self): from azure.communication.chat.aio import ChatThreadClient, CommunicationTokenCredential, CommunicationTokenRefreshOptions refresh_options = CommunicationTokenRefreshOptions(self.token) chat_thread_client = ChatThreadClient( self.endpoint, CommunicationTokenCredential(refresh_options), self._thread_id) async with chat_thread_client: # [START add_participant] from azure.communication.chat import ChatThreadParticipant, CommunicationUserIdentifier from datetime import datetime new_chat_thread_participant = ChatThreadParticipant( user=self.new_user, display_name='name', share_history_time=datetime.utcnow()) await chat_thread_client.add_participant( new_chat_thread_participant) # [END add_participant] print("add_participant succeeded")
async def list_messages_async(self): from azure.communication.chat.aio import ChatThreadClient, CommunicationTokenCredential, CommunicationTokenRefreshOptions refresh_options = CommunicationTokenRefreshOptions(self.token) chat_thread_client = ChatThreadClient( self.endpoint, CommunicationTokenCredential(refresh_options), self._thread_id) async with chat_thread_client: # [START list_messages] from datetime import datetime, timedelta start_time = datetime.utcnow() - timedelta(days=1) chat_messages = chat_thread_client.list_messages( results_per_page=1, start_time=start_time) print( "list_messages succeeded with results_per_page is 1, and start time is yesterday UTC" ) async for chat_message_page in chat_messages.by_page(): l = [i async for i in chat_message_page] print("page size: ", len(l))
async def create_thread_async(self): from datetime import datetime from azure.communication.chat.aio import ChatClient, CommunicationTokenCredential, CommunicationTokenRefreshOptions from azure.communication.chat import ChatThreadMember, CommunicationUser refresh_options = CommunicationTokenRefreshOptions(self.token) chat_client = ChatClient(self.endpoint, CommunicationTokenCredential(refresh_options)) async with chat_client: # [START create_thread] topic = "test topic" members = [ChatThreadMember( user=self.user, display_name='name', share_history_time=datetime.utcnow() )] chat_thread_client = await chat_client.create_chat_thread(topic, members) # [END create_thread] self._thread_id = chat_thread_client.thread_id print("thread created, id: " + self._thread_id)
def setUp(self): super(ChatClientTestAsync, self).setUp() self.recording_processors.extend([ BodyReplacerProcessor(keys=["id", "token", "createdBy", "members", "multipleStatus", "value"]), URIIdentityReplacer(), ResponseReplacerProcessor(keys=[self._resource_name]), ChatURIReplacer()]) endpoint, _ = parse_connection_str(self.connection_str) self.endpoint = endpoint self.identity_client = CommunicationIdentityClient.from_connection_string(self.connection_str) # create user self.user = self.identity_client.create_user() token_response = self.identity_client.issue_token(self.user, scopes=["chat"]) self.token = token_response.token # create ChatClient refresh_options = CommunicationTokenRefreshOptions(self.token) self.chat_client = ChatClient(self.endpoint, CommunicationTokenCredential(refresh_options))