Tulir Asokan
399 lines
14 KiB
Python
399 lines
14 KiB
Python
# -*- coding: future_fstrings -*-
|
|
# mautrix-telegram - A Matrix-Telegram puppeting bridge
|
|
# Copyright (C) 2018 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 <https://www.gnu.org/licenses/>.
|
|
from difflib import SequenceMatcher
|
|
from typing import Optional, Awaitable
|
|
import re
|
|
import logging
|
|
import asyncio
|
|
|
|
from telethon.tl.types import UserProfilePhoto
|
|
from mautrix_appservice import AppService, IntentAPI, MatrixRequestError
|
|
|
|
from .db import Puppet as DBPuppet
|
|
from . import util, matrix
|
|
|
|
config = None
|
|
|
|
|
|
class Puppet:
|
|
log = logging.getLogger("mau.puppet")
|
|
db = None
|
|
az = None # type: AppService
|
|
mx = None # type: matrix.MatrixHandler
|
|
loop = None # type: asyncio.AbstractEventLoop
|
|
mxid_regex = None
|
|
username_template = None
|
|
hs_domain = None
|
|
cache = {}
|
|
by_custom_mxid = {}
|
|
|
|
def __init__(self, id=None, access_token=None, custom_mxid=None, username=None,
|
|
displayname=None, displayname_source=None, photo_id=None, is_bot=None,
|
|
is_registered=False, db_instance=None):
|
|
self.id = id
|
|
self.access_token = access_token
|
|
self.custom_mxid = custom_mxid
|
|
self.is_real_user = self.custom_mxid and self.access_token
|
|
self.default_mxid = self.get_mxid_from_id(self.id)
|
|
self.mxid = self.custom_mxid or self.default_mxid
|
|
|
|
self.username = username
|
|
self.displayname = displayname
|
|
self.displayname_source = displayname_source
|
|
self.photo_id = photo_id
|
|
self.is_bot = is_bot
|
|
self.is_registered = is_registered
|
|
self._db_instance = db_instance
|
|
|
|
self.default_mxid_intent = self.az.intent.user(self.default_mxid)
|
|
self.intent = None # type: IntentAPI
|
|
self.refresh_intents()
|
|
|
|
self.cache[id] = self
|
|
if self.custom_mxid:
|
|
self.by_custom_mxid[self.custom_mxid] = self
|
|
|
|
def refresh_intents(self):
|
|
self.is_real_user = self.custom_mxid and self.access_token
|
|
self.intent = (self.az.intent.user(self.custom_mxid, self.access_token)
|
|
if self.is_real_user else self.default_mxid_intent)
|
|
|
|
@property
|
|
def tgid(self):
|
|
return self.id
|
|
|
|
async def switch_mxid(self, access_token, mxid):
|
|
prev_mxid = self.custom_mxid
|
|
self.custom_mxid = mxid
|
|
self.access_token = access_token
|
|
self.refresh_intents()
|
|
|
|
err = await self.init_custom_mxid()
|
|
if err != 0:
|
|
return err
|
|
|
|
try:
|
|
del self.by_custom_mxid[prev_mxid]
|
|
except KeyError:
|
|
pass
|
|
self.mxid = self.custom_mxid or self.default_mxid
|
|
self.by_custom_mxid[self.mxid] = self
|
|
self.save()
|
|
return 0
|
|
|
|
async def init_custom_mxid(self):
|
|
if not self.is_real_user:
|
|
return 0
|
|
|
|
mxid = await self.intent.whoami()
|
|
if not mxid or mxid != self.custom_mxid:
|
|
self.custom_mxid = None
|
|
self.access_token = None
|
|
self.refresh_intents()
|
|
if mxid != self.custom_mxid:
|
|
return 2
|
|
return 1
|
|
asyncio.ensure_future(self.sync(), loop=self.loop)
|
|
return 0
|
|
|
|
def create_sync_filter(self) -> Awaitable[str]:
|
|
return self.intent.client.create_filter(self.custom_mxid, {
|
|
"room": {
|
|
"include_leave": False,
|
|
"state": {
|
|
"types": []
|
|
},
|
|
"timeline": {
|
|
"types": [],
|
|
},
|
|
"ephemeral": {
|
|
"types": ["m.typing", "m.receipt"]
|
|
},
|
|
"account_data": {
|
|
"types": []
|
|
}
|
|
},
|
|
"account_data": {
|
|
"types": [],
|
|
},
|
|
"presence": {
|
|
"types": ["m.presence"]
|
|
},
|
|
})
|
|
|
|
def handle_sync(self, presence, ephemeral):
|
|
presence = [self.mx.try_handle_event(event) for event in presence]
|
|
|
|
for room_id, events in ephemeral.items():
|
|
for event in events:
|
|
event["room_id"] = room_id
|
|
|
|
ephemeral = [self.mx.try_handle_event(event)
|
|
for events in ephemeral.values()
|
|
for event in events]
|
|
|
|
events = ephemeral + presence
|
|
coro = asyncio.gather(*events, loop=self.loop)
|
|
asyncio.ensure_future(coro, loop=self.loop)
|
|
|
|
async def sync(self):
|
|
try:
|
|
await self._sync()
|
|
except Exception:
|
|
self.log.exception("Fatal error syncing")
|
|
|
|
async def _sync(self):
|
|
if not self.is_real_user:
|
|
self.log.warning("Called sync() for non-custom puppet.")
|
|
return
|
|
custom_mxid = self.custom_mxid
|
|
access_token_at_start = self.access_token
|
|
errors = 0
|
|
next_batch = None
|
|
filter_id = await self.create_sync_filter()
|
|
self.log.debug(f"Starting syncer for {custom_mxid} with sync filter {filter_id}.")
|
|
while access_token_at_start == self.access_token:
|
|
try:
|
|
sync_resp = await self.intent.client.sync(filter=filter_id, since=next_batch)
|
|
errors = 0
|
|
if next_batch is not None:
|
|
presence = sync_resp.get("presence", {}).get("events", [])
|
|
ephemeral = {room: data.get("ephemeral", {}).get("events", [])
|
|
for room, data
|
|
in sync_resp.get("rooms", {}).get("join", {}).items()}
|
|
self.handle_sync(presence, ephemeral)
|
|
next_batch = sync_resp.get("next_batch", None)
|
|
except MatrixRequestError as e:
|
|
wait = min(errors, 11) ** 2
|
|
self.log.warning(f"Syncer for {custom_mxid} errored: {e}. "
|
|
f"Waiting for {wait} seconds...")
|
|
errors += 1
|
|
await asyncio.sleep(wait)
|
|
self.log.debug(f"Syncer for custom puppet {custom_mxid} stopped.")
|
|
|
|
async def is_logged_in(self):
|
|
return True
|
|
|
|
@property
|
|
def db_instance(self):
|
|
if not self._db_instance:
|
|
self._db_instance = self.new_db_instance()
|
|
return self._db_instance
|
|
|
|
def new_db_instance(self):
|
|
return DBPuppet(id=self.id, access_token=self.access_token, custom_mxid=self.custom_mxid,
|
|
username=self.username, displayname=self.displayname,
|
|
displayname_source=self.displayname_source, photo_id=self.photo_id,
|
|
is_bot=self.is_bot, matrix_registered=self.is_registered)
|
|
|
|
@classmethod
|
|
def from_db(cls, db_puppet):
|
|
return Puppet(db_puppet.id, db_puppet.access_token, db_puppet.custom_mxid,
|
|
db_puppet.username, db_puppet.displayname, db_puppet.displayname_source,
|
|
db_puppet.photo_id, db_puppet.is_bot, db_puppet.matrix_registered,
|
|
db_instance=db_puppet)
|
|
|
|
def save(self):
|
|
self.db_instance.access_token = self.access_token
|
|
self.db_instance.custom_mxid = self.custom_mxid
|
|
self.db_instance.username = self.username
|
|
self.db_instance.displayname = self.displayname
|
|
self.db_instance.displayname_source = self.displayname_source
|
|
self.db_instance.photo_id = self.photo_id
|
|
self.db_instance.is_bot = self.is_bot
|
|
self.db_instance.matrix_registered = self.is_registered
|
|
self.db.commit()
|
|
|
|
def similarity(self, query):
|
|
username_similarity = (SequenceMatcher(None, self.username, query).ratio()
|
|
if self.username else 0)
|
|
displayname_similarity = (SequenceMatcher(None, self.displayname, query).ratio()
|
|
if self.displayname else 0)
|
|
similarity = max(username_similarity, displayname_similarity)
|
|
return round(similarity * 1000) / 10
|
|
|
|
@staticmethod
|
|
def get_displayname(info, format=True):
|
|
data = {
|
|
"phone number": info.phone if hasattr(info, "phone") else None,
|
|
"username": info.username,
|
|
"full name": " ".join([info.first_name or "", info.last_name or ""]).strip(),
|
|
"full name reversed": " ".join([info.first_name or "", info.last_name or ""]).strip(),
|
|
"first name": info.first_name,
|
|
"last name": info.last_name,
|
|
}
|
|
preferences = config.get("bridge.displayname_preference",
|
|
["full name", "username", "phone"])
|
|
name = None
|
|
for preference in preferences:
|
|
name = data[preference]
|
|
if name:
|
|
break
|
|
|
|
if info.deleted:
|
|
name = f"Deleted account {info.id}"
|
|
elif not name:
|
|
name = info.id
|
|
|
|
if not format:
|
|
return name
|
|
return config.get("bridge.displayname_template", "{displayname} (Telegram)").format(
|
|
displayname=name)
|
|
|
|
async def update_info(self, source, info):
|
|
changed = False
|
|
if self.username != info.username:
|
|
self.username = info.username
|
|
changed = True
|
|
|
|
changed = await self.update_displayname(source, info) or changed
|
|
if isinstance(info.photo, UserProfilePhoto):
|
|
changed = await self.update_avatar(source, info.photo.photo_big) or changed
|
|
|
|
self.is_bot = info.bot
|
|
|
|
if changed:
|
|
self.save()
|
|
|
|
async def update_displayname(self, source, info):
|
|
ignore_source = (not source.is_relaybot
|
|
and self.displayname_source is not None
|
|
and self.displayname_source != source.tgid)
|
|
if ignore_source:
|
|
return
|
|
|
|
displayname = self.get_displayname(info)
|
|
if displayname != self.displayname:
|
|
await self.default_mxid_intent.set_display_name(displayname)
|
|
self.displayname = displayname
|
|
self.displayname_source = source.tgid
|
|
return True
|
|
elif source.is_relaybot or self.displayname_source is None:
|
|
self.displayname_source = source.tgid
|
|
return True
|
|
|
|
async def update_avatar(self, source, photo):
|
|
photo_id = f"{photo.volume_id}-{photo.local_id}"
|
|
if self.photo_id != photo_id:
|
|
file = await util.transfer_file_to_matrix(self.db, source.client,
|
|
self.default_mxid_intent, photo)
|
|
if file:
|
|
await self.default_mxid_intent.set_avatar(file.mxc)
|
|
self.photo_id = photo_id
|
|
return True
|
|
return False
|
|
|
|
@classmethod
|
|
def get(cls, id, create=True) -> "Optional[Puppet]":
|
|
try:
|
|
return cls.cache[id]
|
|
except KeyError:
|
|
pass
|
|
|
|
puppet = DBPuppet.query.get(id)
|
|
if puppet:
|
|
return cls.from_db(puppet)
|
|
|
|
if create:
|
|
puppet = cls(id)
|
|
cls.db.add(puppet.db_instance)
|
|
cls.db.commit()
|
|
return puppet
|
|
|
|
return None
|
|
|
|
@classmethod
|
|
def get_by_mxid(cls, mxid, create=True) -> "Optional[Puppet]":
|
|
tgid = cls.get_id_from_mxid(mxid)
|
|
return cls.get(tgid, create) if tgid else None
|
|
|
|
@classmethod
|
|
def get_by_custom_mxid(cls, mxid):
|
|
if not mxid:
|
|
raise ValueError("Matrix ID can't be empty")
|
|
|
|
try:
|
|
return cls.by_custom_mxid[mxid]
|
|
except KeyError:
|
|
pass
|
|
|
|
puppet = DBPuppet.query.filter(DBPuppet.custom_mxid == mxid).one_or_none()
|
|
if puppet:
|
|
puppet = cls.from_db(puppet)
|
|
return puppet
|
|
|
|
return None
|
|
|
|
@classmethod
|
|
def get_all_with_custom_mxid(cls):
|
|
return [cls.by_custom_mxid[puppet.mxid]
|
|
if puppet.custom_mxid in cls.by_custom_mxid
|
|
else cls.from_db(puppet)
|
|
for puppet in DBPuppet.query.filter(DBPuppet.custom_mxid is not None).all()]
|
|
|
|
@classmethod
|
|
def get_id_from_mxid(cls, mxid):
|
|
match = cls.mxid_regex.match(mxid)
|
|
if match:
|
|
return int(match.group(1))
|
|
return None
|
|
|
|
@classmethod
|
|
def get_mxid_from_id(cls, id):
|
|
return f"@{cls.username_template.format(userid=id)}:{cls.hs_domain}"
|
|
|
|
@classmethod
|
|
def find_by_username(cls, username) -> "Optional[Puppet]":
|
|
if not username:
|
|
return None
|
|
|
|
for _, puppet in cls.cache.items():
|
|
if puppet.username and puppet.username.lower() == username.lower():
|
|
return puppet
|
|
|
|
puppet = DBPuppet.query.filter(DBPuppet.username == username).one_or_none()
|
|
if puppet:
|
|
return cls.from_db(puppet)
|
|
|
|
return None
|
|
|
|
@classmethod
|
|
def find_by_displayname(cls, displayname) -> "Optional[Puppet]":
|
|
if not displayname:
|
|
return None
|
|
|
|
for _, puppet in cls.cache.items():
|
|
if puppet.displayname and puppet.displayname == displayname:
|
|
return puppet
|
|
|
|
puppet = DBPuppet.query.filter(DBPuppet.displayname == displayname).one_or_none()
|
|
if puppet:
|
|
return cls.from_db(puppet)
|
|
|
|
return None
|
|
|
|
|
|
def init(context):
|
|
global config
|
|
Puppet.az, Puppet.db, config, Puppet.loop, _ = context
|
|
Puppet.mx = context.mx
|
|
Puppet.username_template = config.get("bridge.username_template", "telegram_{userid}")
|
|
Puppet.hs_domain = config["homeserver"]["domain"]
|
|
localpart = Puppet.username_template.format(userid="(.+)")
|
|
Puppet.mxid_regex = re.compile(f"@{localpart}:{Puppet.hs_domain}")
|
|
return [puppet.init_custom_mxid() for puppet in Puppet.get_all_with_custom_mxid()]
|