`")
try:
await evt.sender.ensure_started(even_if_no_session=True)
first_name, last_name = evt.sender.command_status["full_name"]
user = await evt.sender.client.sign_up(evt.args[0], first_name, last_name)
- ignore_coro(asyncio.ensure_future(evt.sender.post_login(user), loop=evt.loop))
+ asyncio.ensure_future(evt.sender.post_login(user), loop=evt.loop)
evt.sender.command_status = None
return await evt.reply(f"Successfully registered to Telegram.")
except PhoneNumberOccupiedError:
@@ -105,7 +106,7 @@ async def enter_code_register(evt: CommandEvent) -> Dict:
@command_handler(needs_auth=False, management_only=True,
help_section=SECTION_AUTH,
help_text="Get instructions on how to log in.")
-async def login(evt: CommandEvent) -> Optional[Dict]:
+async def login(evt: CommandEvent) -> EventID:
override_sender = False
if len(evt.args) > 0 and evt.sender.is_admin:
evt.sender = await u.User.get_by_mxid(evt.args[0]).ensure_started()
@@ -142,7 +143,7 @@ async def login(evt: CommandEvent) -> Optional[Dict]:
async def _request_code(evt: CommandEvent, phone_number: str, next_status: Dict[str, Any]
- ) -> Dict:
+ ) -> EventID:
ok = False
try:
await evt.sender.ensure_started(even_if_no_session=True)
@@ -174,7 +175,7 @@ async def _request_code(evt: CommandEvent, phone_number: str, next_status: Dict[
@command_handler(needs_auth=False)
-async def enter_phone_or_token(evt: CommandEvent) -> Optional[Dict]:
+async def enter_phone_or_token(evt: CommandEvent) -> Optional[EventID]:
if len(evt.args) == 0:
return await evt.reply("**Usage:** `$cmdprefix+sp enter-phone-or-token `")
elif not evt.config.get("bridge.allow_matrix_login", True):
@@ -198,7 +199,7 @@ async def enter_phone_or_token(evt: CommandEvent) -> Optional[Dict]:
@command_handler(needs_auth=False)
-async def enter_code(evt: CommandEvent) -> Optional[Dict]:
+async def enter_code(evt: CommandEvent) -> Optional[EventID]:
if len(evt.args) == 0:
return await evt.reply("**Usage:** `$cmdprefix+sp enter-code `")
elif not evt.config.get("bridge.allow_matrix_login", True):
@@ -214,7 +215,7 @@ async def enter_code(evt: CommandEvent) -> Optional[Dict]:
@command_handler(needs_auth=False)
-async def enter_password(evt: CommandEvent) -> Optional[Dict]:
+async def enter_password(evt: CommandEvent) -> Optional[EventID]:
if len(evt.args) == 0:
return await evt.reply("**Usage:** `$cmdprefix+sp enter-password `")
elif not evt.config.get("bridge.allow_matrix_login", True):
@@ -233,7 +234,7 @@ async def enter_password(evt: CommandEvent) -> Optional[Dict]:
return None
-async def _sign_in(evt: CommandEvent, **sign_in_info) -> Dict:
+async def _sign_in(evt: CommandEvent, **sign_in_info) -> EventID:
try:
await evt.sender.ensure_started(even_if_no_session=True)
user = await evt.sender.client.sign_in(**sign_in_info)
@@ -243,7 +244,7 @@ async def _sign_in(evt: CommandEvent, **sign_in_info) -> Dict:
await evt.reply(f"[{existing_user.displayname}]"
f"(https://matrix.to/#/{existing_user.mxid})"
" was logged out from the account.")
- ignore_coro(asyncio.ensure_future(evt.sender.post_login(user), loop=evt.loop))
+ asyncio.ensure_future(evt.sender.post_login(user), loop=evt.loop)
evt.sender.command_status = None
name = f"@{user.username}" if user.username else f"+{user.phone}"
return await evt.reply(f"Successfully logged in as {name}")
@@ -265,7 +266,7 @@ async def _sign_in(evt: CommandEvent, **sign_in_info) -> Dict:
@command_handler(needs_auth=True,
help_section=SECTION_AUTH,
help_text="Log out from Telegram.")
-async def logout(evt: CommandEvent) -> Optional[Dict]:
+async def logout(evt: CommandEvent) -> EventID:
if await evt.sender.log_out():
return await evt.reply("Logged out successfully.")
return await evt.reply("Failed to log out.")
diff --git a/mautrix_telegram/commands/telegram/misc.py b/mautrix_telegram/commands/telegram/misc.py
index 5555bd1c..60b12181 100644
--- a/mautrix_telegram/commands/telegram/misc.py
+++ b/mautrix_telegram/commands/telegram/misc.py
@@ -1,4 +1,3 @@
-# -*- coding: future_fstrings -*-
# mautrix-telegram - A Matrix-Telegram puppeting bridge
# Copyright (C) 2019 Tulir Asokan
#
@@ -14,13 +13,14 @@
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see `")
@@ -60,7 +62,7 @@ async def search(evt: CommandEvent) -> Optional[Dict]:
"Minimum length of remote query is 5 characters.")
return await evt.reply("No results 3:")
- reply = [] # type: List[str]
+ reply: List[str] = []
if remote:
reply += ["**Results from Telegram server:**", ""]
else:
@@ -80,7 +82,7 @@ async def search(evt: CommandEvent) -> Optional[Dict]:
"either the internal user ID, the username or the phone number. "
"**N.B.** The phone numbers you start chats with must already be in "
"your contacts.")
-async def pm(evt: CommandEvent) -> Optional[Dict]:
+async def pm(evt: CommandEvent) -> EventID:
if len(evt.args) == 0:
return await evt.reply("**Usage:** `$cmdprefix+sp pm `")
@@ -99,7 +101,7 @@ async def pm(evt: CommandEvent) -> Optional[Dict]:
f"{pu.Puppet.get_displayname(user, False)}")
-async def _join(evt: CommandEvent, arg: str) -> Tuple[Optional[TypeUpdates], Optional[Dict]]:
+async def _join(evt: CommandEvent, arg: str) -> Tuple[Optional[TypeUpdates], Optional[EventID]]:
if arg.startswith("joinchat/"):
invite_hash = arg[len("joinchat/"):]
try:
@@ -122,7 +124,7 @@ async def _join(evt: CommandEvent, arg: str) -> Tuple[Optional[TypeUpdates], Opt
@command_handler(help_section=SECTION_CREATING_PORTALS,
help_args="<_link_>",
help_text="Join a chat with an invite link.")
-async def join(evt: CommandEvent) -> Optional[Dict]:
+async def join(evt: CommandEvent) -> Optional[EventID]:
if len(evt.args) == 0:
return await evt.reply("**Usage:** `$cmdprefix+sp join `")
@@ -142,7 +144,11 @@ async def join(evt: CommandEvent) -> Optional[Dict]:
return await evt.reply(f"Invited you to portal of {portal.title}")
else:
await evt.reply(f"Creating room for {chat.title}... This might take a while.")
- await portal.create_matrix_room(evt.sender, chat, [evt.sender.mxid])
+ try:
+ await portal.create_matrix_room(evt.sender, chat, [evt.sender.mxid])
+ except ChatIdInvalidError as e:
+ logging.getLogger("mau.commands").info(updates.stringify())
+ raise e
return await evt.reply(f"Created room for {portal.title}")
return None
@@ -150,7 +156,7 @@ async def join(evt: CommandEvent) -> Optional[Dict]:
@command_handler(help_section=SECTION_MISC,
help_args="[`chats`|`contacts`|`me`]",
help_text="Synchronize your chat portals, contacts and/or own info.")
-async def sync(evt: CommandEvent) -> Optional[Dict]:
+async def sync(evt: CommandEvent) -> EventID:
if len(evt.args) > 0:
sync_only = evt.args[0]
if sync_only not in ("chats", "contacts", "me"):
@@ -212,7 +218,7 @@ async def _parse_encoded_msgid(user: AbstractUser, enc_id: str, type_name: str
@command_handler(help_section=SECTION_MISC,
help_args="<_play ID_>",
help_text="Play a Telegram game.")
-async def play(evt: CommandEvent) -> Optional[Dict]:
+async def play(evt: CommandEvent) -> EventID:
if len(evt.args) < 1:
return await evt.reply("**Usage:** `$cmdprefix+sp play `")
elif not await evt.sender.is_logged_in():
@@ -232,14 +238,14 @@ async def play(evt: CommandEvent) -> Optional[Dict]:
if not isinstance(game, BotCallbackAnswer):
return await evt.reply("Game request response invalid")
- await evt.reply(f"Click [here]({game.url}) to play {msg.media.game.title}:\n\n"
+ return await evt.reply(f"Click [here]({game.url}) to play {msg.media.game.title}:\n\n"
f"{msg.media.game.description}")
@command_handler(help_section=SECTION_MISC,
help_args="<_poll ID_> <_choice number_>",
help_text="Vote in a Telegram poll.")
-async def vote(evt: CommandEvent) -> Optional[Dict]:
+async def vote(evt: CommandEvent) -> EventID:
if len(evt.args) < 1:
return await evt.reply("**Usage:** `$cmdprefix+sp vote `")
elif not await evt.sender.is_logged_in():
diff --git a/mautrix_telegram/config.py b/mautrix_telegram/config.py
index 4aa165fd..eb42b33f 100644
--- a/mautrix_telegram/config.py
+++ b/mautrix_telegram/config.py
@@ -1,4 +1,3 @@
-# -*- coding: future_fstrings -*-
# mautrix-telegram - A Matrix-Telegram puppeting bridge
# Copyright (C) 2019 Tulir Asokan
#
@@ -14,149 +13,27 @@
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see
"
- f"{html}
"
+ f"{content.formatted_body}
{r_msg_link} {r_sender_link}\n{r_html_body}
- {evt.post_author}"
+ if not content.formatted_body:
+ content.formatted_body = escape(content.body)
+ content.body += f"\n- {evt.post_author}"
+ content.formatted_body += f"
- {evt.post_author}"
- if html:
- html = html.replace("\n", "
")
+ content.body = del_surrogate(content.body)
- return remove_surrogates(text), remove_surrogates(html), relates_to
+ if content.formatted_body:
+ content.formatted_body = del_surrogate(content.formatted_body.replace("\n", "
"))
+
+ return content
def _telegram_entities_to_matrix_catch(text: str, entities: List[TypeMessageEntity]) -> str:
@@ -313,8 +289,8 @@ def _parse_name_mention(html: List[str], entity_text: str, user_id: TelegramID)
return False
-message_link_regex = re.compile(
- r"https?://t(?:elegram)?\.(?:me|dog)/([A-Za-z][A-Za-z0-9_]{3,}[A-Za-z0-9])/([0-9]{1,50})")
+message_link_regex = re.compile(r"https?://t(?:elegram)?\.(?:me|dog)/"
+ r"([A-Za-z][A-Za-z0-9_]{3,}[A-Za-z0-9])/([0-9]{1,50})")
def _parse_url(html: List[str], entity_text: str, url: str) -> bool:
diff --git a/mautrix_telegram/formatter/util.py b/mautrix_telegram/formatter/util.py
deleted file mode 100644
index 4ac01284..00000000
--- a/mautrix_telegram/formatter/util.py
+++ /dev/null
@@ -1,57 +0,0 @@
-# -*- coding: future_fstrings -*-
-# mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2019 Tulir Asokan
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-# GNU Affero General Public License for more details.
-#
-# You should have received a copy of the GNU Affero General Public License
-# along with this program. If not, see Optional[str]:
- if text is None:
- return None
- return text.encode("utf-16", "surrogatepass").decode("utf-16")
-
-
-# trim_reply_fallback_text, html_reply_fallback_regex and trim_reply_fallback_html are Matrix
-# reply fallback utility functions.
-# You may copy and use them under any OSI-approved license.
-def trim_reply_fallback_text(text: str) -> str:
- if not text.startswith("> ") or "\n" not in text:
- return text
- lines = text.split("\n")
- while len(lines) > 0 and lines[0].startswith("> "):
- lines.pop(0)
- return "\n".join(lines)
-
-
-html_reply_fallback_regex = re.compile("^"
- r"[\s\S]+?"
- " ") # type: Pattern
-
-
-def trim_reply_fallback_html(html: str) -> str:
- return html_reply_fallback_regex.sub("", html)
diff --git a/mautrix_telegram/matrix.py b/mautrix_telegram/matrix.py
index 03c10af2..68ba0b03 100644
--- a/mautrix_telegram/matrix.py
+++ b/mautrix_telegram/matrix.py
@@ -1,4 +1,3 @@
-# -*- coding: future_fstrings -*-
# mautrix-telegram - A Matrix-Telegram puppeting bridge
# Copyright (C) 2019 Tulir Asokan
#
@@ -14,58 +13,56 @@
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see You are not whitelisted to use this bridge.
"
- "If you are the owner of this bridge, see the "
- "bridge.permissions section in your config file.
")
- await self.az.intent.leave_room(room_id)
-
+ async def send_welcome_message(self, room_id: RoomID, inviter: 'u.User') -> None:
try:
is_management = len(await self.az.intent.get_room_members(room_id)) == 2
- except MatrixRequestError:
- is_management = False
+ except MatrixError:
+ # The AS bot is not in the room.
+ return
cmd_prefix = self.commands.command_prefix
text = html = "Hello, I'm a Telegram bridge bot. "
if is_management and inviter.puppet_whitelisted and not await inviter.is_logged_in():
text += f"Use `{cmd_prefix} help` for help or `{cmd_prefix} login` to log in."
html += (f"Use {cmd_prefix} help for help"
f" or {cmd_prefix} login to log in.")
- pass
else:
text += f"Use `{cmd_prefix} help` for help."
html += f"Use {cmd_prefix} help for help."
await self.az.intent.send_notice(room_id, text=text, html=html)
- async def handle_invite(self, room_id: MatrixRoomID, user_id: MatrixUserID,
- inviter_mxid: MatrixUserID) -> None:
- self.log.debug(f"{inviter_mxid} invited {user_id} to {room_id}")
- inviter = u.User.get_by_mxid(inviter_mxid)
- if inviter is None:
- self.log.exception("Failed to find user with Matrix ID {inviter_mxid}")
- await inviter.ensure_started()
- if user_id == self.az.bot_mxid:
- return await self.accept_bot_invite(room_id, inviter)
- elif not inviter.whitelisted:
- return
-
- puppet = pu.Puppet.get_by_mxid(user_id)
- if puppet:
- await self.handle_puppet_invite(room_id, puppet, inviter)
- return
-
+ async def handle_invite(self, room_id: RoomID, user_id: UserID, inviter: 'u.User',
+ event_id: EventID) -> None:
user = u.User.get_by_mxid(user_id, create=False)
if not user:
return
@@ -187,10 +140,7 @@ class MatrixHandler:
await portal.invite_telegram(inviter, user)
return
- # The rest can probably be ignored
-
- async def handle_join(self, room_id: MatrixRoomID, user_id: MatrixUserID,
- event_id: MatrixEventID) -> None:
+ async def handle_join(self, room_id: RoomID, user_id: UserID, event_id: EventID) -> None:
user = await u.User.get_by_mxid(user_id).ensure_started()
portal = po.Portal.get_by_mxid(room_id)
@@ -198,24 +148,24 @@ class MatrixHandler:
return
if not user.relaybot_whitelisted:
- await portal.main_intent.kick(room_id, user.mxid,
- "You are not whitelisted on this Telegram bridge.")
+ await portal.main_intent.kick_user(room_id, user.mxid,
+ "You are not whitelisted on this Telegram bridge.")
return
elif not await user.is_logged_in() and not portal.has_bot:
- await portal.main_intent.kick(room_id, user.mxid,
- "This chat does not have a bot relaying "
- "messages for unauthenticated users.")
+ await portal.main_intent.kick_user(room_id, user.mxid,
+ "This chat does not have a bot relaying "
+ "messages for unauthenticated users.")
return
self.log.debug(f"{user} joined {room_id}")
if await user.is_logged_in() or portal.has_bot:
await portal.join_matrix(user, event_id)
- async def handle_part(self, room_id: MatrixRoomID, user_id: MatrixUserID,
- sender_mxid: MatrixUserID, event_id: MatrixEventID) -> None:
+ async def handle_raw_leave(self, room_id: RoomID, user_id: UserID, sender_id: UserID,
+ reason: str, event_id: EventID) -> None:
self.log.debug(f"{user_id} left {room_id}")
- sender = u.User.get_by_mxid(sender_mxid, create=False)
+ sender = u.User.get_by_mxid(sender_id, create=False)
if not sender:
return
await sender.ensure_started()
@@ -226,98 +176,67 @@ class MatrixHandler:
puppet = pu.Puppet.get_by_mxid(user_id)
if puppet:
- if sender:
- await portal.kick_matrix(puppet, sender)
+ await portal.kick_matrix(puppet, sender)
return
user = u.User.get_by_mxid(user_id, create=False)
if not user:
return
await user.ensure_started()
- if await user.is_logged_in() or portal.has_bot:
- await portal.leave_matrix(user, sender, event_id)
-
- def is_command(self, message: Dict) -> Tuple[bool, str]:
- text = message.get("body", "")
- prefix = self.config["bridge.command_prefix"]
- is_command = text.startswith(prefix)
- if is_command:
- text = text[len(prefix) + 1:].lstrip()
- return is_command, text
-
- async def handle_message(self, room: MatrixRoomID, sender_id: MatrixUserID, message: Dict,
- event_id: MatrixEventID) -> None:
- is_command, text = self.is_command(message)
- sender = await u.User.get_by_mxid(sender_id).ensure_started()
- if not sender.relaybot_whitelisted:
- self.log.debug(f"Ignoring message \"{message}\" from {sender} to {room}:"
- " User is not whitelisted.")
- return
- self.log.debug(f"Received Matrix event \"{message}\" from {sender} in {room}")
-
- portal = po.Portal.get_by_mxid(room)
- if not is_command and portal and (await sender.is_logged_in() or portal.has_bot):
- await portal.handle_matrix_message(sender, message, event_id)
- return
-
- if not sender.whitelisted or message.get("msgtype", "m.unknown") != "m.text":
- return
-
- try:
- is_management = len(await self.az.intent.get_room_members(room)) == 2
- except MatrixRequestError:
- # The AS bot is not in the room.
- return
-
- if is_command or is_management:
- try:
- command, arguments = text.split(" ", 1)
- args = arguments.split(" ")
- except ValueError:
- # Not enough values to unpack, i.e. no arguments
- command = text
- args = []
- await self.commands.handle(room, event_id, sender, command, args, is_management,
- is_portal=portal is not None)
+ if sender_id != user_id:
+ await portal.kick_matrix(user, sender)
+ else:
+ await portal.leave_matrix(user, event_id)
@staticmethod
- async def handle_redaction(room_id: MatrixRoomID, sender_mxid: MatrixUserID,
- event_id: MatrixEventID) -> None:
- sender = await u.User.get_by_mxid(sender_mxid).ensure_started()
+ async def allow_message(user: 'u.User') -> bool:
+ return user.relaybot_whitelisted
+
+ @staticmethod
+ async def allow_command(user: 'u.User') -> bool:
+ return user.whitelisted
+
+ @staticmethod
+ async def allow_bridging_message(user: 'u.User', portal: 'po.Portal') -> bool:
+ return await user.is_logged_in() or portal.has_bot
+
+ @staticmethod
+ async def handle_redaction(evt: RedactionEvent) -> None:
+ sender = await u.User.get_by_mxid(evt.sender).ensure_started()
if not sender.relaybot_whitelisted:
return
- portal = po.Portal.get_by_mxid(room_id)
+ portal = po.Portal.get_by_mxid(evt.room_id)
if not portal:
return
- await portal.handle_matrix_deletion(sender, event_id)
+ await portal.handle_matrix_deletion(sender, evt.redacts)
@staticmethod
- async def handle_power_levels(room_id: MatrixRoomID, sender_mxid: MatrixUserID,
- new: Dict, old: Dict) -> None:
- portal = po.Portal.get_by_mxid(room_id)
- sender = await u.User.get_by_mxid(sender_mxid).ensure_started()
+ async def handle_power_levels(evt: StateEvent) -> None:
+ portal = po.Portal.get_by_mxid(evt.room_id)
+ sender = await u.User.get_by_mxid(evt.sender).ensure_started()
if await sender.has_full_access(allow_bot=True) and portal:
- await portal.handle_matrix_power_levels(sender, new["users"], old["users"])
+ await portal.handle_matrix_power_levels(sender, evt.content.users,
+ evt.unsigned.prev_content.users)
@staticmethod
- async def handle_room_meta(evt_type: str, room_id: MatrixRoomID, sender_mxid: MatrixUserID,
- content: dict) -> None:
+ async def handle_room_meta(evt_type: EventType, room_id: RoomID, sender_mxid: UserID,
+ content: RoomMetaStateEventContent) -> None:
portal = po.Portal.get_by_mxid(room_id)
sender = await u.User.get_by_mxid(sender_mxid).ensure_started()
if await sender.has_full_access(allow_bot=True) and portal:
handler, content_key = {
- "m.room.name": (portal.handle_matrix_title, "name"),
- "m.room.topic": (portal.handle_matrix_about, "topic"),
- "m.room.avatar": (portal.handle_matrix_avatar, "url"),
+ EventType.ROOM_NAME: (portal.handle_matrix_title, "name"),
+ EventType.ROOM_TOPIC: (portal.handle_matrix_about, "topic"),
+ EventType.ROOM_AVATAR: (portal.handle_matrix_avatar, "url"),
}[evt_type]
if content_key not in content:
return
await handler(sender, content[content_key])
@staticmethod
- async def handle_room_pin(room_id: MatrixRoomID, sender_mxid: MatrixUserID,
+ async def handle_room_pin(room_id: RoomID, sender_mxid: UserID,
new_events: Set[str], old_events: Set[str]) -> None:
portal = po.Portal.get_by_mxid(room_id)
sender = await u.User.get_by_mxid(sender_mxid).ensure_started()
@@ -325,62 +244,69 @@ class MatrixHandler:
events = new_events - old_events
if len(events) > 0:
# New event pinned, set that as pinned in Telegram.
- await portal.handle_matrix_pin(sender, MatrixEventID(events.pop()))
+ await portal.handle_matrix_pin(sender, EventID(events.pop()))
elif len(new_events) == 0:
# All pinned events removed, remove pinned event in Telegram.
await portal.handle_matrix_pin(sender, None)
@staticmethod
- async def handle_room_upgrade(room_id: MatrixRoomID, new_room_id: MatrixRoomID) -> None:
+ async def handle_room_upgrade(room_id: RoomID, new_room_id: RoomID) -> None:
portal = po.Portal.get_by_mxid(room_id)
if portal:
await portal.handle_matrix_upgrade(new_room_id)
- @staticmethod
- async def handle_name_change(room_id: MatrixRoomID, user_id: MatrixUserID, displayname: str,
- prev_displayname: str, event_id: MatrixEventID) -> None:
+ async def handle_member_info_change(self, room_id: RoomID, user_id: UserID,
+ profile: MemberStateEventContent,
+ prev_profile: MemberStateEventContent,
+ event_id: EventID) -> None:
+ if profile.displayname == prev_profile.displayname:
+ return
+
portal = po.Portal.get_by_mxid(room_id)
if not portal or not portal.has_bot:
return
user = await u.User.get_by_mxid(user_id).ensure_started()
if await user.needs_relaybot(portal):
- await portal.name_change_matrix(user, displayname, prev_displayname, event_id)
+ await portal.name_change_matrix(user, profile.displayname, prev_profile.displayname,
+ event_id)
@staticmethod
- def parse_read_receipts(content: Dict) -> Dict[MatrixUserID, MatrixEventID]:
- return {user_id: event_id
+ def parse_read_receipts(content: ReceiptEventContent) -> Iterable[Tuple[UserID, EventID]]:
+ return ((user_id, event_id)
for event_id, receipts in content.items()
- for user_id in receipts.get("m.read", {})}
+ for user_id in receipts.get(ReceiptType.READ, {}))
@staticmethod
- async def handle_read_receipts(room_id: MatrixRoomID,
- receipts: Dict[MatrixUserID, MatrixEventID]) -> None:
+ async def handle_read_receipts(room_id: RoomID, receipts: Iterable[Tuple[UserID, EventID]]
+ ) -> None:
portal = po.Portal.get_by_mxid(room_id)
if not portal:
return
- for user_id, event_id in receipts.items():
+ for user_id, event_id in receipts:
user = await u.User.get_by_mxid(user_id).ensure_started()
if not await user.is_logged_in():
continue
await portal.mark_read(user, event_id)
@staticmethod
- async def handle_presence(user_id: MatrixUserID, presence: str) -> None:
+ async def handle_presence(user_id: UserID, presence: PresenceState) -> None:
user = await u.User.get_by_mxid(user_id).ensure_started()
if not await user.is_logged_in():
return
- await user.set_presence(presence == "online")
+ await user.set_presence(presence == PresenceState.ONLINE)
- async def handle_typing(self, room_id: MatrixRoomID, now_typing: List[MatrixUserID]) -> None:
+ async def handle_typing(self, room_id: RoomID, now_typing: Set[UserID]) -> None:
portal = po.Portal.get_by_mxid(room_id)
if not portal:
return
- for user_id in set(self.previously_typing + now_typing):
+ previously_typing = self.previously_typing.get(room_id, set())
+
+ for user_id in set(previously_typing | now_typing):
is_typing = user_id in now_typing
- was_typing = user_id in self.previously_typing
+ was_typing = user_id in previously_typing
if is_typing and was_typing:
continue
@@ -390,88 +316,46 @@ class MatrixHandler:
await portal.set_typing(user, is_typing)
- self.previously_typing = now_typing
+ self.previously_typing[room_id] = now_typing
- def filter_matrix_event(self, event: MatrixEvent) -> bool:
- sender = event.get("sender", None)
- if not sender:
- return False
- return (sender == self.az.bot_mxid
- or pu.Puppet.get_id_from_mxid(sender) is not None)
+ def filter_matrix_event(self, evt: Event) -> bool:
+ if not isinstance(evt, (RedactionEvent, MessageEvent, StateEvent)):
+ return True
+ return evt.sender and (evt.sender == self.az.bot_mxid
+ or pu.Puppet.get_id_from_mxid(evt.sender) is not None)
- async def try_handle_ephemeral_event(self, evt: MatrixEvent) -> None:
- try:
- await self.handle_ephemeral_event(evt)
- except Exception:
- self.log.exception("Error handling manually received Matrix event")
+ async def handle_ephemeral_event(self, evt: Union[ReceiptEvent, PresenceEvent, TypingEvent]
+ ) -> None:
+ if evt.type == EventType.RECEIPT:
+ await self.handle_read_receipts(evt.room_id, self.parse_read_receipts(evt.content))
+ elif evt.type == EventType.PRESENCE:
+ await self.handle_presence(evt.sender, evt.content.presence)
+ elif evt.type == EventType.TYPING:
+ await self.handle_typing(evt.room_id, set(evt.content.user_ids))
- async def handle_ephemeral_event(self, evt: MatrixEvent) -> None:
- evt_type = evt.get("type", "m.unknown") # type: str
- room_id = evt.get("room_id", None) # type: Optional[MatrixRoomID]
- sender = evt.get("sender", None) # type: Optional[MatrixUserID]
- content = evt.get("content", {}) # type: Dict
- if evt_type == "m.receipt":
- await self.handle_read_receipts(room_id, self.parse_read_receipts(content))
- elif evt_type == "m.presence":
- await self.handle_presence(sender, content.get("presence", "offline"))
- elif evt_type == "m.typing":
- await self.handle_typing(room_id, content.get("user_ids", []))
+ async def handle_event(self, evt: Event) -> None:
+ if evt.type == EventType.ROOM_REDACTION:
+ await self.handle_redaction(evt)
- async def handle_event(self, evt: MatrixEvent) -> None:
- if self.filter_matrix_event(evt):
- return
- start_time = time.time()
- self.log.debug("Received event: %s", evt)
- evt_type = evt.get("type", "m.unknown") # type: str
- room_id = evt.get("room_id", None) # type: Optional[MatrixRoomID]
- event_id = evt.get("event_id", None) # type: Optional[MatrixEventID]
- sender = evt.get("sender", None) # type: Optional[MatrixUserID]
- state_key = evt.get("state_key", None)
- content = evt.get("content", {}) # type: Dict
- if state_key is not None:
- if evt_type == "m.room.member":
- prev_content = evt.get("unsigned", {}).get("prev_content", {}) # type: Dict
- membership = content.get("membership", "") # type: str
- prev_membership = prev_content.get("membership", "leave") # type: str
- if membership == prev_membership:
- match = re.compile("@(.+):(.+)").match(state_key) # type: Match
- mxid = match.group(0) # type: str
- displayname = content.get("displayname", None) or mxid # type: str
- prev_displayname = prev_content.get("displayname", None) or mxid # type: str
- if displayname != prev_displayname:
- await self.handle_name_change(room_id, state_key, displayname,
- prev_displayname, event_id)
- elif membership == "invite":
- await self.handle_invite(room_id, state_key, sender)
- elif prev_membership == "join" and membership == "leave":
- await self.handle_part(room_id, state_key, sender, event_id)
- elif membership == "join":
- await self.handle_join(room_id, state_key, event_id)
- elif evt_type == "m.room.power_levels":
- prev_content = evt.get("unsigned", {}).get("prev_content", {})
- await self.handle_power_levels(room_id, sender, evt["content"], prev_content)
- elif evt_type in ("m.room.name", "m.room.avatar", "m.room.topic"):
- await self.handle_room_meta(evt_type, room_id, sender, evt["content"])
- elif evt_type == "m.room.pinned_events":
- new_events = set(evt["content"]["pinned"])
- try:
- old_events = set(evt["unsigned"]["prev_content"]["pinned"])
- except KeyError:
- old_events = set()
- await self.handle_room_pin(room_id, sender, new_events, old_events)
- elif evt_type == "m.room.tombstone":
- await self.handle_room_upgrade(room_id, evt["content"]["replacement_room"])
- else:
- return
- else:
- if evt_type in ("m.room.message", "m.sticker"):
- if evt_type != "m.room.message":
- content["msgtype"] = evt_type
- await self.handle_message(room_id, sender, content, event_id)
- elif evt_type == "m.room.redaction":
- await self.handle_redaction(room_id, sender, evt["redacts"])
- else:
- return
+ async def handle_state_event(self, evt: StateEvent) -> None:
+ if evt.type == EventType.ROOM_POWER_LEVELS:
+ await self.handle_power_levels(evt)
+ elif evt.type in (EventType.ROOM_NAME, EventType.ROOM_AVATAR, EventType.ROOM_TOPIC):
+ await self.handle_room_meta(evt.type, evt.room_id, evt.sender, evt.content)
+ elif evt.type == EventType.ROOM_PINNED_EVENTS:
+ new_events = set(evt.content.pinned)
+ try:
+ old_events = set(evt.unsigned.prev_content.pinned)
+ except (KeyError, ValueError, TypeError, AttributeError):
+ old_events = set()
+ await self.handle_room_pin(evt.room_id, evt.sender, new_events, old_events)
+ elif evt.type == EventType.ROOM_TOMBSTONE:
+ await self.handle_room_upgrade(evt.room_id, evt.content.replacement_room)
- if EVENT_TIME:
- EVENT_TIME.labels(event_type=evt_type).observe(time.time() - start_time)
+ # async def handle_event(self, evt: MatrixEvent) -> None:
+ # if self.filter_matrix_event(evt):
+ # return
+ # start_time = time.time()
+ #
+ # if EVENT_TIME:
+ # EVENT_TIME.labels(event_type=evt_type).observe(time.time() - start_time)
diff --git a/mautrix_telegram/portal.py b/mautrix_telegram/portal.py
deleted file mode 100644
index 2be1c05f..00000000
--- a/mautrix_telegram/portal.py
+++ /dev/null
@@ -1,2171 +0,0 @@
-# -*- coding: future_fstrings -*-
-# mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2019 Tulir Asokan
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-# GNU Affero General Public License for more details.
-#
-# You should have received a copy of the GNU Affero General Public License
-# along with this program. If not, see
")
- body = message["formatted_body"]
-
- tpl = (self.get_config(f"message_formats.[{msgtype}]")
- or "$sender_displayname: $message")
- displayname = await self.get_displayname(sender)
- tpl_args = dict(sender_mxid=sender.mxid,
- sender_username=sender.mxid_localpart,
- sender_displayname=escape_html(displayname),
- message=body)
- message["formatted_body"] = Template(tpl).safe_substitute(tpl_args)
-
- async def _pre_process_matrix_message(self, sender: 'u.User', use_relaybot: bool,
- message: Dict[str, Any]) -> None:
- msgtype = message.get("msgtype", "m.text")
- if msgtype == "m.emote":
- await self._apply_msg_format(sender, msgtype, message)
- if "m.new_content" in message:
- await self._apply_msg_format(sender, msgtype, message["m.new_content"])
- message["m.new_content"]["msgtype"] = "m.text"
- message["msgtype"] = "m.text"
- elif use_relaybot:
- await self._apply_msg_format(sender, msgtype, message)
- if "m.new_content" in message:
- await self._apply_msg_format(sender, msgtype, message["m.new_content"])
-
- @staticmethod
- def _matrix_event_to_entities(event: Dict[str, Any]
- ) -> Tuple[str, Optional[List[TypeMessageEntity]]]:
- try:
- if event.get("format", None) == "org.matrix.custom.html":
- message, entities = formatter.matrix_to_telegram(event.get("formatted_body", ""))
- else:
- message, entities = formatter.matrix_text_to_telegram(event.get("body", ""))
- except KeyError:
- message, entities = None, None
- return message, entities
-
- def require_send_lock(self, user_id: TelegramID) -> asyncio.Lock:
- if user_id is None:
- raise ValueError("Required send lock for none id")
- try:
- return self._send_locks[user_id]
- except KeyError:
- self._send_locks[user_id] = asyncio.Lock()
- return self._send_locks[user_id]
-
- def optional_send_lock(self, user_id: TelegramID) -> Optional[asyncio.Lock]:
- if user_id is None:
- return None
- try:
- return self._send_locks[user_id]
- except KeyError:
- return None
-
- async def _handle_matrix_text(self, sender_id: TelegramID, event_id: MatrixEventID,
- space: TelegramID, client: 'MautrixTelegramClient',
- message: Dict, reply_to: TelegramID) -> None:
- lock = self.require_send_lock(sender_id)
- async with lock:
- lp = self.get_config("telegram_link_preview")
- relates_to = message.get("m.relates_to", None) or {}
- if relates_to.get("rel_type", None) == "m.replace":
- orig_msg = DBMessage.get_by_mxid(relates_to.get("event_id", ""), self.mxid, space)
- if orig_msg and "m.new_content" in message:
- message = message["m.new_content"]
- response = await client.edit_message(self.peer, orig_msg.tgid, message,
- parse_mode=self._matrix_event_to_entities,
- link_preview=lp)
- self._add_telegram_message_to_db(event_id, space, -1, response)
- return
- response = await client.send_message(self.peer, message, reply_to=reply_to,
- parse_mode=self._matrix_event_to_entities,
- link_preview=lp)
- self._add_telegram_message_to_db(event_id, space, 0, response)
-
- async def _handle_matrix_file(self, msgtype: str, sender_id: TelegramID,
- event_id: MatrixEventID, space: TelegramID,
- client: 'MautrixTelegramClient', message: dict,
- reply_to: TelegramID) -> None:
- file = await self.main_intent.download_file(message["url"])
-
- info = message.get("info", {})
- mime = info.get("mimetype", None)
-
- w, h = None, None
-
- if msgtype == "m.sticker":
- if mime != "image/gif":
- mime, file, w, h = util.convert_image(file, source_mime=mime, target_type="webp")
- else:
- # Remove sticker description
- message["mxtg_filename"] = "sticker.gif"
- message["body"] = ""
- elif "w" in info and "h" in info:
- w, h = info["w"], info["h"]
-
- file_name = self._get_file_meta(message["mxtg_filename"], mime)
- attributes = [DocumentAttributeFilename(file_name=file_name)]
- if w and h:
- attributes.append(DocumentAttributeImageSize(w, h))
-
- caption = message["body"] if message["body"].lower() != file_name.lower() else None
-
- media = await client.upload_file_direct(
- file, mime, attributes, file_name,
- max_image_size=config["bridge.image_as_file_size"] * 1000 ** 2)
- lock = self.require_send_lock(sender_id)
- async with lock:
- relates_to = message.get("m.relates_to", None) or {}
- if relates_to.get("rel_type", None) == "m.replace":
- orig_msg = DBMessage.get_by_mxid(relates_to.get("event_id", ""), self.mxid, space)
- if orig_msg:
- response = await client.edit_message(self.peer, orig_msg.tgid,
- caption, file=media)
- self._add_telegram_message_to_db(event_id, space, -1, response)
- return
- try:
- response = await client.send_media(self.peer, media, reply_to=reply_to,
- caption=caption)
- except (PhotoInvalidDimensionsError, PhotoSaveFileInvalidError, PhotoExtInvalidError):
- media = InputMediaUploadedDocument(file=media.file, mime_type=mime,
- attributes=attributes)
- response = await client.send_media(self.peer, media, reply_to=reply_to,
- caption=caption)
- self._add_telegram_message_to_db(event_id, space, 0, response)
-
- async def _handle_matrix_location(self, sender_id: TelegramID, event_id: MatrixEventID,
- space: TelegramID, client: 'MautrixTelegramClient',
- message: Dict[str, Any], reply_to: TelegramID) -> None:
- try:
- lat, long = message["geo_uri"][len("geo:"):].split(",")
- lat, long = float(lat), float(long)
- except (KeyError, ValueError):
- self.log.exception("Failed to parse location")
- return None
- caption, entities = self._matrix_event_to_entities(message)
- media = MessageMediaGeo(geo=GeoPoint(lat, long, access_hash=0))
-
- lock = self.require_send_lock(sender_id)
- async with lock:
- relates_to = message.get("m.relates_to", None) or {}
- if relates_to.get("rel_type", None) == "m.replace":
- orig_msg = DBMessage.get_by_mxid(relates_to.get("event_id", ""), self.mxid, space)
- if orig_msg:
- response = await client.edit_message(self.peer, orig_msg.tgid,
- caption, file=media)
- self._add_telegram_message_to_db(event_id, space, -1, response)
- return
- response = await client.send_media(self.peer, media, reply_to=reply_to,
- caption=caption, entities=entities)
- self._add_telegram_message_to_db(event_id, space, 0, response)
-
- def _add_telegram_message_to_db(self, event_id: MatrixEventID, space: TelegramID,
- edit_index: int, response: TypeMessage) -> None:
- self.log.debug("Handled Matrix message: %s", response)
- self.is_duplicate(response, (event_id, space), force_hash=edit_index != 0)
- if edit_index < 0:
- prev_edit = DBMessage.get_one_by_tgid(TelegramID(response.id), space, -1)
- edit_index = prev_edit.edit_index + 1
- DBMessage(
- tgid=TelegramID(response.id),
- tg_space=space,
- mx_room=self.mxid,
- mxid=event_id,
- edit_index=edit_index).insert()
-
- async def handle_matrix_message(self, sender: 'u.User', message: Dict[str, Any],
- event_id: MatrixEventID) -> None:
- if "body" not in message or "msgtype" not in message:
- self.log.debug(f"Ignoring message {event_id} in {self.mxid} without body or msgtype")
- return
-
- puppet = p.Puppet.get_by_custom_mxid(sender.mxid)
- if puppet and message.get("net.maunium.telegram.puppet", False):
- self.log.debug("Ignoring puppet-sent message by confirmed puppet user %s", sender.mxid)
- return
-
- logged_in = not await sender.needs_relaybot(self)
- client = sender.client if logged_in else self.bot.client
- sender_id = sender.tgid if logged_in else self.bot.tgid
- space = (self.tgid if self.peer_type == "channel" # Channels have their own ID space
- else (sender.tgid if logged_in else self.bot.tgid))
- reply_to = formatter.matrix_reply_to_telegram(message, space, room_id=self.mxid)
-
- message["mxtg_filename"] = message["body"]
- await self._pre_process_matrix_message(sender, not logged_in, message)
- msgtype = message["msgtype"]
-
- if msgtype == "m.notice":
- bridge_notices = self.get_config("bridge_notices.default")
- excepted = sender.mxid in self.get_config("bridge_notices.exceptions")
- if not bridge_notices and not excepted:
- return
-
- if msgtype == "m.text" or msgtype == "m.notice":
- await self._handle_matrix_text(sender_id, event_id, space, client, message, reply_to)
- elif msgtype == "m.location":
- await self._handle_matrix_location(sender_id, event_id, space, client, message,
- reply_to)
- elif msgtype in ("m.sticker", "m.image", "m.file", "m.audio", "m.video"):
- await self._handle_matrix_file(msgtype, sender_id, event_id, space, client, message,
- reply_to)
- else:
- self.log.debug(f"Unhandled Matrix event: {message}")
-
- async def handle_matrix_pin(self, sender: 'u.User',
- pinned_message: Optional[MatrixEventID]) -> None:
- if self.peer_type != "chat" and self.peer_type != "channel":
- return
- try:
- if not pinned_message:
- await sender.client(UpdatePinnedMessageRequest(peer=self.peer, id=0))
- else:
- tg_space = self.tgid if self.peer_type == "channel" else sender.tgid
- message = DBMessage.get_by_mxid(pinned_message, self.mxid, tg_space)
- if message is None:
- self.log.warning(f"Could not find pinned {pinned_message} in {self.mxid}")
- return
- await sender.client(UpdatePinnedMessageRequest(peer=self.peer, id=message.tgid))
- except ChatNotModifiedError:
- pass
-
- async def handle_matrix_deletion(self, deleter: 'u.User', event_id: MatrixEventID) -> None:
- real_deleter = deleter if not await deleter.needs_relaybot(self) else self.bot
- space = self.tgid if self.peer_type == "channel" else real_deleter.tgid
- message = DBMessage.get_by_mxid(event_id, self.mxid, space)
- if not message:
- return
- if message.edit_index == 0:
- await real_deleter.client.delete_messages(self.peer, [message.tgid])
- else:
- self.log.debug(f"Ignoring deletion of edit event {message.mxid} in {message.mx_room}")
-
- async def _update_telegram_power_level(self, sender: 'u.User', user_id: TelegramID,
- level: int) -> None:
- if self.peer_type == "chat":
- await sender.client(EditChatAdminRequest(
- chat_id=self.tgid, user_id=user_id, is_admin=level >= 50))
- elif self.peer_type == "channel":
- moderator = level >= 50
- admin = level >= 75
- rights = ChatAdminRights(change_info=moderator, post_messages=moderator,
- edit_messages=moderator, delete_messages=moderator,
- ban_users=moderator, invite_users=moderator,
- pin_messages=moderator, add_admins=admin)
- await sender.client(
- EditAdminRequest(channel=await self.get_input_entity(sender),
- user_id=user_id, admin_rights=rights))
-
- async def handle_matrix_power_levels(self, sender: 'u.User',
- new_users: Dict[MatrixUserID, int],
- old_users: Dict[str, int]) -> None:
- # TODO handle all power level changes and bridge exact admin rights to supergroups/channels
- for user, level in new_users.items():
- if not user or user == self.main_intent.mxid or user == sender.mxid:
- continue
- user_id = p.Puppet.get_id_from_mxid(user)
- if not user_id:
- mx_user = u.User.get_by_mxid(user, create=False)
- if not mx_user or not mx_user.tgid:
- continue
- user_id = mx_user.tgid
- if not user_id or user_id == sender.tgid:
- continue
- if user not in old_users or level != old_users[user]:
- await self._update_telegram_power_level(sender, user_id, level)
-
- async def handle_matrix_about(self, sender: 'u.User', about: str) -> None:
- if self.peer_type not in ("chat", "channel"):
- return
- peer = await self.get_input_entity(sender)
- await sender.client(EditChatAboutRequest(peer=peer, about=about))
- self.about = about
- self.save()
-
- async def handle_matrix_title(self, sender: 'u.User', title: str) -> None:
- if self.peer_type not in ("chat", "channel"):
- return
-
- if self.peer_type == "chat":
- response = await sender.client(EditChatTitleRequest(chat_id=self.tgid, title=title))
- else:
- channel = await self.get_input_entity(sender)
- response = await sender.client(EditTitleRequest(channel=channel, title=title))
- self._register_outgoing_actions_for_dedup(response)
- self.title = title
- self.save()
-
- async def handle_matrix_avatar(self, sender: 'u.User', url: str) -> None:
- if self.peer_type not in ("chat", "channel"):
- # Invalid peer type
- return
-
- file = await self.main_intent.download_file(url)
- mime = magic.from_buffer(file, mime=True)
- ext = sane_mimetypes.guess_extension(mime)
- uploaded = await sender.client.upload_file(file, file_name=f"avatar{ext}", use_cache=False)
- photo = InputChatUploadedPhoto(file=uploaded)
-
- if self.peer_type == "chat":
- response = await sender.client(EditChatPhotoRequest(chat_id=self.tgid, photo=photo))
- else:
- channel = await self.get_input_entity(sender)
- response = await sender.client(EditPhotoRequest(channel=channel, photo=photo))
- self._register_outgoing_actions_for_dedup(response)
- for update in response.updates:
- is_photo_update = (isinstance(update, UpdateNewMessage)
- and isinstance(update.message, MessageService)
- and isinstance(update.message.action, MessageActionChatEditPhoto))
- if is_photo_update:
- loc, size = self._get_largest_photo_size(update.message.action.photo)
- self.photo_id = f"{size.location.volume_id}-{size.location.local_id}"
- self.save()
- break
-
- async def handle_matrix_upgrade(self, new_room: MatrixRoomID) -> None:
- old_room = self.mxid
- self.migrate_and_save_matrix(new_room)
- await self.main_intent.join_room(new_room)
- entity = None # type: TypeInputPeer
- user = None # type: AbstractUser
- if self.bot and self.has_bot:
- user = self.bot
- entity = await self.get_input_entity(self.bot)
- if not entity:
- user_mxids = await self.main_intent.get_room_members(self.mxid)
- for user_str in user_mxids:
- user_id = MatrixUserID(user_str)
- if user_id == self.az.bot_mxid:
- continue
- user = u.User.get_by_mxid(user_id, create=False)
- if user and user.tgid:
- entity = await self.get_input_entity(user)
- if entity:
- break
- if not entity:
- self.log.error(
- "Failed to fully migrate to upgraded Matrix room: no Telegram user found.")
- return
- users, participants = await self._get_users(self.bot, entity)
- await self.sync_telegram_users(user, users)
- levels = await self.main_intent.get_power_levels(self.mxid)
- await self.update_telegram_participants(participants, levels)
- self.log.info(f"Upgraded room from {old_room} to {self.mxid}")
-
- def _register_outgoing_actions_for_dedup(self, response: TypeUpdates) -> None:
- for update in response.updates:
- check_dedup = (isinstance(update, (UpdateNewMessage, UpdateNewChannelMessage))
- and isinstance(update.message, MessageService))
- if check_dedup:
- self.is_duplicate_action(update.message)
-
- # endregion
- # region Telegram chat info updating
-
- async def _get_telegram_users_in_matrix_room(self) -> List[TelegramID]:
- user_tgids = set()
- user_mxids = await self.main_intent.get_room_members(self.mxid, ("join", "invite"))
- for user_str in user_mxids:
- user = MatrixUserID(user_str)
- if user == self.az.bot_mxid:
- continue
- mx_user = u.User.get_by_mxid(user, create=False)
- if mx_user and mx_user.tgid:
- user_tgids.add(mx_user.tgid)
- puppet_id = p.Puppet.get_id_from_mxid(user)
- if puppet_id:
- user_tgids.add(puppet_id)
- return list(user_tgids)
-
- async def upgrade_telegram_chat(self, source: 'u.User') -> None:
- if self.peer_type != "chat":
- raise ValueError("Only normal group chats are upgradable to supergroups.")
-
- response = await source.client(MigrateChatRequest(chat_id=self.tgid))
- entity = None
- for chat in response.chats:
- if isinstance(chat, Channel):
- entity = chat
- break
- if not entity:
- raise ValueError("Upgrade may have failed: output channel not found.")
- self.peer_type = "channel"
- self.migrate_and_save_telegram(TelegramID(entity.id))
- await self.update_info(source, entity)
-
- async def set_telegram_username(self, source: 'u.User', username: str) -> None:
- if self.peer_type != "channel":
- raise ValueError("Only channels and supergroups have usernames.")
- await source.client(
- UpdateUsernameRequest(await self.get_input_entity(source), username))
- if await self.update_username(username):
- self.save()
-
- async def create_telegram_chat(self, source: 'u.User', supergroup: bool = False) -> None:
- if not self.mxid:
- raise ValueError("Can't create Telegram chat for portal without Matrix room.")
- elif self.tgid:
- raise ValueError("Can't create Telegram chat for portal with existing Telegram chat.")
-
- invites = await self._get_telegram_users_in_matrix_room()
- if len(invites) < 2:
- if self.bot is not None:
- info, mxid = await self.bot.get_me()
- raise ValueError("Not enough Telegram users to create a chat. "
- "Invite more Telegram ghost users to the room, such as the "
- f"relaybot ([{info.first_name}](https://matrix.to/#/{mxid})).")
- raise ValueError("Not enough Telegram users to create a chat. "
- "Invite more Telegram ghost users to the room.")
- if self.peer_type == "chat":
- response = await source.client(CreateChatRequest(title=self.title, users=invites))
- entity = response.chats[0]
- elif self.peer_type == "channel":
- response = await source.client(CreateChannelRequest(title=self.title,
- about=self.about or "",
- megagroup=supergroup))
- entity = response.chats[0]
- await source.client(InviteToChannelRequest(
- channel=await source.client.get_input_entity(entity),
- users=invites))
- else:
- raise ValueError("Invalid peer type for Telegram chat creation")
-
- self.tgid = entity.id
- self.tg_receiver = self.tgid
- self.by_tgid[self.tgid_full] = self
- await self.update_info(source, entity)
- self.db_instance.insert()
- self.log = self.base_log.getChild(str(self.tgid))
-
- if self.bot and self.bot.tgid in invites:
- self.bot.add_chat(self.tgid, self.peer_type)
-
- levels = await self.main_intent.get_power_levels(self.mxid)
- bot_level = self._get_bot_level(levels)
- if bot_level == 100:
- levels = self._get_base_power_levels(levels, entity)
- await self.main_intent.set_power_levels(self.mxid, levels)
- await self.handle_matrix_power_levels(source, levels["users"], {})
-
- async def invite_telegram(self, source: 'u.User',
- puppet: Union[p.Puppet, 'AbstractUser']) -> None:
- if self.peer_type == "chat":
- await source.client(
- AddChatUserRequest(chat_id=self.tgid, user_id=puppet.tgid, fwd_limit=0))
- elif self.peer_type == "channel":
- await source.client(InviteToChannelRequest(channel=self.peer, users=[puppet.tgid]))
- else:
- raise ValueError("Invalid peer type for Telegram user invite")
-
- # endregion
- # region Telegram event handling
-
- async def handle_telegram_typing(self, user: p.Puppet,
- _: Union[UpdateUserTyping, UpdateChatUserTyping]) -> None:
- await user.intent.set_typing(self.mxid, is_typing=True)
-
- def get_external_url(self, evt: Message) -> Optional[str]:
- if self.peer_type == "channel" and self.username is not None:
- return f"https://t.me/{self.username}/{evt.id}"
- elif self.peer_type != "user":
- return f"https://t.me/c/{self.tgid}/{evt.id}"
- return None
-
- async def handle_telegram_photo(self, source: 'AbstractUser', intent: IntentAPI, evt: Message,
- relates_to: Dict = None) -> Optional[Dict]:
- loc, largest_size = self._get_largest_photo_size(evt.media.photo)
- file = await util.transfer_file_to_matrix(source.client, intent, loc)
- if not file:
- return None
- if self.get_config("inline_images") and (evt.message
- or evt.fwd_from or evt.reply_to_msg_id):
- text, html, relates_to = await formatter.telegram_to_matrix(
- evt, source, self.main_intent,
- prefix_html=f"
",
- prefix_text="Inline image: ")
- await intent.set_typing(self.mxid, is_typing=False)
- return await intent.send_text(self.mxid, text, html=html, relates_to=relates_to,
- timestamp=evt.date,
- external_url=self.get_external_url(evt))
- info = {
- "h": largest_size.h,
- "w": largest_size.w,
- "size": len(largest_size.bytes) if (
- isinstance(largest_size, PhotoCachedSize)) else largest_size.size,
- "orientation": 0,
- "mimetype": file.mime_type,
- }
- name = f"image{sane_mimetypes.guess_extension(file.mime_type)}"
- await intent.set_typing(self.mxid, is_typing=False)
- result = await intent.send_image(self.mxid, file.mxc, info=info, text=name,
- relates_to=relates_to, timestamp=evt.date,
- external_url=self.get_external_url(evt))
- if evt.message:
- text, html, _ = await formatter.telegram_to_matrix(evt, source, self.main_intent,
- no_reply_fallback=True)
- result = await intent.send_text(self.mxid, text, html=html, timestamp=evt.date,
- external_url=self.get_external_url(evt))
- return result
-
- @staticmethod
- def _parse_telegram_document_attributes(attributes: List[TypeDocumentAttribute]) -> Dict:
- attrs = {
- "name": None,
- "mime_type": None,
- "is_sticker": False,
- "sticker_alt": None,
- "width": None,
- "height": None,
- } # type: Dict
- for attr in attributes:
- if isinstance(attr, DocumentAttributeFilename):
- attrs["name"] = attrs["name"] or attr.file_name
- attrs["mime_type"], _ = mimetypes.guess_type(attr.file_name)
- elif isinstance(attr, DocumentAttributeSticker):
- attrs["is_sticker"] = True
- attrs["sticker_alt"] = attr.alt
- elif isinstance(attr, DocumentAttributeVideo):
- attrs["width"], attrs["height"] = attr.w, attr.h
- return attrs
-
- @staticmethod
- def _parse_telegram_document_meta(evt: Message, file: DBTelegramFile, attrs: Dict,
- thumb_size: TypePhotoSize) -> Tuple[Dict, str]:
- document = evt.media.document
- name = evt.message or attrs["name"]
- if attrs["is_sticker"]:
- alt = attrs["sticker_alt"]
- if len(alt) > 0:
- try:
- name = f"{alt} ({unicodedata.name(alt[0]).lower()})"
- except ValueError:
- name = alt
-
- generic_types = ("text/plain", "application/octet-stream")
- if file.mime_type in generic_types and document.mime_type not in generic_types:
- mime_type = document.mime_type or file.mime_type
- else:
- mime_type = file.mime_type or document.mime_type
- info = {
- "size": file.size,
- "mimetype": mime_type,
- }
-
- if attrs["mime_type"] and not file.was_converted:
- file.mime_type = attrs["mime_type"] or file.mime_type
- if file.width and file.height:
- info["w"], info["h"] = file.width, file.height
- elif attrs["width"] and attrs["height"]:
- info["w"], info["h"] = attrs["width"], attrs["height"]
-
- if file.thumbnail:
- info["thumbnail_url"] = file.thumbnail.mxc
- info["thumbnail_info"] = {
- "mimetype": file.thumbnail.mime_type,
- "h": file.thumbnail.height or thumb_size.h,
- "w": file.thumbnail.width or thumb_size.w,
- "size": file.thumbnail.size,
- }
-
- return info, name
-
- async def handle_telegram_document(self, source: 'AbstractUser', intent: IntentAPI,
- evt: Message, relates_to: dict = None) -> Optional[Dict]:
- document = evt.media.document
-
- attrs = self._parse_telegram_document_attributes(document.attributes)
-
- if document.size > config["bridge.max_document_size"] * 1000 ** 2:
- name = attrs["name"] or ""
- caption = f"\n{evt.message}" if evt.message else ""
- return await intent.send_notice(self.mxid, f"Too large file {name}{caption}")
-
- thumb_loc, thumb_size = self._get_largest_photo_size(document)
- if thumb_size and not isinstance(thumb_size, (PhotoSize, PhotoCachedSize)):
- self.log.debug(f"Unsupported thumbnail type {type(thumb_size)}")
- thumb_loc = None
- thumb_size = None
- file = await util.transfer_file_to_matrix(source.client, intent, document, thumb_loc,
- is_sticker=attrs["is_sticker"])
- if not file:
- return None
-
- info, name = self._parse_telegram_document_meta(evt, file, attrs, thumb_size)
-
- await intent.set_typing(self.mxid, is_typing=False)
-
- kwargs = {
- "room_id": self.mxid,
- "url": file.mxc,
- "info": info,
- "text": name,
- "relates_to": relates_to,
- "timestamp": evt.date,
- "external_url": self.get_external_url(evt)
- }
-
- if attrs["is_sticker"]:
- return await intent.send_sticker(**kwargs)
-
- mime_type = info["mimetype"]
- if mime_type.startswith("video/"):
- kwargs["file_type"] = "m.video"
- elif mime_type.startswith("audio/"):
- kwargs["file_type"] = "m.audio"
- elif mime_type.startswith("image/"):
- kwargs["file_type"] = "m.image"
- else:
- kwargs["file_type"] = "m.file"
- return await intent.send_file(**kwargs)
-
- def handle_telegram_location(self, _: 'AbstractUser', intent: IntentAPI, evt: Message,
- relates_to: dict = None) -> Awaitable[dict]:
- location = evt.media.geo
- long = location.long
- lat = location.lat
- long_char = "E" if long > 0 else "W"
- lat_char = "N" if lat > 0 else "S"
- rounded_long = round(long, 5)
- rounded_lat = round(lat, 5)
-
- body = f"{rounded_lat}° {lat_char}, {rounded_long}° {long_char}"
-
- url = f"https://maps.google.com/?q={lat},{long}"
-
- formatted_body = f"Location: {body}"
- # At least riot-web ignores formatting in m.location messages,
- # so we'll add a plaintext link.
- body = f"Location: {body}\n{url}"
-
- return intent.send_message(self.mxid, {
- "msgtype": "m.location",
- "geo_uri": f"geo:{lat},{long}",
- "body": body,
- "format": "org.matrix.custom.html",
- "formatted_body": formatted_body,
- "m.relates_to": relates_to or None,
- }, timestamp=evt.date, external_url=self.get_external_url(evt))
-
- async def handle_telegram_text(self, source: 'AbstractUser', intent: IntentAPI, is_bot: bool,
- evt: Message) -> dict:
- self.log.debug(f"Sending {evt.message} to {self.mxid} by {intent.mxid}")
- text, html, relates_to = await formatter.telegram_to_matrix(evt, source, self.main_intent)
- await intent.set_typing(self.mxid, is_typing=False)
- msgtype = "m.notice" if is_bot and self.get_config("bot_messages_as_notices") else "m.text"
- return await intent.send_text(self.mxid, text, html=html, relates_to=relates_to,
- msgtype=msgtype, timestamp=evt.date,
- external_url=self.get_external_url(evt))
-
- async def handle_telegram_unsupported(self, source: 'AbstractUser', intent: IntentAPI,
- evt: Message, relates_to: dict = None) -> dict:
- override_text = ("This message is not supported on your version of Mautrix-Telegram. "
- "Please check https://github.com/tulir/mautrix-telegram or ask your "
- "bridge administrator about possible updates.")
- text, html, relates_to = await formatter.telegram_to_matrix(
- evt, source, self.main_intent, override_text=override_text)
- await intent.set_typing(self.mxid, is_typing=False)
- return await intent.send_message(self.mxid, {
- "body": text,
- "msgtype": "m.notice",
- "format": "org.matrix.custom.html",
- "formatted_body": html,
- "m.relates_to": relates_to,
- "net.maunium.telegram.unsupported": True,
- }, timestamp=evt.date, external_url=self.get_external_url(evt))
-
- async def handle_telegram_poll(self, source: 'AbstractUser', intent: IntentAPI, evt: Message,
- relates_to: dict) -> dict:
- poll = evt.media.poll # type: Poll
- poll_id = self._encode_msgid(source, evt)
-
- _n = 0
-
- def n() -> int:
- nonlocal _n
- _n += 1
- return _n
-
- text = (f"Poll: {poll.question}\n"
- + "\n".join(f"{n()}. {answer.text}" for answer in poll.answers) +
- "\n"
- f"Vote with !tg vote {poll_id} ")
-
- html = (f"Poll: {poll.question}
\n"
- f""
- + "\n".join(f"- {answer.text}
"
- for answer in poll.answers) +
- "
\n"
- f"Vote with !tg vote {poll_id} <choice number>")
- await intent.set_typing(self.mxid, is_typing=False)
- return await intent.send_text(self.mxid, text, html=html, relates_to=relates_to,
- msgtype="m.text", timestamp=evt.date,
- external_url=self.get_external_url(evt))
-
- @staticmethod
- def _int_to_bytes(i: int) -> bytes:
- hex_value = "{0:010x}".format(i)
- return codecs.decode(hex_value, "hex_codec")
-
- def _encode_msgid(self, source: 'AbstractUser', evt: Message) -> str:
- if self.peer_type == "channel":
- play_id = (b"c"
- + self._int_to_bytes(self.tgid)
- + self._int_to_bytes(evt.id))
- elif self.peer_type == "chat":
- play_id = (b"g"
- + self._int_to_bytes(self.tgid)
- + self._int_to_bytes(evt.id)
- + self._int_to_bytes(source.tgid))
- elif self.peer_type == "user":
- play_id = (b"u"
- + self._int_to_bytes(self.tgid)
- + self._int_to_bytes(evt.id))
- else:
- raise ValueError("Portal has invalid peer type")
- return base64.b64encode(play_id).decode("utf-8").rstrip("=")
-
- async def handle_telegram_game(self, source: 'AbstractUser', intent: IntentAPI,
- evt: Message, relates_to: dict = None):
- game = evt.media.game
- play_id = self._encode_msgid(source, evt)
- command = f"!tg play {play_id}"
- override_text = f"Run {command} in your bridge management room to play {game.title}"
- override_entities = [
- MessageEntityPre(offset=len("Run "), length=len(command), language="")]
- text, html, relates_to = await formatter.telegram_to_matrix(
- evt, source, self.main_intent,
- override_text=override_text, override_entities=override_entities)
- await intent.set_typing(self.mxid, is_typing=False)
- return await intent.send_message(self.mxid, {
- "body": text,
- "msgtype": "m.notice",
- "format": "org.matrix.custom.html",
- "formatted_body": html,
- "m.relates_to": relates_to,
- "net.maunium.telegram.game": play_id,
- }, timestamp=evt.date, external_url=self.get_external_url(evt))
-
- async def handle_telegram_edit(self, source: 'AbstractUser', sender: p.Puppet,
- evt: Message) -> None:
- if not self.mxid:
- return
- elif hasattr(evt, "media") and isinstance(evt.media, (MessageMediaGame,)):
- self.log.debug("Ignoring game message edit event")
- return
-
- lock = self.optional_send_lock(sender.tgid if sender else None)
- if lock:
- async with lock:
- pass
-
- tg_space = self.tgid if self.peer_type == "channel" else source.tgid
-
- temporary_identifier = MatrixEventID(
- f"${random.randint(1000000000000, 9999999999999)}TGBRIDGEDITEMP")
- duplicate_found = self.is_duplicate(evt, (temporary_identifier, tg_space), force_hash=True)
- if duplicate_found:
- mxid, other_tg_space = duplicate_found
- if tg_space != other_tg_space:
- prev_edit_msg = DBMessage.get_one_by_tgid(TelegramID(evt.id), tg_space, -1)
- if not prev_edit_msg:
- return
- DBMessage(mxid=mxid, mx_room=self.mxid, tg_space=tg_space, tgid=evt.id,
- edit_index=prev_edit_msg.edit_index + 1).insert()
- return
-
- text, html, _ = await formatter.telegram_to_matrix(evt, source, self.main_intent)
- editing_msg = DBMessage.get_one_by_tgid(TelegramID(evt.id), tg_space)
- if not editing_msg:
- self.log.info(f"Didn't find edited message {evt.id}@{tg_space} (src {source.tgid}) "
- "in database.")
- return
-
- msgtype = ("m.notice"
- if sender and sender.is_bot and self.get_config("bot_messages_as_notices")
- else "m.text")
- content = {
- "body": f"Edit: {text}",
- "msgtype": msgtype,
- "format": "org.matrix.custom.html",
- "formatted_body": (f"Edit: "
- f"{html or escape_html(text)}"),
- "external_url": self.get_external_url(evt),
- "m.new_content": {
- "body": text,
- "msgtype": "m.text",
- **({"format": "org.matrix.custom.html",
- "formatted_body": html} if html else {}),
- },
- "m.relates_to": {
- "rel_type": "m.replace",
- "event_id": editing_msg.mxid,
- },
- }
-
- intent = sender.intent if sender else self.main_intent
- await intent.set_typing(self.mxid, is_typing=False)
- response = await intent.send_message(self.mxid, content)
- mxid = response["event_id"]
-
- prev_edit_msg = DBMessage.get_one_by_tgid(TelegramID(evt.id), tg_space, -1) or editing_msg
- DBMessage(mxid=mxid, mx_room=self.mxid, tg_space=tg_space, tgid=evt.id,
- edit_index=prev_edit_msg.edit_index + 1).insert()
- DBMessage.update_by_mxid(temporary_identifier, self.mxid, mxid=mxid)
-
- async def handle_telegram_message(self, source: 'AbstractUser', sender: p.Puppet,
- evt: Message) -> None:
- if not self.mxid:
- await self.create_matrix_room(source, invites=[source.mxid], update_if_exists=False)
-
- lock = self.optional_send_lock(sender.tgid if sender else None)
- if lock:
- async with lock:
- pass
-
- tg_space = self.tgid if self.peer_type == "channel" else source.tgid
-
- temporary_identifier = MatrixEventID(
- f"${random.randint(1000000000000, 9999999999999)}TGBRIDGETEMP")
- duplicate_found = self.is_duplicate(evt, (temporary_identifier, tg_space))
- if duplicate_found:
- mxid, other_tg_space = duplicate_found
- self.log.debug(f"Ignoring message {evt.id}@{tg_space} (src {source.tgid}) "
- f"as it was already handled (in space {other_tg_space})")
- if tg_space != other_tg_space:
- DBMessage(tgid=TelegramID(evt.id), mx_room=self.mxid, mxid=mxid,
- tg_space=tg_space, edit_index=0).insert()
- return
-
- if self.dedup_pre_db_check and self.peer_type == "channel":
- msg = DBMessage.get_one_by_tgid(TelegramID(evt.id), tg_space)
- if msg:
- self.log.debug(f"Ignoring message {evt.id} (src {source.tgid}) as it was already"
- f"handled into {msg.mxid}. This duplicate was catched in the db "
- "check. If you get this message often, consider increasing"
- "bridge.deduplication.cache_queue_length in the config.")
- return
-
- if sender and not sender.displayname:
- self.log.debug(f"Telegram user {sender.tgid} sent a message, but doesn't have a "
- "displayname, updating info...")
- entity = await source.client.get_entity(PeerUser(sender.tgid))
- await sender.update_info(source, entity)
-
- allowed_media = (MessageMediaPhoto, MessageMediaDocument, MessageMediaGeo,
- MessageMediaGame, MessageMediaPoll, MessageMediaUnsupported)
- media = evt.media if hasattr(evt, "media") and isinstance(evt.media,
- allowed_media) else None
- intent = sender.intent if sender else self.main_intent
- if not media and evt.message:
- is_bot = sender.is_bot if sender else False
- response = await self.handle_telegram_text(source, intent, is_bot, evt)
- elif media:
- response = await {
- MessageMediaPhoto: self.handle_telegram_photo,
- MessageMediaDocument: self.handle_telegram_document,
- MessageMediaGeo: self.handle_telegram_location,
- MessageMediaPoll: self.handle_telegram_poll,
- MessageMediaUnsupported: self.handle_telegram_unsupported,
- MessageMediaGame: self.handle_telegram_game,
- }[type(media)](source, intent, evt,
- relates_to=formatter.telegram_reply_to_matrix(evt, source))
- else:
- self.log.debug("Unhandled Telegram message: %s", evt)
- return
-
- if not response:
- return
-
- mxid = response["event_id"]
-
- prev_id = self.update_duplicate(evt, (mxid, tg_space), (temporary_identifier, tg_space))
- if prev_id:
- self.log.debug(f"Sent message {evt.id}@{tg_space} to Matrix as {mxid}. "
- f"Temporary dedup identifier was {temporary_identifier}, "
- f"but dedup map contained {prev_id[1]} instead! -- "
- "This was probably a race condition caused by Telegram sending updates"
- "to other clients before responding to the sender. I'll just redact "
- "the likely duplicate message now.")
- await intent.redact(self.mxid, mxid)
- return
-
- self.log.debug("Handled Telegram message: %s", evt)
- try:
- DBMessage(tgid=TelegramID(evt.id), mx_room=self.mxid, mxid=mxid,
- tg_space=tg_space, edit_index=0).insert()
- DBMessage.update_by_mxid(temporary_identifier, self.mxid, mxid=mxid)
- except IntegrityError as e:
- self.log.exception(f"{e.__class__.__name__} while saving message mapping. "
- "This might mean that an update was handled after it left the "
- "dedup cache queue. You can try enabling bridge.deduplication."
- "pre_db_check in the config.")
- await intent.redact(self.mxid, mxid)
-
- async def _create_room_on_action(self, source: 'AbstractUser',
- action: TypeMessageAction) -> bool:
- if source.is_relaybot:
- return False
- create_and_exit = (MessageActionChatCreate, MessageActionChannelCreate)
- create_and_continue = (MessageActionChatAddUser, MessageActionChatJoinedByLink)
- if isinstance(action, create_and_exit) or isinstance(action, create_and_continue):
- await self.create_matrix_room(source, invites=[source.mxid],
- update_if_exists=isinstance(action, create_and_exit))
- if not isinstance(action, create_and_continue):
- return False
- return True
-
- async def handle_telegram_action(self, source: 'AbstractUser', sender: p.Puppet,
- update: MessageService) -> None:
- action = update.action
- should_ignore = ((not self.mxid and not await self._create_room_on_action(source, action))
- or self.is_duplicate_action(update))
- if should_ignore or not self.mxid:
- return
- # TODO figure out how to see changes to about text / channel username
- if isinstance(action, MessageActionChatEditTitle):
- await self.update_title(action.title, save=True)
- elif isinstance(action, MessageActionChatEditPhoto):
- await self.update_avatar(source, action.photo, save=True)
- elif isinstance(action, MessageActionChatDeletePhoto):
- await self.remove_avatar(source, save=True)
- elif isinstance(action, MessageActionChatAddUser):
- for user_id in action.users:
- await self.add_telegram_user(TelegramID(user_id), source)
- elif isinstance(action, MessageActionChatJoinedByLink):
- await self.add_telegram_user(sender.id, source)
- elif isinstance(action, MessageActionChatDeleteUser):
- await self.delete_telegram_user(TelegramID(action.user_id), sender)
- elif isinstance(action, MessageActionChatMigrateTo):
- self.peer_type = "channel"
- self.migrate_and_save_telegram(TelegramID(action.channel_id))
- await sender.intent.send_emote(self.mxid, "upgraded this group to a supergroup.")
- elif isinstance(action, MessageActionPinMessage):
- await self.receive_telegram_pin_sender(sender)
- elif isinstance(action, MessageActionGameScore):
- # TODO handle game score
- pass
- else:
- self.log.debug("Unhandled Telegram action in %s: %s", self.title, action)
-
- async def set_telegram_admin(self, user_id: TelegramID) -> None:
- puppet = p.Puppet.get(user_id)
- user = u.User.get_by_tgid(user_id)
-
- levels = await self.main_intent.get_power_levels(self.mxid)
- if user:
- levels["users"][user.mxid] = 50
- if puppet:
- levels["users"][puppet.mxid] = 50
- await self.main_intent.set_power_levels(self.mxid, levels)
-
- async def receive_telegram_pin_sender(self, sender: p.Puppet) -> None:
- self._temp_pinned_message_sender = sender
- if self._temp_pinned_message_id:
- await self.update_telegram_pin()
-
- async def update_telegram_pin(self) -> None:
- intent = (self._temp_pinned_message_sender.intent
- if self._temp_pinned_message_sender else self.main_intent)
- msg_id = self._temp_pinned_message_id
- self._temp_pinned_message_id = None
- self._temp_pinned_message_sender = None
-
- message = DBMessage.get_one_by_tgid(msg_id, self._temp_pinned_message_id_space)
- if message:
- await intent.set_pinned_messages(self.mxid, [message.mxid])
- else:
- await intent.set_pinned_messages(self.mxid, [])
-
- async def receive_telegram_pin_id(self, msg_id: int, receiver: TelegramID) -> None:
- if msg_id == 0:
- return await self.update_telegram_pin()
- self._temp_pinned_message_id = msg_id
- self._temp_pinned_message_id_space = receiver if self.peer_type != "channel" else self.tgid
- if self._temp_pinned_message_sender:
- await self.update_telegram_pin()
-
- @staticmethod
- def _get_level_from_participant(participant: TypeParticipant, _: Dict) -> int:
- # TODO use the power level requirements to get better precision in channels
- if isinstance(participant, (ChatParticipantAdmin, ChannelParticipantAdmin)):
- return 50
- elif isinstance(participant, (ChatParticipantCreator, ChannelParticipantCreator)):
- return 95
- return 0
-
- @staticmethod
- def _participant_to_power_levels(levels: dict, user: Union['u.User', p.Puppet], new_level: int,
- bot_level: int) -> bool:
- new_level = min(new_level, bot_level)
- default_level = levels["users_default"] if "users_default" in levels else 0
- try:
- user_level = int(levels["users"][user.mxid])
- except (ValueError, KeyError):
- user_level = default_level
- if user_level != new_level and user_level < bot_level:
- levels["users"][user.mxid] = new_level
- return True
- return False
-
- def _get_bot_level(self, levels: dict) -> int:
- try:
- return levels["users"][self.main_intent.mxid]
- except KeyError:
- try:
- return levels["users_default"]
- except KeyError:
- return 0
-
- @staticmethod
- def _get_powerlevel_level(levels: dict) -> int:
- try:
- return levels["events"]["m.room.power_levels"]
- except KeyError:
- try:
- return levels["state_default"]
- except KeyError:
- return 50
-
- def _participants_to_power_levels(self, participants: List[TypeParticipant], levels: Dict
- ) -> bool:
- bot_level = self._get_bot_level(levels)
- if bot_level < self._get_powerlevel_level(levels):
- return False
- changed = False
- admin_power_level = min(75 if self.peer_type == "channel" else 50, bot_level)
- if levels["events"]["m.room.power_levels"] != admin_power_level:
- changed = True
- levels["events"]["m.room.power_levels"] = admin_power_level
-
- for participant in participants:
- puppet = p.Puppet.get(TelegramID(participant.user_id))
- user = u.User.get_by_tgid(TelegramID(participant.user_id))
- new_level = self._get_level_from_participant(participant, levels)
-
- if user:
- user.register_portal(self)
- changed = self._participant_to_power_levels(levels, user, new_level,
- bot_level) or changed
-
- if puppet:
- changed = self._participant_to_power_levels(levels, puppet, new_level,
- bot_level) or changed
- return changed
-
- async def update_telegram_participants(self, participants: List[TypeParticipant],
- levels: dict = None) -> None:
- if not levels:
- levels = await self.main_intent.get_power_levels(self.mxid)
- if self._participants_to_power_levels(participants, levels):
- await self.main_intent.set_power_levels(self.mxid, levels)
-
- async def set_telegram_admins_enabled(self, enabled: bool) -> None:
- level = 50 if enabled else 10
- levels = await self.main_intent.get_power_levels(self.mxid)
- levels["invite"] = level
- levels["events"]["m.room.name"] = level
- levels["events"]["m.room.avatar"] = level
- await self.main_intent.set_power_levels(self.mxid, levels)
-
- # endregion
- # region Database conversion
-
- @property
- def db_instance(self) -> DBPortal:
- if not self._db_instance:
- self._db_instance = self.new_db_instance()
- return self._db_instance
-
- def new_db_instance(self) -> DBPortal:
- return DBPortal(tgid=self.tgid, tg_receiver=self.tg_receiver, peer_type=self.peer_type,
- mxid=self.mxid, username=self.username, megagroup=self.megagroup,
- title=self.title, about=self.about, photo_id=self.photo_id,
- config=json.dumps(self.local_config))
-
- def migrate_and_save_telegram(self, new_id: TelegramID) -> None:
- try:
- del self.by_tgid[self.tgid_full]
- except KeyError:
- pass
- try:
- existing = self.by_tgid[(new_id, new_id)]
- existing.delete()
- except KeyError:
- pass
- self.db_instance.update(tgid=new_id, tg_receiver=new_id, peer_type=self.peer_type)
- old_id = self.tgid
- self.tgid = new_id
- self.tg_receiver = new_id
- self.by_tgid[self.tgid_full] = self
- self.log = self.base_log.getChild(str(self.tgid))
- self.log.info(f"Telegram chat upgraded from {old_id}")
-
- def migrate_and_save_matrix(self, new_id: MatrixRoomID) -> None:
- try:
- del self.by_mxid[self.mxid]
- except KeyError:
- pass
- self.mxid = new_id
- self.db_instance.update(mxid=self.mxid)
- self.by_mxid[self.mxid] = self
-
- def save(self) -> None:
- self.db_instance.update(mxid=self.mxid, username=self.username, title=self.title,
- about=self.about, photo_id=self.photo_id,
- config=json.dumps(self.local_config))
-
- def delete(self) -> None:
- try:
- del self.by_tgid[self.tgid_full]
- except KeyError:
- pass
- try:
- del self.by_mxid[self.mxid]
- except KeyError:
- pass
- if self._db_instance:
- self._db_instance.delete()
- self.deleted = True
-
- @classmethod
- def from_db(cls, db_portal: DBPortal) -> 'Portal':
- return Portal(tgid=db_portal.tgid, tg_receiver=db_portal.tg_receiver,
- peer_type=db_portal.peer_type, mxid=db_portal.mxid,
- username=db_portal.username, megagroup=db_portal.megagroup,
- title=db_portal.title, about=db_portal.about, photo_id=db_portal.photo_id,
- local_config=db_portal.config, db_instance=db_portal)
-
- # endregion
- # region Class instance lookup
-
- @classmethod
- def get_by_mxid(cls, mxid: MatrixRoomID) -> Optional['Portal']:
- try:
- return cls.by_mxid[mxid]
- except KeyError:
- pass
-
- portal = DBPortal.get_by_mxid(mxid)
- if portal:
- return cls.from_db(portal)
-
- return None
-
- @classmethod
- def get_username_from_mx_alias(cls, alias: str) -> Optional[str]:
- match = cls.mx_alias_regex.match(alias)
- if match:
- return match.group(1)
- return None
-
- @classmethod
- def find_by_username(cls, username: str) -> Optional['Portal']:
- if not username:
- return None
-
- for _, portal in cls.by_tgid.items():
- if portal.username and portal.username.lower() == username.lower():
- return portal
-
- dbportal = DBPortal.get_by_username(username)
- if dbportal:
- return cls.from_db(dbportal)
-
- return None
-
- @classmethod
- def get_by_tgid(cls, tgid: TelegramID, tg_receiver: Optional[TelegramID] = None,
- peer_type: str = None) -> Optional['Portal']:
- tg_receiver = tg_receiver or tgid
- tgid_full = (tgid, tg_receiver)
- try:
- return cls.by_tgid[tgid_full]
- except KeyError:
- pass
-
- db_portal = DBPortal.get_by_tgid(tgid, tg_receiver)
- if db_portal:
- return cls.from_db(db_portal)
-
- if peer_type:
- portal = Portal(tgid, peer_type=peer_type, tg_receiver=tg_receiver)
- portal.db_instance.insert()
- return portal
-
- return None
-
- @classmethod
- def get_by_entity(cls, entity: Union[TypeChat, TypePeer, TypeUser, TypeUserFull,
- TypeInputPeer],
- receiver_id: Optional[TelegramID] = None, create: bool = True
- ) -> Optional['Portal']:
- entity_type = type(entity)
- if entity_type in {Chat, ChatFull}:
- type_name = "chat"
- entity_id = entity.id
- elif entity_type in {PeerChat, InputPeerChat}:
- type_name = "chat"
- entity_id = entity.chat_id
- elif entity_type in {Channel, ChannelFull}:
- type_name = "channel"
- entity_id = entity.id
- elif entity_type in {PeerChannel, InputPeerChannel, InputChannel}:
- type_name = "channel"
- entity_id = entity.channel_id
- elif entity_type in {User, UserFull}:
- type_name = "user"
- entity_id = entity.id
- elif entity_type in {PeerUser, InputPeerUser, InputUser}:
- type_name = "user"
- entity_id = entity.user_id
- else:
- raise ValueError(f"Unknown entity type {entity_type.__name__}")
- return cls.get_by_tgid(TelegramID(entity_id),
- receiver_id if type_name == "user" else entity_id,
- type_name if create else None)
-
- # endregion
-
-
-def init(context: Context) -> None:
- global config
- Portal.az, config, Portal.loop, Portal.bot = context.core
- Portal.max_initial_member_sync = config["bridge.max_initial_member_sync"]
- Portal.sync_channel_members = config["bridge.sync_channel_members"]
- Portal.sync_matrix_state = config["bridge.sync_matrix_state"]
- Portal.public_portals = config["bridge.public_portals"]
- Portal.filter_mode = config["bridge.filter.mode"]
- Portal.filter_list = config["bridge.filter.list"]
- Portal.dedup_pre_db_check = config["bridge.deduplication.pre_db_check"]
- Portal.dedup_cache_queue_length = config["bridge.deduplication.cache_queue_length"]
- Portal.alias_template = config.get("bridge.alias_template", "telegram_{groupname}")
- Portal.hs_domain = config["homeserver.domain"]
- Portal.mx_alias_regex = re.compile(
- f"#{Portal.alias_template.format(groupname='(.+)')}:{Portal.hs_domain}")
diff --git a/mautrix_telegram/portal/__init__.py b/mautrix_telegram/portal/__init__.py
new file mode 100644
index 00000000..800f93d2
--- /dev/null
+++ b/mautrix_telegram/portal/__init__.py
@@ -0,0 +1,21 @@
+from .base import BasePortal, init as init_base
+from .matrix import PortalMatrix, init as init_matrix
+from .metadata import PortalMetadata, init as init_metadata
+from .telegram import PortalTelegram, init as init_telegram
+from .deduplication import init as init_dedup
+from ..context import Context
+
+
+class Portal(PortalMatrix, PortalTelegram, PortalMetadata):
+ pass
+
+
+def init(context: Context) -> None:
+ init_base(context)
+ init_dedup(context)
+ init_metadata(context)
+ init_telegram(context)
+ init_matrix(context)
+
+
+__all__ = ["Portal", "init"]
diff --git a/mautrix_telegram/portal/__init__.pyi b/mautrix_telegram/portal/__init__.pyi
new file mode 100644
index 00000000..f705bfc7
--- /dev/null
+++ b/mautrix_telegram/portal/__init__.pyi
@@ -0,0 +1,15 @@
+from typing import Union
+from .base import BasePortal
+from .portal_matrix import PortalMatrix
+from .portal_metadata import PortalMetadata
+from .portal_telegram import PortalTelegram
+from ..context import Context
+
+Portal = Union[BasePortal, PortalMatrix, PortalMetadata, PortalTelegram]
+
+
+def init(context: Context) -> None:
+ pass
+
+
+__all__ = ["Portal", "init"]
diff --git a/mautrix_telegram/portal/base.py b/mautrix_telegram/portal/base.py
new file mode 100644
index 00000000..fd4d3374
--- /dev/null
+++ b/mautrix_telegram/portal/base.py
@@ -0,0 +1,474 @@
+# mautrix-telegram - A Matrix-Telegram puppeting bridge
+# Copyright (C) 2019 Tulir Asokan
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see
")
+
+ tpl = (self.get_config(f"message_formats.[{content.msgtype.value}]")
+ or "$sender_displayname: $message")
+ displayname = await self.get_displayname(sender)
+ tpl_args = dict(sender_mxid=sender.mxid,
+ sender_username=sender.mxid_localpart,
+ sender_displayname=escape_html(displayname),
+ body=content.body)
+ if isinstance(content, TextMessageEventContent):
+ tpl_args["formatted_body"] = content.formatted_body
+ tpl_args["message"] = content.formatted_body
+ content.formatted_body = Template(tpl).safe_substitute(tpl_args)
+ else:
+ tpl_args["message"] = content.body
+ content.body = Template(tpl).safe_substitute(tpl_args)
+
+ async def _pre_process_matrix_message(self, sender: 'u.User', use_relaybot: bool,
+ content: MessageEventContent) -> None:
+ if content.msgtype == MessageType.EMOTE:
+ await self._apply_msg_format(sender, content)
+ content.msgtype = MessageType.TEXT
+ elif use_relaybot:
+ await self._apply_msg_format(sender, content)
+
+ @staticmethod
+ def _matrix_event_to_entities(event: Union[str, MessageEventContent]
+ ) -> Tuple[str, Optional[List[TypeMessageEntity]]]:
+ try:
+ if isinstance(event, str):
+ message, entities = formatter.matrix_to_telegram(event)
+ elif isinstance(event, TextMessageEventContent) and event.format == Format.HTML:
+ message, entities = formatter.matrix_to_telegram(event.formatted_body)
+ else:
+ message, entities = formatter.matrix_text_to_telegram(event.body)
+ except KeyError:
+ message, entities = None, None
+ return message, entities
+
+ async def _handle_matrix_text(self, sender_id: TelegramID, event_id: EventID,
+ space: TelegramID, client: 'MautrixTelegramClient',
+ content: TextMessageEventContent, reply_to: TelegramID) -> None:
+ async with self.send_lock(sender_id):
+ lp = self.get_config("telegram_link_preview")
+ if content.get_edit():
+ orig_msg = DBMessage.get_by_mxid(content.get_edit(), self.mxid, space)
+ if orig_msg:
+ response = await client.edit_message(self.peer, orig_msg.tgid, content,
+ parse_mode=self._matrix_event_to_entities,
+ link_preview=lp)
+ self._add_telegram_message_to_db(event_id, space, -1, response)
+ return
+ response = await client.send_message(self.peer, content, reply_to=reply_to,
+ parse_mode=self._matrix_event_to_entities,
+ link_preview=lp)
+ self._add_telegram_message_to_db(event_id, space, 0, response)
+
+ async def _handle_matrix_file(self, sender_id: TelegramID, event_id: EventID,
+ space: TelegramID, client: 'MautrixTelegramClient',
+ content: MediaMessageEventContent, reply_to: TelegramID) -> None:
+ file = await self.main_intent.download_media(content.url)
+
+ mime = content.info.mimetype
+
+ w, h = content.info.width, content.info.height
+
+ if content.msgtype == MessageType.STICKER:
+ if mime != "image/gif":
+ mime, file, w, h = util.convert_image(file, source_mime=mime, target_type="webp")
+ else:
+ # Remove sticker description
+ content["net.maunium.telegram.internal.filename"] = "sticker.gif"
+ content.body = ""
+
+ file_name = self._get_file_meta(content["net.maunium.telegram.internal.filename"], mime)
+ attributes = [DocumentAttributeFilename(file_name=file_name)]
+ if w and h:
+ attributes.append(DocumentAttributeImageSize(w, h))
+
+ caption = content.body if content.body.lower() != file_name.lower() else None
+
+ media = await client.upload_file_direct(
+ file, mime, attributes, file_name,
+ max_image_size=config["bridge.image_as_file_size"] * 1000 ** 2)
+ async with self.send_lock(sender_id):
+ if await self._matrix_document_edit(client, content, space, caption, media, event_id):
+ return
+ try:
+ response = await client.send_media(self.peer, media, reply_to=reply_to,
+ caption=caption)
+ except (PhotoInvalidDimensionsError, PhotoSaveFileInvalidError, PhotoExtInvalidError):
+ media = InputMediaUploadedDocument(file=media.file, mime_type=mime,
+ attributes=attributes)
+ response = await client.send_media(self.peer, media, reply_to=reply_to,
+ caption=caption)
+ self._add_telegram_message_to_db(event_id, space, 0, response)
+
+ async def _matrix_document_edit(self, client: 'MautrixTelegramClient',
+ content: MessageEventContent, space: TelegramID,
+ caption: str, media: Any, event_id: EventID) -> bool:
+ if content.get_edit():
+ orig_msg = DBMessage.get_by_mxid(content.get_edit(), self.mxid, space)
+ if orig_msg:
+ response = await client.edit_message(self.peer, orig_msg.tgid,
+ caption, file=media)
+ self._add_telegram_message_to_db(event_id, space, -1, response)
+ return True
+ return False
+
+ async def _handle_matrix_location(self, sender_id: TelegramID, event_id: EventID,
+ space: TelegramID, client: 'MautrixTelegramClient',
+ content: LocationMessageEventContent, reply_to: TelegramID
+ ) -> None:
+ try:
+ lat, long = content.geo_uri[len("geo:"):].split(",")
+ lat, long = float(lat), float(long)
+ except (KeyError, ValueError):
+ self.log.exception("Failed to parse location")
+ return None
+ caption, entities = self._matrix_event_to_entities(content)
+ media = MessageMediaGeo(geo=GeoPoint(lat, long, access_hash=0))
+
+ async with self.send_lock(sender_id):
+ if await self._matrix_document_edit(client, content, space, caption, media, event_id):
+ return
+ response = await client.send_media(self.peer, media, reply_to=reply_to,
+ caption=caption, entities=entities)
+ self._add_telegram_message_to_db(event_id, space, 0, response)
+
+ def _add_telegram_message_to_db(self, event_id: EventID, space: TelegramID,
+ edit_index: int, response: TypeMessage) -> None:
+ self.log.debug("Handled Matrix message: %s", response)
+ self.dedup.check(response, (event_id, space), force_hash=edit_index != 0)
+ if edit_index < 0:
+ prev_edit = DBMessage.get_one_by_tgid(TelegramID(response.id), space, -1)
+ edit_index = prev_edit.edit_index + 1
+ DBMessage(
+ tgid=TelegramID(response.id),
+ tg_space=space,
+ mx_room=self.mxid,
+ mxid=event_id,
+ edit_index=edit_index).insert()
+
+ async def handle_matrix_message(self, sender: 'u.User', content: MessageEventContent,
+ event_id: EventID) -> None:
+ if not content.body or not content.msgtype:
+ self.log.debug(f"Ignoring message {event_id} in {self.mxid} without body or msgtype")
+ return
+
+ puppet = p.Puppet.get_by_custom_mxid(sender.mxid)
+ if puppet and content.get("net.maunium.telegram.puppet", False):
+ self.log.debug("Ignoring puppet-sent message by confirmed puppet user %s", sender.mxid)
+ return
+
+ logged_in = not await sender.needs_relaybot(self)
+ client = sender.client if logged_in else self.bot.client
+ sender_id = sender.tgid if logged_in else self.bot.tgid
+ space = (self.tgid if self.peer_type == "channel" # Channels have their own ID space
+ else (sender.tgid if logged_in else self.bot.tgid))
+ reply_to = formatter.matrix_reply_to_telegram(content, space, room_id=self.mxid)
+
+ content["net.maunium.telegram.internal.filename"] = content.body
+ await self._pre_process_matrix_message(sender, not logged_in, content)
+
+ if content.msgtype == MessageType.NOTICE:
+ bridge_notices = self.get_config("bridge_notices.default")
+ excepted = sender.mxid in self.get_config("bridge_notices.exceptions")
+ if not bridge_notices and not excepted:
+ return
+
+ if content.msgtype in (MessageType.TEXT, MessageType.NOTICE):
+ await self._handle_matrix_text(sender_id, event_id, space, client, content, reply_to)
+ elif content.msgtype == MessageType.LOCATION:
+ await self._handle_matrix_location(sender_id, event_id, space, client, content,
+ reply_to)
+ elif content.msgtype in (MessageType.STICKER, MessageType.IMAGE, MessageType.FILE,
+ MessageType.AUDIO, MessageType.VIDEO):
+ await self._handle_matrix_file(sender_id, event_id, space, client, content, reply_to)
+ else:
+ self.log.debug(f"Unhandled Matrix event: {content}")
+
+ async def handle_matrix_pin(self, sender: 'u.User',
+ pinned_message: Optional[EventID]) -> None:
+ if self.peer_type != "chat" and self.peer_type != "channel":
+ return
+ try:
+ if not pinned_message:
+ await sender.client(UpdatePinnedMessageRequest(peer=self.peer, id=0))
+ else:
+ tg_space = self.tgid if self.peer_type == "channel" else sender.tgid
+ message = DBMessage.get_by_mxid(pinned_message, self.mxid, tg_space)
+ if message is None:
+ self.log.warning(f"Could not find pinned {pinned_message} in {self.mxid}")
+ return
+ await sender.client(UpdatePinnedMessageRequest(peer=self.peer, id=message.tgid))
+ except ChatNotModifiedError:
+ pass
+
+ async def handle_matrix_deletion(self, deleter: 'u.User', event_id: EventID) -> None:
+ real_deleter = deleter if not await deleter.needs_relaybot(self) else self.bot
+ space = self.tgid if self.peer_type == "channel" else real_deleter.tgid
+ message = DBMessage.get_by_mxid(event_id, self.mxid, space)
+ if not message:
+ return
+ if message.edit_index == 0:
+ await real_deleter.client.delete_messages(self.peer, [message.tgid])
+ else:
+ self.log.debug(f"Ignoring deletion of edit event {message.mxid} in {message.mx_room}")
+
+ async def _update_telegram_power_level(self, sender: 'u.User', user_id: TelegramID,
+ level: int) -> None:
+ moderator = level >= 50
+ admin = level >= 75
+ await sender.client.edit_admin(self.peer, user_id,
+ change_info=moderator, post_messages=moderator,
+ edit_messages=moderator, delete_messages=moderator,
+ ban_users=moderator, invite_users=moderator,
+ pin_messages=moderator, add_admins=admin)
+
+ async def handle_matrix_power_levels(self, sender: 'u.User', new_users: Dict[UserID, int],
+ old_users: Dict[UserID, int]) -> None:
+ # TODO handle all power level changes and bridge exact admin rights to supergroups/channels
+ for user, level in new_users.items():
+ if not user or user == self.main_intent.mxid or user == sender.mxid:
+ continue
+ user_id = p.Puppet.get_id_from_mxid(user)
+ if not user_id:
+ mx_user = u.User.get_by_mxid(user, create=False)
+ if not mx_user or not mx_user.tgid:
+ continue
+ user_id = mx_user.tgid
+ if not user_id or user_id == sender.tgid:
+ continue
+ if user not in old_users or level != old_users[user]:
+ await self._update_telegram_power_level(sender, user_id, level)
+
+ async def handle_matrix_about(self, sender: 'u.User', about: str) -> None:
+ if self.peer_type not in ("chat", "channel"):
+ return
+ peer = await self.get_input_entity(sender)
+ await sender.client(EditChatAboutRequest(peer=peer, about=about))
+ self.about = about
+ self.save()
+
+ async def handle_matrix_title(self, sender: 'u.User', title: str) -> None:
+ if self.peer_type not in ("chat", "channel"):
+ return
+
+ if self.peer_type == "chat":
+ response = await sender.client(EditChatTitleRequest(chat_id=self.tgid, title=title))
+ else:
+ channel = await self.get_input_entity(sender)
+ response = await sender.client(EditTitleRequest(channel=channel, title=title))
+ self.dedup.register_outgoing_actions(response)
+ self.title = title
+ self.save()
+
+ async def handle_matrix_avatar(self, sender: 'u.User', url: ContentURI) -> None:
+ if self.peer_type not in ("chat", "channel"):
+ # Invalid peer type
+ return
+
+ file = await self.main_intent.download_media(url)
+ mime = magic.from_buffer(file, mime=True)
+ ext = sane_mimetypes.guess_extension(mime)
+ uploaded = await sender.client.upload_file(file, file_name=f"avatar{ext}")
+ photo = InputChatUploadedPhoto(file=uploaded)
+
+ if self.peer_type == "chat":
+ response = await sender.client(EditChatPhotoRequest(chat_id=self.tgid, photo=photo))
+ else:
+ channel = await self.get_input_entity(sender)
+ response = await sender.client(EditPhotoRequest(channel=channel, photo=photo))
+ self.dedup.register_outgoing_actions(response)
+ for update in response.updates:
+ is_photo_update = (isinstance(update, UpdateNewMessage)
+ and isinstance(update.message, MessageService)
+ and isinstance(update.message.action, MessageActionChatEditPhoto))
+ if is_photo_update:
+ loc, size = self._get_largest_photo_size(update.message.action.photo)
+ self.photo_id = f"{size.location.volume_id}-{size.location.local_id}"
+ self.save()
+ break
+
+ async def handle_matrix_upgrade(self, new_room: RoomID) -> None:
+ old_room = self.mxid
+ self.migrate_and_save_matrix(new_room)
+ await self.main_intent.join_room(new_room)
+ entity: Optional[TypeInputPeer] = None
+ user: Optional[AbstractUser] = None
+ if self.bot and self.has_bot:
+ user = self.bot
+ entity = await self.get_input_entity(self.bot)
+ if not entity:
+ user_mxids = await self.main_intent.get_room_members(self.mxid)
+ for user_str in user_mxids:
+ user_id = UserID(user_str)
+ if user_id == self.az.bot_mxid:
+ continue
+ user = u.User.get_by_mxid(user_id, create=False)
+ if user and user.tgid:
+ entity = await self.get_input_entity(user)
+ if entity:
+ break
+ if not entity:
+ self.log.error("Failed to fully migrate to upgraded Matrix room: "
+ "no Telegram user found.")
+ return
+ await self.update_matrix_room(user, entity, direct=self.peer_type == "user")
+ self.log.info(f"Upgraded room from {old_room} to {self.mxid}")
+
+ def migrate_and_save_matrix(self, new_id: RoomID) -> None:
+ try:
+ del self.by_mxid[self.mxid]
+ except KeyError:
+ pass
+ self.mxid = new_id
+ self.db_instance.edit(mxid=self.mxid)
+ self.by_mxid[self.mxid] = self
+
+
+def init(context: Context) -> None:
+ global config
+ config = context.config
diff --git a/mautrix_telegram/portal/metadata.py b/mautrix_telegram/portal/metadata.py
new file mode 100644
index 00000000..e5f3ccea
--- /dev/null
+++ b/mautrix_telegram/portal/metadata.py
@@ -0,0 +1,666 @@
+# mautrix-telegram - A Matrix-Telegram puppeting bridge
+# Copyright (C) 2019 Tulir Asokan
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see
",
+ prefix_text="Inline image: ")
+ content.external_url = self._get_external_url(evt)
+ await intent.set_typing(self.mxid, is_typing=False)
+ return await intent.send_message(self.mxid, content, timestamp=evt.date)
+ info = ImageInfo(
+ height=largest_size.h, width=largest_size.w, orientation=0, mimetype=file.mime_type,
+ size=(len(largest_size.bytes) if (isinstance(largest_size, PhotoCachedSize))
+ else largest_size.size))
+ name = f"image{sane_mimetypes.guess_extension(file.mime_type)}"
+ await intent.set_typing(self.mxid, is_typing=False)
+ content = MediaMessageEventContent(url=file.mxc, msgtype=MessageType.IMAGE, info=info,
+ body=name, relates_to=relates_to,
+ external_url=self._get_external_url(evt))
+ result = await intent.send_message(self.mxid, content, timestamp=evt.date)
+ if evt.message:
+ caption_content = await formatter.telegram_to_matrix(evt, source, self.main_intent,
+ no_reply_fallback=True)
+ caption_content.external_url = content.external_url
+ result = await intent.send_message(self.mxid, caption_content, timestamp=evt.date)
+ return result
+
+ @staticmethod
+ def _parse_telegram_document_attributes(attributes: List[TypeDocumentAttribute]) -> DocAttrs:
+ name, mime_type, is_sticker, sticker_alt, width, height = None, None, False, None, 0, 0
+ for attr in attributes:
+ if isinstance(attr, DocumentAttributeFilename):
+ name = name or attr.file_name
+ mime_type, _ = mimetypes.guess_type(attr.file_name)
+ elif isinstance(attr, DocumentAttributeSticker):
+ is_sticker = True
+ sticker_alt = attr.alt
+ elif isinstance(attr, DocumentAttributeVideo):
+ width, height = attr.w, attr.h
+ return DocAttrs(name, mime_type, is_sticker, sticker_alt, width, height)
+
+ @staticmethod
+ def _parse_telegram_document_meta(evt: Message, file: DBTelegramFile, attrs: DocAttrs,
+ thumb_size: TypePhotoSize) -> Tuple[ImageInfo, str]:
+ document = evt.media.document
+ name = evt.message or attrs.name
+ if attrs.is_sticker:
+ alt = attrs.sticker_alt
+ if len(alt) > 0:
+ try:
+ name = f"{alt} ({unicodedata.name(alt[0]).lower()})"
+ except ValueError:
+ name = alt
+
+ generic_types = ("text/plain", "application/octet-stream")
+ if file.mime_type in generic_types and document.mime_type not in generic_types:
+ mime_type = document.mime_type or file.mime_type
+ else:
+ mime_type = file.mime_type or document.mime_type
+ info = ImageInfo(size=file.size, mimetype=mime_type)
+
+ if attrs.mime_type and not file.was_converted:
+ file.mime_type = attrs.mime_type or file.mime_type
+ if file.width and file.height:
+ info.width, info.height = file.width, file.height
+ elif attrs.width and attrs.height:
+ info.width, info.height = attrs.width, attrs.height
+
+ if file.thumbnail:
+ info.thumbnail_url = file.thumbnail.mxc
+ info.thumbnail_info = ThumbnailInfo(mimetype=file.thumbnail.mime_type,
+ height=file.thumbnail.height or thumb_size.h,
+ width=file.thumbnail.width or thumb_size.w,
+ size=file.thumbnail.size)
+
+ return info, name
+
+ async def handle_telegram_document(self, source: 'AbstractUser', intent: IntentAPI,
+ evt: Message, relates_to: RelatesTo = None
+ ) -> Optional[EventID]:
+ document = evt.media.document
+
+ attrs = self._parse_telegram_document_attributes(document.attributes)
+
+ if document.size > config["bridge.max_document_size"] * 1000 ** 2:
+ name = attrs.name or ""
+ caption = f"\n{evt.message}" if evt.message else ""
+ return await intent.send_notice(self.mxid, f"Too large file {name}{caption}")
+
+ thumb_loc, thumb_size = self._get_largest_photo_size(document)
+ if thumb_size and not isinstance(thumb_size, (PhotoSize, PhotoCachedSize)):
+ self.log.debug(f"Unsupported thumbnail type {type(thumb_size)}")
+ thumb_loc = None
+ thumb_size = None
+ file = await util.transfer_file_to_matrix(source.client, intent, document, thumb_loc,
+ is_sticker=attrs.is_sticker)
+ if not file:
+ return None
+
+ info, name = self._parse_telegram_document_meta(evt, file, attrs, thumb_size)
+
+ await intent.set_typing(self.mxid, is_typing=False)
+
+ event_type = EventType.STICKER if attrs.is_sticker else EventType.ROOM_MESSAGE
+ content = MediaMessageEventContent(
+ body=name or "unnamed file", info=info, url=file.mxc, relates_to=relates_to,
+ external_url=self._get_external_url(evt),
+ msgtype={
+ "video/": MessageType.VIDEO,
+ "audio/": MessageType.AUDIO,
+ "image/": MessageType.IMAGE,
+ }.get(info.mimetype[:6], MessageType.FILE))
+ return await intent.send_message_event(self.mxid, event_type, content, timestamp=evt.date)
+
+ def handle_telegram_location(self, _: 'AbstractUser', intent: IntentAPI, evt: Message,
+ relates_to: dict = None) -> Awaitable[EventID]:
+ long = evt.media.geo.long
+ lat = evt.media.geo.lat
+ long_char = "E" if long > 0 else "W"
+ lat_char = "N" if lat > 0 else "S"
+
+ body = f"{round(lat, 5)}° {lat_char}, {round(long, 5)}° {long_char}"
+ url = f"https://maps.google.com/?q={lat},{long}"
+
+ content = LocationMessageEventContent(
+ msgtype=MessageType.LOCATION, geo_uri=f"geo:{lat},{long}",
+ body=f"Location: {body}\n{url}",
+ relates_to=relates_to, external_url=self._get_external_url(evt))
+ content["format"] = Format.HTML
+ content["formatted_body"] = f"Location: {body}"
+
+ return intent.send_message(self.mxid, content, timestamp=evt.date)
+
+ async def handle_telegram_text(self, source: 'AbstractUser', intent: IntentAPI, is_bot: bool,
+ evt: Message) -> EventID:
+ self.log.debug(f"Sending {evt.message} to {self.mxid} by {intent.mxid}")
+ content = await formatter.telegram_to_matrix(evt, source, self.main_intent)
+ content.external_url = self._get_external_url(evt)
+ if is_bot and self.get_config("bot_messages_as_notices"):
+ content.msgtype = MessageType.NOTICE
+ await intent.set_typing(self.mxid, is_typing=False)
+ return await intent.send_message(self.mxid, content, timestamp=evt.date)
+
+ async def handle_telegram_unsupported(self, source: 'AbstractUser', intent: IntentAPI,
+ evt: Message, relates_to: dict = None) -> EventID:
+ override_text = ("This message is not supported on your version of Mautrix-Telegram. "
+ "Please check https://github.com/tulir/mautrix-telegram or ask your "
+ "bridge administrator about possible updates.")
+ content = await formatter.telegram_to_matrix(
+ evt, source, self.main_intent, override_text=override_text)
+ content.msgtype = MessageType.NOTICE
+ content.external_url = self._get_external_url(evt)
+ content["net.maunium.telegram.unsupported"] = True
+ await intent.set_typing(self.mxid, is_typing=False)
+ return await intent.send_message(self.mxid, content, timestamp=evt.date)
+
+ async def handle_telegram_poll(self, source: 'AbstractUser', intent: IntentAPI, evt: Message,
+ relates_to: RelatesTo) -> EventID:
+ poll: Poll = evt.media.poll
+ poll_id = self._encode_msgid(source, evt)
+
+ _n = 0
+
+ def n() -> int:
+ nonlocal _n
+ _n += 1
+ return _n
+
+ text_answers = "\n".join(f"{n()}. {answer.text}" for answer in poll.answers)
+ html_answers = "\n".join(f"{answer.text} " for answer in poll.answers)
+ content = TextMessageEventContent(
+ msgtype=MessageType.TEXT, format=Format.HTML,
+ body=f"Poll: {poll.question}\n{text_answers}\n"
+ f"Vote with !tg vote {poll_id} ",
+ formatted_body=f"Poll: {poll.question}
\n"
+ f"{html_answers}
\n"
+ f"Vote with !tg vote {poll_id} <choice number>",
+ relates_to=relates_to, external_url=self._get_external_url(evt))
+
+ await intent.set_typing(self.mxid, is_typing=False)
+ return await intent.send_message(self.mxid, content, timestamp=evt.date)
+
+ @staticmethod
+ def _int_to_bytes(i: int) -> bytes:
+ hex_value = "{0:010x}".format(i)
+ return codecs.decode(hex_value, "hex_codec")
+
+ def _encode_msgid(self, source: 'AbstractUser', evt: Message) -> str:
+ if self.peer_type == "channel":
+ play_id = (b"c"
+ + self._int_to_bytes(self.tgid)
+ + self._int_to_bytes(evt.id))
+ elif self.peer_type == "chat":
+ play_id = (b"g"
+ + self._int_to_bytes(self.tgid)
+ + self._int_to_bytes(evt.id)
+ + self._int_to_bytes(source.tgid))
+ elif self.peer_type == "user":
+ play_id = (b"u"
+ + self._int_to_bytes(self.tgid)
+ + self._int_to_bytes(evt.id))
+ else:
+ raise ValueError("Portal has invalid peer type")
+ return base64.b64encode(play_id).decode("utf-8").rstrip("=")
+
+ async def handle_telegram_game(self, source: 'AbstractUser', intent: IntentAPI,
+ evt: Message, relates_to: RelatesTo = None) -> EventID:
+ game = evt.media.game
+ play_id = self._encode_msgid(source, evt)
+ command = f"!tg play {play_id}"
+ override_text = f"Run {command} in your bridge management room to play {game.title}"
+ override_entities = [
+ MessageEntityPre(offset=len("Run "), length=len(command), language="")]
+
+ content = await formatter.telegram_to_matrix(
+ evt, source, self.main_intent,
+ override_text=override_text, override_entities=override_entities)
+ content.msgtype = MessageType.NOTICE
+ content.external_url = self._get_external_url(evt)
+ content["net.maunium.telegram.game"] = play_id
+
+ await intent.set_typing(self.mxid, is_typing=False)
+ return await intent.send_message(self.mxid, content, timestamp=evt.date)
+
+ async def handle_telegram_edit(self, source: 'AbstractUser', sender: p.Puppet, evt: Message
+ ) -> None:
+ if not self.mxid:
+ return
+ elif hasattr(evt, "media") and isinstance(evt.media, MessageMediaGame):
+ self.log.debug("Ignoring game message edit event")
+ return
+
+ async with self.send_lock(sender.tgid if sender else None, required=False):
+ tg_space = self.tgid if self.peer_type == "channel" else source.tgid
+
+ temporary_identifier = EventID(
+ f"${random.randint(1000000000000, 9999999999999)}TGBRIDGEDITEMP")
+ duplicate_found = self.dedup.check(evt, (temporary_identifier, tg_space),
+ force_hash=True)
+ if duplicate_found:
+ mxid, other_tg_space = duplicate_found
+ if tg_space != other_tg_space:
+ prev_edit_msg = DBMessage.get_one_by_tgid(TelegramID(evt.id), tg_space, -1)
+ if not prev_edit_msg:
+ return
+ DBMessage(mxid=mxid, mx_room=self.mxid, tg_space=tg_space,
+ tgid=TelegramID(evt.id), edit_index=prev_edit_msg.edit_index + 1
+ ).insert()
+ return
+
+ content = await formatter.telegram_to_matrix(evt, source, self.main_intent,
+ no_reply_fallback=True)
+ editing_msg = DBMessage.get_one_by_tgid(TelegramID(evt.id), tg_space)
+ if not editing_msg:
+ self.log.info(f"Didn't find edited message {evt.id}@{tg_space} (src {source.tgid}) "
+ "in database.")
+ return
+
+ content.msgtype = (MessageType.NOTICE if (sender and sender.is_bot
+ and self.get_config("bot_messages_as_notices"))
+ else MessageType.TEXT)
+ content.external_url = self._get_external_url(evt)
+ content.set_edit(editing_msg.mxid)
+
+ # TODO remove this stuff once mautrix-python generates m.new_content
+ new_content = content.serialize()
+ del new_content["m.relates_to"]
+ content["m.new_content"] = new_content
+ content.body = f"Edit: {content.body}"
+ content.format = Format.HTML
+ content.formatted_body = (f"Edit: "
+ f"{content.formatted_body or escape_html(content.body)}")
+
+ intent = sender.intent_for(self) if sender else self.main_intent
+ await intent.set_typing(self.mxid, is_typing=False)
+ event_id = await intent.send_message(self.mxid, content)
+
+ prev_edit_msg = DBMessage.get_one_by_tgid(TelegramID(evt.id), tg_space, -1) or editing_msg
+ DBMessage(mxid=event_id, mx_room=self.mxid, tg_space=tg_space, tgid=TelegramID(evt.id),
+ edit_index=prev_edit_msg.edit_index + 1).insert()
+ DBMessage.update_by_mxid(temporary_identifier, self.mxid, mxid=event_id)
+
+ async def handle_telegram_message(self, source: 'AbstractUser', sender: p.Puppet,
+ evt: Message) -> None:
+ if not self.mxid:
+ await self.create_matrix_room(source, invites=[source.mxid], update_if_exists=False)
+
+ if (self.peer_type == "user" and sender.tgid == self.tg_receiver
+ and not sender.is_real_user and not self.az.state_store.is_joined(self.mxid,
+ sender.mxid)):
+ self.log.debug(f"Ignoring private chat message {evt.id}@{source.tgid} as receiver does"
+ " not have matrix puppeting and their default puppet isn't in the room")
+
+ async with self.send_lock(sender.tgid if sender else None, required=False):
+ tg_space = self.tgid if self.peer_type == "channel" else source.tgid
+
+ temporary_identifier = EventID(
+ f"${random.randint(1000000000000, 9999999999999)}TGBRIDGETEMP")
+ duplicate_found = self.dedup.check(evt, (temporary_identifier, tg_space))
+ if duplicate_found:
+ mxid, other_tg_space = duplicate_found
+ self.log.debug(f"Ignoring message {evt.id}@{tg_space} (src {source.tgid}) "
+ f"as it was already handled (in space {other_tg_space})")
+ if tg_space != other_tg_space:
+ DBMessage(tgid=TelegramID(evt.id), mx_room=self.mxid, mxid=mxid,
+ tg_space=tg_space, edit_index=0).insert()
+ return
+
+ if self.dedup.pre_db_check and self.peer_type == "channel":
+ msg = DBMessage.get_one_by_tgid(TelegramID(evt.id), tg_space)
+ if msg:
+ self.log.debug(f"Ignoring message {evt.id} (src {source.tgid}) as it was already"
+ f"handled into {msg.mxid}. This duplicate was catched in the db "
+ "check. If you get this message often, consider increasing"
+ "bridge.deduplication.cache_queue_length in the config.")
+ return
+
+ if sender and not sender.displayname:
+ self.log.debug(f"Telegram user {sender.tgid} sent a message, but doesn't have a "
+ "displayname, updating info...")
+ entity = await source.client.get_entity(PeerUser(sender.tgid))
+ await sender.update_info(source, entity)
+
+ allowed_media = (MessageMediaPhoto, MessageMediaDocument, MessageMediaGeo,
+ MessageMediaGame, MessageMediaPoll, MessageMediaUnsupported)
+ media = evt.media if hasattr(evt, "media") and isinstance(evt.media,
+ allowed_media) else None
+ intent = sender.intent_for(self) if sender else self.main_intent
+ if not media and evt.message:
+ is_bot = sender.is_bot if sender else False
+ event_id = await self.handle_telegram_text(source, intent, is_bot, evt)
+ elif media:
+ event_id = await {
+ MessageMediaPhoto: self.handle_telegram_photo,
+ MessageMediaDocument: self.handle_telegram_document,
+ MessageMediaGeo: self.handle_telegram_location,
+ MessageMediaPoll: self.handle_telegram_poll,
+ MessageMediaUnsupported: self.handle_telegram_unsupported,
+ MessageMediaGame: self.handle_telegram_game,
+ }[type(media)](source, intent, evt,
+ relates_to=formatter.telegram_reply_to_matrix(evt, source))
+ else:
+ self.log.debug("Unhandled Telegram message: %s", evt)
+ return
+
+ if not event_id:
+ return
+
+ prev_id = self.dedup.update(evt, (event_id, tg_space), (temporary_identifier, tg_space))
+ if prev_id:
+ self.log.debug(f"Sent message {evt.id}@{tg_space} to Matrix as {event_id}. "
+ f"Temporary dedup identifier was {temporary_identifier}, "
+ f"but dedup map contained {prev_id[1]} instead! -- "
+ "This was probably a race condition caused by Telegram sending updates"
+ "to other clients before responding to the sender. I'll just redact "
+ "the likely duplicate message now.")
+ await intent.redact(self.mxid, event_id)
+ return
+
+ self.log.debug("Handled Telegram message: %s", evt)
+ try:
+ DBMessage(tgid=TelegramID(evt.id), mx_room=self.mxid, mxid=event_id,
+ tg_space=tg_space, edit_index=0).insert()
+ DBMessage.update_by_mxid(temporary_identifier, self.mxid, mxid=event_id)
+ except IntegrityError as e:
+ self.log.exception(f"{e.__class__.__name__} while saving message mapping. "
+ "This might mean that an update was handled after it left the "
+ "dedup cache queue. You can try enabling bridge.deduplication."
+ "pre_db_check in the config.")
+ await intent.redact(self.mxid, event_id)
+
+ async def _create_room_on_action(self, source: 'AbstractUser',
+ action: TypeMessageAction) -> bool:
+ if source.is_relaybot:
+ return False
+ create_and_exit = (MessageActionChatCreate, MessageActionChannelCreate)
+ create_and_continue = (MessageActionChatAddUser, MessageActionChatJoinedByLink)
+ if isinstance(action, create_and_exit) or isinstance(action, create_and_continue):
+ await self.create_matrix_room(source, invites=[source.mxid],
+ update_if_exists=isinstance(action, create_and_exit))
+ if not isinstance(action, create_and_continue):
+ return False
+ return True
+
+ async def handle_telegram_action(self, source: 'AbstractUser', sender: p.Puppet,
+ update: MessageService) -> None:
+ action = update.action
+ should_ignore = ((not self.mxid and not await self._create_room_on_action(source, action))
+ or self.dedup.check_action(update))
+ if should_ignore or not self.mxid:
+ return
+ if isinstance(action, MessageActionChatEditTitle):
+ await self._update_title(action.title, save=True)
+ elif isinstance(action, MessageActionChatEditPhoto):
+ await self._update_avatar(source, action.photo, save=True)
+ elif isinstance(action, MessageActionChatDeletePhoto):
+ await self._update_avatar(source, ChatPhotoEmpty(), save=True)
+ elif isinstance(action, MessageActionChatAddUser):
+ for user_id in action.users:
+ await self._add_telegram_user(TelegramID(user_id), source)
+ elif isinstance(action, MessageActionChatJoinedByLink):
+ await self._add_telegram_user(sender.id, source)
+ elif isinstance(action, MessageActionChatDeleteUser):
+ await self._delete_telegram_user(TelegramID(action.user_id), sender)
+ elif isinstance(action, MessageActionChatMigrateTo):
+ self.peer_type = "channel"
+ self._migrate_and_save_telegram(TelegramID(action.channel_id))
+ await sender.intent_for(self).send_emote(self.mxid,
+ "upgraded this group to a supergroup.")
+ elif isinstance(action, MessageActionPinMessage):
+ await self.receive_telegram_pin_sender(sender)
+ elif isinstance(action, MessageActionGameScore):
+ # TODO handle game score
+ pass
+ else:
+ self.log.debug("Unhandled Telegram action in %s: %s", self.title, action)
+
+ async def set_telegram_admin(self, user_id: TelegramID) -> None:
+ puppet = p.Puppet.get(user_id)
+ user = u.User.get_by_tgid(user_id)
+
+ levels = await self.main_intent.get_power_levels(self.mxid)
+ if user:
+ levels.users[user.mxid] = 50
+ if puppet:
+ levels.users[puppet.mxid] = 50
+ await self.main_intent.set_power_levels(self.mxid, levels)
+
+ async def receive_telegram_pin_sender(self, sender: p.Puppet) -> None:
+ self._temp_pinned_message_sender = sender
+ if self._temp_pinned_message_id:
+ await self.update_telegram_pin()
+
+ async def update_telegram_pin(self) -> None:
+ intent = (self._temp_pinned_message_sender.intent_for(self)
+ if self._temp_pinned_message_sender else self.main_intent)
+ msg_id = self._temp_pinned_message_id
+ self._temp_pinned_message_id = None
+ self._temp_pinned_message_sender = None
+
+ message = DBMessage.get_one_by_tgid(msg_id, self._temp_pinned_message_id_space)
+ if message:
+ await intent.set_pinned_messages(self.mxid, [message.mxid])
+ else:
+ await intent.set_pinned_messages(self.mxid, [])
+
+ async def receive_telegram_pin_id(self, msg_id: TelegramID, receiver: TelegramID) -> None:
+ if msg_id == 0:
+ return await self.update_telegram_pin()
+ self._temp_pinned_message_id = msg_id
+ self._temp_pinned_message_id_space = receiver if self.peer_type != "channel" else self.tgid
+ if self._temp_pinned_message_sender:
+ await self.update_telegram_pin()
+
+ async def set_telegram_admins_enabled(self, enabled: bool) -> None:
+ level = 50 if enabled else 10
+ levels = await self.main_intent.get_power_levels(self.mxid)
+ levels.invite = level
+ levels.events[EventType.ROOM_NAME] = level
+ levels.events[EventType.ROOM_AVATAR] = level
+ await self.main_intent.set_power_levels(self.mxid, levels)
+
+
+def init(context: Context) -> None:
+ global config
+ config = context.config
diff --git a/mautrix_telegram/puppet.py b/mautrix_telegram/puppet.py
index ede800b0..cb3c9d9f 100644
--- a/mautrix_telegram/puppet.py
+++ b/mautrix_telegram/puppet.py
@@ -1,4 +1,3 @@
-# -*- coding: future_fstrings -*-
# mautrix-telegram - A Matrix-Telegram puppeting bridge
# Copyright (C) 2019 Tulir Asokan
#
@@ -14,21 +13,24 @@
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see
allfun*!",
html="**This** was
allfun*!\n",
)
@@ -69,7 +71,7 @@ class TestCommandEvent:
# html, markdown (default)
evt.reply(message, allow_html=True, render_markdown=True)
mock_az.intent.send_notice.assert_called_with(
- MatrixRoomID("#mock_room:example.org"),
+ RoomID("#mock_room:example.org"),
"**This** was
allfun*!",
html=(
"This was
"
@@ -80,7 +82,7 @@ class TestCommandEvent:
# no html, no markdown
evt.reply(message, allow_html=False, render_markdown=False)
mock_az.intent.send_notice.assert_called_with(
- MatrixRoomID("#mock_room:example.org"),
+ RoomID("#mock_room:example.org"),
"**This** was
allfun*!",
html=None,
)
@@ -88,7 +90,7 @@ class TestCommandEvent:
# no html, markdown
evt.reply(message, allow_html=False, render_markdown=True)
mock_az.intent.send_notice.assert_called_with(
- MatrixRoomID("#mock_room:example.org"),
+ RoomID("#mock_room:example.org"),
"**This** was
allfun*!",
html="
This <i>was</i><br/>"
"<strong>all</strong>fun*!
\n"
@@ -100,9 +102,9 @@ class TestCommandEvent:
evt = CommandEvent(
processor=command_processor,
- room=MatrixRoomID("#mock_room:example.org"),
- event=MatrixEventID("$H45H:example.org"),
- sender=u.User(MatrixUserID("@sender:example.org")),
+ room_id=RoomID("#mock_room:example.org"),
+ event_id=EventID("$H45H:example.org"),
+ sender=u.User(UserID("@sender:example.org")),
command="help",
args=[],
is_management=False,
@@ -115,7 +117,7 @@ class TestCommandEvent:
render_markdown=False)
mock_az.intent.send_notice.assert_called_with(
- MatrixRoomID("#mock_room:example.org"),
+ RoomID("#mock_room:example.org"),
"tg ....tg+sp...tg tg",
html=None,
)
@@ -126,9 +128,9 @@ class TestCommandEvent:
evt = CommandEvent(
processor=command_processor,
- room=MatrixRoomID("#mock_room:example.org"),
- event=MatrixEventID("$H45H:example.org"),
- sender=u.User(MatrixUserID("@sender:example.org")),
+ room_id=RoomID("#mock_room:example.org"),
+ event_id=EventID("$H45H:example.org"),
+ sender=u.User(UserID("@sender:example.org")),
command="help",
args=[],
is_management=True,
@@ -144,7 +146,7 @@ class TestCommandEvent:
)
mock_az.intent.send_notice.assert_called_with(
- MatrixRoomID("#mock_room:example.org"),
+ RoomID("#mock_room:example.org"),
"....tg+sp...tg tg",
html="....tg+sp...tg tg
\n",
)
@@ -195,15 +197,15 @@ class TestCommandHandler:
help_section=HelpSection("Mock Section", 42, ""),
)
- sender = u.User(MatrixUserID("@sender:example.org"))
+ sender = u.User(UserID("@sender:example.org"))
sender.puppet_whitelisted = False
sender.matrix_puppet_whitelisted = False
sender.is_admin = False
event = CommandEvent(
processor=command_processor,
- room=MatrixRoomID("#mock_room:example.org"),
- event=MatrixEventID("$H45H:example.org"),
+ room_id=RoomID("#mock_room:example.org"),
+ event_id=EventID("$H45H:example.org"),
sender=sender,
command=command,
args=[],
@@ -212,7 +214,8 @@ class TestCommandHandler:
)
assert await command_handler.get_permission_error(event)
- assert not command_handler.has_permission(False, False, False, False, False)
+ assert not command_handler.has_permission(
+ HelpCacheKey(False, False, False, False, False, False))
@pytest.mark.parametrize(
(
@@ -255,7 +258,7 @@ class TestCommandHandler:
help_section=HelpSection("Mock Section", 42, ""),
)
- sender = u.User(MatrixUserID("@sender:example.org"))
+ sender = u.User(UserID("@sender:example.org"))
sender.puppet_whitelisted = puppet_whitelisted
sender.matrix_puppet_whitelisted = matrix_puppet_whitelisted
sender.is_admin = is_admin
@@ -263,8 +266,8 @@ class TestCommandHandler:
event = CommandEvent(
processor=command_processor,
- room=MatrixRoomID("#mock_room:example.org"),
- event=MatrixEventID("$H45H:example.org"),
+ room_id=RoomID("#mock_room:example.org"),
+ event_id=EventID("$H45H:example.org"),
sender=sender,
command=command,
args=[],
@@ -274,12 +277,12 @@ class TestCommandHandler:
assert not await command_handler.get_permission_error(event)
assert command_handler.has_permission(
- is_management=is_management,
- puppet_whitelisted=puppet_whitelisted,
- matrix_puppet_whitelisted=matrix_puppet_whitelisted,
- is_admin=is_admin,
- is_logged_in=is_logged_in,
- )
+ HelpCacheKey(is_management=is_management,
+ puppet_whitelisted=puppet_whitelisted,
+ matrix_puppet_whitelisted=matrix_puppet_whitelisted,
+ is_admin=is_admin,
+ is_logged_in=is_logged_in,
+ is_portal=boolean))
class TestCommandProcessor:
@@ -292,41 +295,41 @@ class TestCommandProcessor:
mocker: MockFixture) -> None:
mocker.patch('mautrix_telegram.user.config', self.config)
mocker.patch(
- 'mautrix_telegram.commands.handler.command_handlers',
+ 'mautrix.bridge.commands.handler.command_handlers',
{"help": AsyncMock(), "unknown-command": AsyncMock()}
)
- sender = u.User(MatrixUserID("@sender:example.org"))
+ sender = u.User(UserID("@sender:example.org"))
result = await command_processor.handle(
- room=MatrixRoomID("#mock_room:example.org"),
- event_id=MatrixEventID("$H45H:example.org"),
+ room_id=RoomID("#mock_room:example.org"),
+ event_id=EventID("$H45H:example.org"),
sender=sender,
command="hElp",
args=[],
is_management=boolean2[0],
- is_portal=boolean2[1],
- )
+ is_portal=boolean2[1])
assert result is None
- command_handlers = mautrix_telegram.commands.handler.command_handlers
+ command_handlers = mautrix.bridge.commands.handler.command_handlers
command_handlers["help"].mock.assert_called_once() # type: ignore
@pytest.mark.asyncio
async def test_handle_unknown_command(self, command_processor: CommandProcessor,
- boolean2: Tuple[bool, bool], mocker: MockFixture) -> None:
+ boolean2: Tuple[bool, bool],
+ mocker: MockFixture) -> None:
mocker.patch('mautrix_telegram.user.config', self.config)
mocker.patch(
- 'mautrix_telegram.commands.handler.command_handlers',
+ 'mautrix.bridge.commands.handler.command_handlers',
{"help": AsyncMock(), "unknown-command": AsyncMock()}
)
- sender = u.User(MatrixUserID("@sender:example.org"))
+ sender = u.User(UserID("@sender:example.org"))
sender.command_status = {}
result = await command_processor.handle(
- room=MatrixRoomID("#mock_room:example.org"),
- event_id=MatrixEventID("$H45H:example.org"),
+ room_id=RoomID("#mock_room:example.org"),
+ event_id=EventID("$H45H:example.org"),
sender=sender,
command="foo",
args=[],
@@ -335,7 +338,7 @@ class TestCommandProcessor:
)
assert result is None
- command_handlers = mautrix_telegram.commands.handler.command_handlers
+ command_handlers = mautrix.bridge.commands.handler.command_handlers
command_handlers["help"].mock.assert_not_called() # type: ignore
command_handlers["unknown-command"].mock.assert_called_once() # type: ignore
@@ -345,16 +348,16 @@ class TestCommandProcessor:
mocker: MockFixture) -> None:
mocker.patch('mautrix_telegram.user.config', self.config)
mocker.patch(
- 'mautrix_telegram.commands.handler.command_handlers',
+ 'mautrix.bridge.commands.handler.command_handlers',
{"help": AsyncMock(), "unknown-command": AsyncMock()}
)
- sender = u.User(MatrixUserID("@sender:example.org"))
+ sender = u.User(UserID("@sender:example.org"))
sender.command_status = {"foo": AsyncMock(), "next": AsyncMock()}
result = await command_processor.handle(
- room=MatrixRoomID("#mock_room:example.org"),
- event_id=MatrixEventID("$H45H:example.org"),
+ room_id=RoomID("#mock_room:example.org"),
+ event_id=EventID("$H45H:example.org"),
sender=sender, # u.User
command="foo",
args=[],
@@ -363,7 +366,7 @@ class TestCommandProcessor:
)
assert result is None
- command_handlers = mautrix_telegram.commands.handler.command_handlers
+ command_handlers = mautrix.bridge.commands.handler.command_handlers
command_handlers["help"].mock.assert_not_called() # type: ignore
command_handlers["unknown-command"].mock.assert_not_called() # type: ignore
sender.command_status["foo"].mock.assert_not_called() # type: ignore