async def message_text(event: MessageEvent):
if event.source.type == 'user':
chat_id = event.source.user_id
username = await self.get_user_name(user_id=event.source.user_id)
elif event.source.type == 'group':
chat_id = event.source.group_id
username = await self.get_user_name(user_id=event.source.user_id, group_id=event.source.group_id)
elif event.source.type == 'room':
chat_id = event.source.room_id
username = await self.get_user_name(user_id=event.source.user_id, room_id=event.source.room_id)
else: # unknown source
return
self.reply_token[chat_id] = event.reply_token
_chat_type = self.chat_type_dict[event.source.type]
pseudo_message_id = self.message_id
message = UnifiedMessage(platform=self.name, chat_id=chat_id, chat_type=_chat_type, name=username, message_id=pseudo_message_id)
set_ingress_message_id(src_platform=self.name, src_chat_id=chat_id, src_chat_type=_chat_type,
src_message_id=pseudo_message_id, user_id=0)
if isinstance(event.message, TextMessage):
message.text = event.message.text
elif isinstance(event.message, StickerMessage):
message.text = 'Sent a sticker'
elif isinstance(event.message, ImageMessage):
message_content = await self.bot.get_message_content(event.message.id)
image_content = message_content.content
image: Image.Image = Image.open(BytesIO(image_content))
image_path = os.path.join(self.data_root, str(uuid4()) + '.jpg')
image.save(image_path)
message.image = image_path
else:
message.text = 'Unsupported message type'
await self.receive(message)
async def handle_msg(context):
message_type = context.get("message_type")
chat_id = context.get(f'{message_type}_id', context.get('user_id'))
chat_type = ChatType(message_type)
self.logger.debug(f'Received message: {str(context)}')
unified_message_list = await self.dissemble_message(context)
set_ingress_message_id(src_platform=self.name, src_chat_id=chat_id, src_chat_type=chat_type,
src_message_id=context.get('message_id'), user_id=context.get('user_id'))
for message in unified_message_list:
await self.receive(message)
return {}
async def handle_msg(message: types.Message):
from_user = message.from_user
_chat_type = ChatType.GROUP if message.chat.id < 0 else ChatType.PRIVATE
if message.text:
text = message.text
elif message.caption:
text = message.caption
else:
text = ''
message_entities = self.parse_entities(message)
unified_message = UnifiedMessage(
platform=self.name,
text=text,
message_entities=message_entities,
chat_id=message.chat.id,
chat_type=_chat_type,
name=from_user.full_name,
user_id=from_user.id,
message_id=message.message_id)
self.get_chat_attributes(message, unified_message.chat_attrs)
set_ingress_message_id(src_platform=self.name,
src_chat_id=message.chat.id,
src_chat_type=_chat_type,
src_message_id=message.message_id,
user_id=message.from_user.id)
if message.content_type == ContentType.TEXT:
pass
elif message.content_type == ContentType.PHOTO:
url, file_id = await self.tg_get_image(
message.photo[-1].file_id)
unified_message.image = url
unified_message.file_id = file_id
elif message.content_type == ContentType.STICKER:
url, file_id = await self.tg_get_image(
message.sticker.file_id)
unified_message.image = url
unified_message.file_id = file_id
elif message.content_type == ContentType.ANIMATION:
url, file_id = await self.tg_get_image(
message.animation.file_id)
unified_message.image = url
unified_message.file_id = file_id
else:
unified_message.text = '[Unsupported message]'
await self.receive(unified_message)
async def on_message(self, message: discord.Message):
# don't respond to ourselves
if message.author == self.user:
return
self.logger.debug(message)
if isinstance(message.author, discord.User):
from_user = message.author.display_name
user_id = message.author.id
elif isinstance(message.author, discord.Member):
from_user = message.author.display_name
user_id = message.author.id
else:
self.logger.debug(f'Unseen user type: {str(message.author)}')
from_user = message.author.display_name
user_id = message.author.id
if isinstance(message.channel, discord.DMChannel):
_chat_type = ChatType.PRIVATE
elif isinstance(message.channel, discord.GroupChannel):
_chat_type = ChatType.GROUP
elif isinstance(message.channel, discord.TextChannel):
_chat_type = ChatType.GROUP
else:
self.logger.warning('Unsupported channel type')
return
chat_id = message.channel.id
unified_message = UnifiedMessage(platform=self.name,
chat_id=chat_id,
chat_type=_chat_type,
name=from_user,
user_id=user_id,
message_id=message.id)
message_content = await self.parse_at(message.content)
unified_message.text, unified_message.text_entities = find_markdown(message_content.replace('\u200b', ''))
if message.attachments:
if message.attachments[0].proxy_url:
unified_message.image = message.attachments[0].proxy_url
if len(message.attachments) > 1:
self.logger.warning('More than one attachment detected, not sure how it happens')
set_ingress_message_id(src_platform=self.name, src_chat_id=chat_id, src_chat_type=_chat_type,
src_message_id=message.id, user_id=user_id)
await self.receive(unified_message)
async def friend_message(event: Message):
if event.type == MessageType.GROUP.value:
chat_type = ChatType.GROUP
username = event.member.memberName
chat_id = event.member.group.id
user_id = event.member.id
elif event.type == MessageType.FRIEND.value:
chat_type = ChatType.PRIVATE
username = event.friend.remark or event.friend.nickname
chat_id = event.friend.id
user_id = event.friend.id
else:
chat_type = ChatType.GROUP
username = event.member.memberName
chat_id = event.member.id
user_id = event.member.id
self.logger.debug(
f"[{event.type}][{chat_id}][{username}({user_id})]: " +
str(event.messageChain))
message_id = event.messageChain.get_source().id
set_ingress_message_id(src_platform=self.name,
src_chat_id=chat_id,
src_chat_type=chat_type,
src_message_id=message_id,
user_id=user_id)
if event.type == MessageType.TEMP:
username += ' [TempMessage]'
unified_message_list = await self.parse_message(
message_chain=event.messageChain,
chat_id=chat_id,
chat_type=chat_type,
username=username,
user_id=user_id,
message_id=message_id)
try:
for message in unified_message_list:
await self.receive(message)
except Exception as e:
self.logger.exception('unhandled exception:', exc_info=e)