def create_chat_client(self): # [START create_chat_client] from azure.communication.chat.aio import ChatClient, CommunicationUserCredential chat_client = ChatClient(self.endpoint, CommunicationUserCredential(self.token)) # [END create_chat_client] print("chat_client created")
def setUp(self): super(ChatThreadClientTestAsync, self).setUp() self.recording_processors.extend([ BodyReplacerProcessor(keys=[ "id", "token", "senderId", "chatMessageId", "nextLink", "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 another user self.new_user = self.identity_client.create_user() # create ChatClient self.chat_client = ChatClient(self.endpoint, CommunicationUserCredential(self.token))
async def delete_message_async(self): from azure.communication.chat.aio import ChatThreadClient, CommunicationUserCredential chat_thread_client = ChatThreadClient(self.endpoint, CommunicationUserCredential(self.token), self._thread_id) async with chat_thread_client: # [START delete_message] await chat_thread_client.delete_message(self._message_id) # [END delete_message] print("delete_message succeeded")
async def remove_member_async(self): from azure.communication.chat.aio import ChatThreadClient, CommunicationUserCredential chat_thread_client = ChatThreadClient(self.endpoint, CommunicationUserCredential(self.token), 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 send_typing_notification_async(self): from azure.communication.chat.aio import ChatThreadClient, CommunicationUserCredential chat_thread_client = ChatThreadClient(self.endpoint, CommunicationUserCredential(self.token), 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 delete_thread_async(self): from azure.communication.chat.aio import ChatClient, CommunicationUserCredential chat_client = ChatClient(self.endpoint, CommunicationUserCredential(self.token)) 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_read_receipt_async(self): from azure.communication.chat.aio import ChatThreadClient, CommunicationUserCredential chat_thread_client = ChatThreadClient(self.endpoint, CommunicationUserCredential(self.token), self._thread_id) async with chat_thread_client: # [START send_read_receipt] await chat_thread_client.send_read_receipt(self._message_id) # [END send_read_receipt] print("send_read_receipt succeeded")
async def update_message_async(self): from azure.communication.chat.aio import ChatThreadClient, CommunicationUserCredential chat_thread_client = ChatThreadClient(self.endpoint, CommunicationUserCredential(self.token), 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, CommunicationUserCredential chat_thread_client = ChatThreadClient(self.endpoint, CommunicationUserCredential(self.token), 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 list_members_async(self): from azure.communication.chat.aio import ChatThreadClient, CommunicationUserCredential chat_thread_client = ChatThreadClient(self.endpoint, CommunicationUserCredential(self.token), self._thread_id) async with chat_thread_client: # [START list_members] chat_thread_members = chat_thread_client.list_members() print("list_members succeeded, members:") async for chat_thread_member in chat_thread_members: print(chat_thread_member)
async def get_thread_async(self): from azure.communication.chat.aio import ChatClient, CommunicationUserCredential chat_client = ChatClient(self.endpoint, CommunicationUserCredential(self.token)) 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)
async def list_read_receipts_async(self): from azure.communication.chat.aio import ChatThreadClient, CommunicationUserCredential chat_thread_client = ChatThreadClient(self.endpoint, CommunicationUserCredential(self.token), 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_thread_async(self): from azure.communication.chat.aio import ChatThreadClient, CommunicationUserCredential chat_thread_client = ChatThreadClient(self.endpoint, CommunicationUserCredential(self.token), 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")
def get_chat_thread_client(self): # [START get_chat_thread_client] from azure.communication.chat.aio import ChatClient, CommunicationUserCredential chat_client = ChatClient(self.endpoint, CommunicationUserCredential(self.token)) 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 list_messages_async(self): from azure.communication.chat.aio import ChatThreadClient, CommunicationUserCredential chat_thread_client = ChatThreadClient(self.endpoint, CommunicationUserCredential(self.token), 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 add_members_async(self): from azure.communication.chat.aio import ChatThreadClient, CommunicationUserCredential chat_thread_client = ChatThreadClient(self.endpoint, CommunicationUserCredential(self.token), 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 list_threads_async(self): from azure.communication.chat.aio import ChatClient, CommunicationUserCredential chat_client = ChatClient(self.endpoint, CommunicationUserCredential(self.token)) 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 send_message_async(self): from azure.communication.chat.aio import ChatThreadClient, CommunicationUserCredential chat_thread_client = ChatThreadClient(self.endpoint, CommunicationUserCredential(self.token), 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 = await chat_thread_client.send_message( content, priority=priority, sender_display_name=sender_display_name) # [END send_message] self._message_id = send_message_result.id print("send_message succeeded, message id:", self._message_id)
async def create_chat_thread_client_async(self): # [START create_chat_thread_client] from datetime import datetime from azure.communication.chat.aio import ChatClient, CommunicationUserCredential from azure.communication.chat import ChatThreadMember, CommunicationUserIdentifier chat_client = ChatClient(self.endpoint, CommunicationUserCredential(self.token)) async with chat_client: 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_chat_thread_client] self._thread_id = chat_thread_client.thread_id print("thread created, id: " + self._thread_id)