async def _send(self, to_chat: int, chat_type: ChatType, message: UnifiedMessage):
"""
:return:
"""
self.logger.debug('begin processing message')
context = dict()
if chat_type == ChatType.UNSPECIFIED:
self.logger.warning(f'Sending to undefined group or chat {to_chat}')
return
context['message_type'] = f'{chat_type}'
context['message'] = list()
if message.image:
image_name = os.path.basename(message.image)
context['message'].append(MessageSegment.image(image_name))
if (chat_type == ChatType.PRIVATE and self.config.NameforPrivateChat) or \
(chat_type in (ChatType.GROUP, ChatType.DISCUSS) and self.config.NameforGroupChat):
# name logic
if message.chat_attrs.name:
context['message'].append(MessageSegment.text(message.chat_attrs.name))
if message.chat_attrs.reply_to:
context['message'].append(MessageSegment.text(' (➡️️' + message.chat_attrs.reply_to.name + ')'))
if message.chat_attrs.forward_from:
context['message'].append(MessageSegment.text(' (️️↩️' + message.chat_attrs.forward_from.name + ')'))
if message.chat_attrs.name:
context['message'].append(MessageSegment.text(': '))
# at user
if message.send_action.user_id:
context['message'].append(MessageSegment.at(message.send_action.user_id))
context['message'].append(MessageSegment.text(' '))
context['message'].append(MessageSegment.text(message.text))
if chat_type == ChatType.PRIVATE:
context['user_id'] = to_chat
else:
context[f'{chat_type}_id'] = to_chat
self.logger.debug('finished processing message, ready to send')
result = await self.bot.send(context, context['message'])
if message.chat_attrs:
set_egress_message_id(src_platform=message.chat_attrs.platform,
src_chat_id=message.chat_attrs.chat_id,
src_chat_type=message.chat_attrs.chat_type,
src_message_id=message.chat_attrs.message_id,
dst_platform=self.name,
dst_chat_id=to_chat,
dst_chat_type=chat_type,
dst_message_id=result.get('message_id'),
user_id=self.config.Account)
self.logger.debug('finished sending')
return result.get('message_id')
async def _send(self, to_chat: int, chat_type: ChatType, message: UnifiedMessage):
"""
decorator for send new message
:return:
"""
channel = self.get_channel(to_chat)
if not channel:
self.logger.error(f'Chat {to_chat} not found, please check your configuration')
message_text = ''
# name logic
if message.chat_attrs.name:
message_text += '**' + escape_markdown(message.chat_attrs.name) + '**\u200b'
if message.chat_attrs.reply_to:
message_text += '** (➡️️' + message.chat_attrs.reply_to.name + ')**\u200b'
if message.chat_attrs.forward_from:
message_text += '** (️️↩️' + message.chat_attrs.forward_from.name + ')**\u200b'
if message.chat_attrs.name:
message_text += '**: **\u200b'
# at user
if message.send_action.user_id:
message_text += f'<@{message.send_action.user_id}> '
message_text += unparse_entities_to_markdown(message,
EntityType.PLAIN | EntityType.BOLD | EntityType.ITALIC |
EntityType.CODE | EntityType.STRIKETHROUGH | EntityType.UNDERLINE |
EntityType.CODE_BLOCK | EntityType.QUOTE | EntityType.QUOTE_BLOCK)
if message.image:
assert isinstance(channel, discord.TextChannel)
outbound_message = await channel.send(content=message_text, file=discord.File(message.image))
else:
outbound_message = await channel.send(content=message_text)
if message.chat_attrs:
set_egress_message_id(src_platform=message.chat_attrs.platform,
src_chat_id=message.chat_attrs.chat_id,
src_chat_type=message.chat_attrs.chat_type,
src_message_id=message.chat_attrs.message_id,
dst_platform=self.name,
dst_chat_id=to_chat,
dst_chat_type=chat_type,
dst_message_id=outbound_message.id, # useless message id
user_id=0)
async def _send(self, to_chat: int, chat_type: ChatType,
message: UnifiedMessage):
"""
decorator for send new message
:return:
"""
messages = list()
if (chat_type == ChatType.PRIVATE and self.config.NameforPrivateChat) or \
(chat_type in (ChatType.GROUP, ChatType.DISCUSS) and self.config.NameforGroupChat):
# name logic
if message.chat_attrs.name:
messages.append(Plain(text=message.chat_attrs.name))
# if message.chat_attrs.reply_to:
# messages.append(Plain(text=' (➡️️' + message.chat_attrs.reply_to.name + ')'))
if message.chat_attrs.forward_from:
messages.append(
Plain(text=' (️️↩️' +
message.chat_attrs.forward_from.name + ')'))
if message.chat_attrs.name:
messages.append(Plain(text='(' + str(quote.senderId) + '): '))
# at user
if not message.send_action.message_id and message.send_action.user_id:
messages.append(At(target=message.send_action.user_id))
messages.append(Plain(text=' '))
if message.text:
messages.append(Plain(text=message.text))
if message.image:
# if chat_type == ChatType.PRIVATE:
# image_type = TargetType.Friend
# else:
# image_type = TargetType.Group
image_id = self.image_cache.get((chat_type, message.image))
if image_id:
image = Image(imageId=image_id)
else:
image = Image(path=message.image)
# image = await self.bot.upload_image(image_type=image_type, image_path=message.image)
# self.image_cache[(image_type, message.image)] = image.imageId
messages.append(image)
self.logger.info(
'If QQ does not receive this message, '
'your account might be suspected of being compromised by Tencent'
)
quote = message.send_action.message_id or None
temp_group = None
if chat_type == ChatType.PRIVATE:
message_type = MessageType.FRIEND
else:
if '[TempMessage]' in message.chat_attrs.name:
message_type = MessageType.Temp
temp_group = message.chat_attrs.chat_id
else:
message_type = MessageType.GROUP
egress_message = await self.bot.send_message(target=to_chat,
message_type=message_type,
message=messages,
temp_group=temp_group,
quote_source=quote)
for i in messages:
if isinstance(i, Image):
self.image_cache[(chat_type, message.image)] = i.imageId
break
if message.chat_attrs:
set_egress_message_id(src_platform=message.chat_attrs.platform,
src_chat_id=message.chat_attrs.chat_id,
src_chat_type=message.chat_attrs.chat_type,
src_message_id=message.chat_attrs.message_id,
dst_platform=self.name,
dst_chat_id=to_chat,
dst_chat_type=chat_type,
dst_message_id=egress_message.messageId,
user_id=self.qq)
async def _send(self, to_chat: str, chat_type: ChatType, message: UnifiedMessage):
"""
decorator for send new message
:return:
"""
self.logger.debug('begin processing message')
_chat_type = self.chat_type_dict_reversed[chat_type]
message_prefix = ''
if message.chat_attrs.name:
message_prefix = message.chat_attrs.name
if message.chat_attrs.reply_to:
message_prefix += ' (➡️️' + message.chat_attrs.reply_to.name + ')'
if message.chat_attrs.forward_from:
message_prefix += ' (️️↩️' + message.chat_attrs.forward_from.name + ')'
if message.chat_attrs.name:
message_prefix += ': '
if message.image:
_, original_file_name = os.path.split(message.image)
file_name, file_ext = original_file_name.split('.')
image_original = file_name + '-origin.' + file_ext
image_thumb = file_name + '-thumb.' + file_ext
image_original_path = os.path.join(self.data_root, image_original)
image_thumb_path = os.path.join(self.data_root, image_thumb)
if not os.path.isfile(image_original_path):
image: Image.Image = Image.open(message.image)
if image.size[0] <= 1024 and image.size[1] <= 1024:
image_original = original_file_name
else:
image.thumbnail((1024, 1024), Image.ANTIALIAS)
image.save(image_original_path)
image.thumbnail((240, 240), Image.ANTIALIAS)
image.save(image_thumb_path)
if self.reply_token[to_chat]:
await self.bot.reply_message(reply_token=self.reply_token[to_chat],
messages=TextSendMessage(text=message_prefix + 'Sent an image ⬇️'))
self.logger.debug('Begin sending image')
await self.bot.reply_message(reply_token=self.reply_token[to_chat],
messages=ImageSendMessage(
original_content_url=self.image_webhook_url + image_original,
preview_image_url=self.image_webhook_url + image_thumb)
)
self.logger.debug('Finished sending image')
else:
await self.bot.push_message(to=to_chat, messages=TextSendMessage(text=message_prefix + 'Sent an image ⬇️'))
self.logger.debug('Begin sending image')
await self.bot.push_message(to=to_chat,
messages=ImageSendMessage(original_content_url=self.image_webhook_url + image_original,
preview_image_url=self.image_webhook_url + image_thumb)
)
self.logger.debug('Finished sending image')
if message.text:
message_text = unparse_entities_to_markdown(message, EntityType.PLAIN)
_message = TextSendMessage(text=message_prefix + message_text)
if self.reply_token[to_chat]:
await self.bot.reply_message(reply_token=self.reply_token[to_chat], messages=_message)
else:
await self.bot.push_message(to=to_chat, messages=_message)
if message.chat_attrs:
set_egress_message_id(src_platform=message.chat_attrs.platform,
src_chat_id=message.chat_attrs.chat_id,
src_chat_type=message.chat_attrs.chat_type,
src_message_id=message.chat_attrs.message_id,
dst_platform=self.name,
dst_chat_id=to_chat,
dst_chat_type=_chat_type,
dst_message_id=self.message_id, # useless message id
user_id=0)
async def _send(self, to_chat: int, message: UnifiedMessage):
"""
decorator for send new message
:return:
"""
self.logger.debug('begin processing message')
await self.bot.send_chat_action(to_chat, types.chat.ChatActions.TYPING)
if message.chat_attrs.name:
text = '<b>' + message.chat_attrs.name + '</b>(' + str(
message.chat_attrs.user_id) + '): '
else:
text = ''
text += unparse_entities_to_html(
message, EntityType.LINK | EntityType.STRIKETHROUGH
| EntityType.UNDERLINE | EntityType.CODE_BLOCK | EntityType.BOLD
| EntityType.ITALIC | EntityType.PLAIN | EntityType.CODE)
if message.send_action.message_id:
reply_to_message_id = message.send_action.message_id
else:
reply_to_message_id = None # TODO support cross platform reply in the future
if message.image:
if message.image in self.image_file_id:
self.logger.debug(
f'file id for {message.image} found, sending file id')
if message.image.endswith('gif'):
tg_message = await self.bot.send_animation(
to_chat,
self.image_file_id[message.image],
caption=text,
parse_mode=types.message.ParseMode.HTML,
disable_notification=True,
reply_to_message_id=reply_to_message_id)
else:
tg_message = await self.bot.send_photo(
to_chat,
self.image_file_id[message.image],
caption=text,
parse_mode=types.message.ParseMode.HTML,
disable_notification=True,
reply_to_message_id=reply_to_message_id)
else:
self.logger.debug(
f'file id for {message.image} not found, sending image file'
)
if message.image.endswith('gif'):
tg_message = await self.bot.send_animation(
to_chat,
types.input_file.InputFile(message.image),
caption=text,
parse_mode=types.message.ParseMode.HTML,
disable_notification=True,
reply_to_message_id=reply_to_message_id)
self.image_file_id[
message.image] = tg_message.document.file_id
else:
tg_message = await self.bot.send_photo(
to_chat,
types.input_file.InputFile(message.image),
caption=text,
parse_mode=types.message.ParseMode.HTML,
disable_notification=True,
reply_to_message_id=reply_to_message_id)
self.image_file_id[
message.image] = tg_message.photo[-1].file_id
else:
self.logger.debug('finished processing message, ready to send')
tg_message = await self.bot.send_message(
to_chat,
text,
parse_mode=types.message.ParseMode.HTML,
disable_notification=True,
reply_to_message_id=reply_to_message_id)
if message.chat_attrs:
set_egress_message_id(src_platform=message.chat_attrs.platform,
src_chat_id=message.chat_attrs.chat_id,
src_chat_type=message.chat_attrs.chat_type,
src_message_id=message.chat_attrs.message_id,
dst_platform=self.name,
dst_chat_id=to_chat,
dst_chat_type=ChatType.GROUP
if to_chat < 0 else ChatType.PRIVATE,
dst_message_id=tg_message.message_id,
user_id=self.bot_user_id)
self.logger.debug('finished sending')
return tg_message.message_id