async def thanos(_, message):
chat = message.text.split("/pidor ", maxsplit = 1)[1]
chats = await client.get_dialogs()
dialog = [cht for cht in chats if chat in cht.name][0]
members = await client.get_participants(dialog.id)
process = 0
eyes = emojize(":eyes:", use_aliases=True)
exclamation = emojize(":exclamation:", use_aliases=True)
while(process < 100):
try:
text = f"{eyes} Пои�к пидора ... {process}%"
await message.edit(text)
process += random.randint(1, 3)
await asyncio.sleep(0.1)
except FloodWait as error:
await asyncio.sleep(error.x)
pidor_id = random.choice(members).id
pidor = (await client.get_entity(PeerUser(pidor_id))).username \
if (await client.get_entity(PeerUser(pidor_id))).username \
else (await client.get_entity(PeerUser(pidor_id))).first_name + " " \
+ (await client.get_entity(PeerUser(pidor_id))).last_name \
if (await client.get_entity(PeerUser(pidor_id))).last_name else ''
if pidor:
await message.edit(f"Пидор найден {exclamation} @{pidor}")
else:
await message.edit(f"Пидор не найден {exclamation}")
async def get_input_entity(
user_id: int, chat: Union[int, PeerChat,
PeerChannel]) -> InputPeerUser:
MESSAGES_TO_GET = 10
try:
return await client.get_input_entity(PeerUser(user_id))
except ValueError:
await client.get_messages(chat, MESSAGES_TO_GET)
return await client.get_input_entity(PeerUser(user_id))
def get_sender(update): sender = False if isinstance(update, UpdateShortMessage): sender = client.get_entity(PeerUser(update.user_id)) elif isinstance(update, UpdateNewChannelMessage): sender = client.get_entity(PeerUser(update.message.from_id)) else: # print(update) pass return sender
async def update_displayname(self, source: 'AbstractUser', info: Union[User, UpdateUserName]
) -> bool:
if self.disable_updates:
return False
is_main_source = (source.is_relaybot or (self.displayname_source is not None
and self.displayname_source == source.tgid))
# No phone -> not in contact list -> can't set custom name -> name is trustworthy
is_trustworthy_source = isinstance(info, User) and info.phone is None
if not is_main_source and not is_trustworthy_source:
return False
elif isinstance(info, UpdateUserName):
info = await source.client.get_entity(PeerUser(self.tgid))
displayname = self.get_displayname(info)
if displayname != self.displayname:
self.displayname = displayname
self.displayname_source = source.tgid
try:
await self.default_mxid_intent.set_display_name(displayname)
except MatrixRequestError:
self.log.exception("Failed to set displayname")
self.displayname = ""
self.displayname_source = None
return True
elif source.is_relaybot or self.displayname_source is None:
self.displayname_source = source.tgid
return True
return False
async def get_user_rights_level(self, user_id):
try:
entity = await self.tg_client.get_entity(PeerUser(int(user_id)))
rights = self.get_entity_rights_level(entity)
except:
rights = 0
return rights
async def on_user_message_to_me(self, from_id, message_text):
if not self.aa_options['is_set']:
return
if from_id in self.aa_not_for_users:
return
if (from_id in self.aa_for_users) and self.aa_for_users[from_id]:
return
try:
entity = await self.tg_bot_controller.tg_client.get_entity(
PeerUser(int(from_id)))
except:
return
if (not entity) or (type(entity) != User):
return
user_level = self.tg_bot_controller.get_entity_rights_level(
entity, self.aa_options['from_user_ids'])
if user_level < self.aa_options['from_mode']:
if from_id not in self.aa_not_for_users:
self.aa_not_for_users.append(from_id)
return
self.aa_for_users[from_id] = StatusController.now_local_datetime()
check_user_name = await self.tg_bot_controller.tg_client.get_entity_name(
from_id, 'User')
print(
StatusController.datetime_to_str(datetime.now()) +
' Adding AA schedule for user "' + check_user_name + '"')
if self.aa_options['answer_after_minutes'] <= 0.05:
await self.do_on_timer([from_id])
def update_handler(update):
try:
message = update.message
messages = []
if isinstance(update, UpdateShortMessage):
sender = client.get_entity(PeerUser(update.user_id))
messages.append(update.id)
elif isinstance(update, UpdateNewChannelMessage):
sender = client.get_entity(
PeerChannel(update.message.to_id.channel_id))
# print(update.message.id)
messages.append(update.message.id)
elif isinstance(update, UpdateEditChannelMessage):
pass
else:
# print(type(update))
# print(update)
return False
except Exception as e:
# print(e)
return
try:
client(
ForwardMessagesRequest(
from_peer=sender, # who sent these messages?
id=messages, # which are the messages?
to_peer=InputPeerSelf() # who are we forwarding them to?
))
print("FORWARD")
# print(get_text(update))
except Exception as e:
print("EXCEPTION")
print(get_text(update))
print(e)
def peer(self) -> Union[TypePeer, TypeInputPeer]:
if self.peer_type == "user":
return PeerUser(user_id=self.tgid)
elif self.peer_type == "chat":
return PeerChat(chat_id=self.tgid)
elif self.peer_type == "channel":
return PeerChannel(channel_id=self.tgid)
async def messages(self, limit=100):
dialogs = await self.get_dialogs(limit=limit)
messages = None
mssgs = []
for dialog in dialogs:
user = dialog.entity
if (not isinstance(user, (Channel, Chat))
) and user.first_name.find("bot") < 0 and (not user.is_self):
new_user = await Users.save_user(user.id, user.first_name)
messages = await self.get_messages(user, limit=limit)
for message in messages:
mssgs.append(message)
for message in mssgs:
fro_user = None
to_user = None
fro_entity = await self.get_entity(entity=PeerUser(
user_id=message.from_id))
print("from user:{}, message :{}".format(fro_entity.username,
message.message))
if isinstance(fro_entity, User):
fro_user = await Users.save_user(
user_id=fro_entity.id, first_name=fro_entity.first_name)
t_entity = await self.get_entity(entity=message.to_id)
if isinstance(t_entity, User):
to_user = await Users.save_user(user_id=t_entity.id,
first_name=t_entity.first_name)
print("to user:{}".format(t_entity.username))
msg = await Messages.save_message(message_id=message.id,
from_user=fro_user[0],
to_user=to_user[0],
ts_created=message.date,
message=message)
return len(mssgs)
async def edit_message(room_id, data):
"""
Returns the updated message
"""
async with start_bot_client() as bot:
msg_inst = Message.objects.get(id=data["message_id"])
if msg_inst.from_group:
receiver = await bot.get_entity(PeerChat(room_id))
else:
receiver = await bot.get_entity(PeerUser(room_id))
msg = await bot.get_messages(receiver, ids=msg_inst.telegram_msg_id)
try:
await bot.edit_message(msg, data[MESSAGE])
except MessageIdInvalidError:
logger.exception(exception)
return {
DATA: {
MESSAGE: EDIT_FAIL,
IS_SUCCESS: False
},
STATUS: status.HTTP_400_BAD_REQUEST,
}
msg_inst.message = data[MESSAGE]
msg_inst.save()
return {
DATA: {
MESSAGE: data,
IS_SUCCESS: True
},
STATUS: status.HTTP_200_OK,
}
def add_user_by_id(client, user_id, channel_id=DEFAULT_CHANNEL):
try:
# client.invoke(InviteToChannelRequest(get_input_peer(channel), [get_input_peer(user)]))
# client.invoke(InviteToChannelRequest(
# # InputChannel(get_input_peer(user.chats[0]).channel_id, get_input_peer(user.chats[0]).access_hash),
# InputChannel(channel.id, channel.access_hash),
# [InputUser(get_input_peer(user.users[0]).user_id, get_input_peer(user.users[0]).access_hash)]
# ))
# client.invoke(InviteToChannelRequest(InputChannel(channel.id, channel.access_hash), [InputUser(get_input_peer(user.users[0]).user_id, get_input_peer(user.users[0]).access_hash)]))
# client.invoke(InviteToChannelRequest(client.get_entity(PeerChannel(1188959006)), [user]))
# client.invoke(InviteToChannelRequest(client.get_input_entity(PeerChannel(channel_id)), [client.get_input_entity(PeerUser(user_id=user.users[0].id))]))
user_entity = client.get_input_entity(PeerUser(user_id))
channel_entity = client.get_entity(PeerChannel(channel_id=int(channel_id)))
client.invoke(InviteToChannelRequest(channel_entity, [user_entity]))
log.warning("Added User: {} to Channel: {}".format(user_id, channel_id))
return "User added successfully"
except Exception as err:
reason = err.args[1] if len(err.args) > 1 else err.message
msg = "Add User {} attempt to channel ({}) failed [{}]".format(user_id, channel_id, reason)
log.error(msg)
log.error(err)
return msg
def get_entity_rows_by_id(self, entity_id, exact=True):
if exact:
key = "{}:entities:{}".format(self.sess_prefix, entity_id)
s = self.redis_connection.get(key)
if not s:
return None
try:
s = self._unpack(s)
return entity_id, s["hash"]
except Exception as ex:
__log__.exception(ex.args)
return None
else:
ids = (
utils.get_peer_id(PeerUser(entity_id)),
utils.get_peer_id(PeerChat(entity_id)),
utils.get_peer_id(PeerChannel(entity_id))
)
try:
for key in self._get_entities():
entity = self._unpack(self.redis_connection.get(key))
if "id" in entity and entity["id"] in ids:
return entity["id"], entity["hash"]
except Exception as ex:
__log__.exception(ex.args)
async def update_displayname(self, source: 'AbstractUser',
info: Union[User, UpdateUserName]) -> bool:
if self.disable_updates:
return False
allow_source = (
source.is_relaybot or self.displayname_source == source.tgid
# User is not a contact, so there's no custom name
or not info.contact
# No displayname source, so just trust anything
or self.displayname_source is None)
if not allow_source:
return False
elif isinstance(info, UpdateUserName):
info = await source.client.get_entity(PeerUser(self.tgid))
displayname = self.get_displayname(info)
if displayname != self.displayname:
self.displayname = displayname
self.displayname_source = source.tgid
try:
await self.default_mxid_intent.set_displayname(
displayname[:config["bridge.displayname_max_length"]])
except MatrixRequestError:
self.log.exception("Failed to set displayname")
self.displayname = ""
self.displayname_source = None
return True
elif source.is_relaybot or self.displayname_source is None:
self.displayname_source = source.tgid
return True
return False
async def _add_forward_header(source, text: str, html: Optional[str],
fwd_from: MessageFwdHeader) -> Tuple[str, str]:
if not html:
html = escape(text)
fwd_from_html, fwd_from_text = None, None
if fwd_from.from_id:
user = u.User.get_by_tgid(fwd_from.from_id)
if user:
fwd_from_text = user.displayname or user.mxid
fwd_from_html = f"<a href='https://matrix.to/#/{user.mxid}'>{fwd_from_text}</a>"
if not fwd_from_text:
puppet = pu.Puppet.get(fwd_from.from_id, create=False)
if puppet and puppet.displayname:
fwd_from_text = puppet.displayname or puppet.mxid
fwd_from_html = f"<a href='https://matrix.to/#/{puppet.mxid}'>{fwd_from_text}</a>"
if not fwd_from_text:
user = await source.client.get_entity(PeerUser(fwd_from.from_id))
if user:
fwd_from_text = pu.Puppet.get_displayname(user, format=False)
fwd_from_html = f"<b>{fwd_from_text}</b>"
if not fwd_from_text:
if fwd_from.from_id:
fwd_from_text = "Unknown user"
else:
fwd_from_text = "Unknown source"
fwd_from_html = f"<b>{fwd_from_text}</b>"
text = "\n".join([f"> {line}" for line in text.split("\n")])
text = f"Forwarded from {fwd_from_text}:\n{text}"
html = (f"Forwarded message from {fwd_from_html}<br/>"
f"<tg-forward><blockquote>{html}</blockquote></tg-forward>")
return text, html
async def send_message(self, to_id):
message_text = self.aa_options['message']
message = message_text.replace(
'[username]', self.tg_bot_controller.tg_client.me_user_name)
if message.find('[statistics]') >= 0:
stats_str = await self.tg_bot_controller.tg_client.status_controller.get_user_aa_statistics_text(
self.tg_bot_controller.tg_client.me_user_id)
message = message.replace('[statistics]', '\n' + stats_str)
if self.aa_options['show_bot']:
message = self.tg_bot_controller.text_to_bot_text(
message, to_id, "dialog")
else:
message = self.tg_bot_controller.text_to_bot_text(
message, to_id, "bot")
to_username = await self.tg_bot_controller.tg_client.get_entity_name(
to_id, 'User')
msg_log = StatusController.datetime_to_str(datetime.now(
)) + ' Sending AA message to user "' + to_username + '"'
msg_log = msg_log + '\n' + '<<< ' + message
print(msg_log)
await self.tg_bot_controller.tg_client.send_message(
PeerUser(to_id), message)
if self.aa_options['notify_entity_id']:
msg_log = StatusController.datetime_to_str(datetime.now(
)) + ' Отправляем сообщение пользователю {}'.format(
await self.tg_bot_controller.user_link(to_id, to_username))
msg_log = msg_log + '\n\n' + '``` ' + message + '```'
await self.send_message_to_user(
self.aa_options['notify_entity_id'],
msg_log,
do_set_next=False)
def _send(ids):
for send_id in ids[60:]:
nonlocal counter
counter += 1
print('I send to client msg')
user = client.get_entity(PeerUser(send_id))
sec = 5
try:
client.send_message(user, text)
except FloodWaitError as error:
sec = int(str(error).split(' ')[3])
print('FLOOD, please sleep {}'.format(sec))
except PeerFloodError as error:
print(str(error))
sleep(5)
nonlocal count
count -= 1
print('Отправлено: {}'.format(counter))
print('Осталось отправить: {}'.format(count))
print('I sleep 5 seconds')
sleep(sec)
print('continue')
return print('I finished the newsletter')
async def test(event):
channel = -1001477006210
global data
global data_1
global data_2
# name = get_display_name(event.original_update.user_id)
name = await bot.get_entity(PeerUser(event.original_update.user_id))
msg = f"[{name.first_name}](tg://user?id={name.id})"
# message_link = f"tg://openmessage?chat_id={event.original_update.peer.channel_id}&message_id={event.original_update.msg_id}"
message_link = f"https://t.me/c/{event.original_update.peer.channel_id}/{event.original_update.msg_id}"
if event.data.decode('utf-8') == "up":
data += 1
buton = tgbot.build_reply_markup([
Button.inline(f"👍🏻 {data}", data="up"),
Button.inline(f"❤️ {data_1}", data="kalp"),
Button.inline(f"😢 {data_2}", data="agla")
])
await tgbot.edit_message(channel,
event.original_update.msg_id,
buttons=buton)
await bot.send_message(
-443785781,
f"Tıklayan: {msg}, 👍 e tıkladı.\n\nMesaja git: {message_link}")
reply_pop_up_alert = "@RetroTurk Katılımınız İçin Teşekkür Eder."
await event.answer(reply_pop_up_alert, cache_time=0, alert=True)
# data += 1
if event.data.decode('utf-8') == "kalp":
data_1 += 1
buton = tgbot.build_reply_markup([
Button.inline(f"👍🏻 {data}", data="up"),
Button.inline(f"❤️ {data_1}", data="kalp"),
Button.inline(f"😢 {data_2}", data="agla")
])
await tgbot.edit_message(channel,
event.original_update.msg_id,
buttons=buton)
await bot.send_message(
-443785781,
f"Tıklayan: {msg}, ❤️ e tıkladı.\n\nMesaja git: {message_link}")
reply_pop_up_alert = "@RetroTurk Katılımınız İçin Teşekkür Eder."
await event.answer(reply_pop_up_alert, cache_time=0, alert=True)
# data_1 += 1
if event.data.decode('utf-8') == "agla":
data_2 += 1
buton = tgbot.build_reply_markup([
Button.inline(f"👍🏻 {data}", data="up"),
Button.inline(f"❤️ {data_1}", data="kalp"),
Button.inline(f"😢 {data_2}", data="agla")
])
await tgbot.edit_message(channel,
event.original_update.msg_id,
buttons=buton)
await bot.send_message(
-443785781,
f"Tıklayan: {msg}, 😢 e tıkladı.\n\nMesaja git: {message_link}")
reply_pop_up_alert = "@RetroTurk Katılımınız İçin Teşekkür Eder."
await event.answer(reply_pop_up_alert, cache_time=0, alert=True)
async def init_chat_for_user(self, user_id, entity_id=None, in_bot=False, show_as_bot=None):
str_user_id = str(user_id)
if not entity_id:
entity_id = user_id
if in_bot and self.tg_client.tg_bot:
bot_chat_dialog = self.entity_controller.get_user_bot_chat(user_id)
if not bot_chat_dialog and self.tg_client.tg_bot:
bot_chat_dialog = await self.tg_client.tg_bot.get_input_entity(PeerUser(user_id))
is_bot_dialog = True
message_client = self.tg_client.tg_bot
else:
is_bot_dialog = False
message_client = self.tg_client
bot_chat_dialog = PeerUser(entity_id)
if str_user_id not in self.users:
try:
entity = await self.tg_client.get_entity(PeerUser(int(user_id)))
rights = self.get_entity_rights_level(entity)
except:
rights = 0
self.users[str_user_id] = {
'active': True,
'branch': None,
'branch_path': '/',
'active_message_id': None,
'last_message_id': None,
'last_next_message_id': None,
'rights': rights,
'show_as_bot': show_as_bot,
'message_client': message_client,
'is_bot_dialog': is_bot_dialog,
'dialog_entity': bot_chat_dialog,
'entity_user_id': user_id,
'entity_user_name': await self.tg_client.get_entity_name(user_id, 'User')
}
await self.on_user_init(user_id)
else:
self.users[str_user_id]['active'] = True
if show_as_bot is not None:
self.users[str_user_id]['show_as_bot'] = show_as_bot
self.users[str_user_id]['message_client'] = message_client
self.users[str_user_id]['is_bot_dialog'] = is_bot_dialog
self.users[str_user_id]['dialog_entity'] = bot_chat_dialog
async def get_entity(chat_id, client):
try:
entity = await client.get_entity(PeerUser(chat_id))
except:
try:
entity = await client.get_entity(PeerChannel(chat_id))
except:
entity = await client.get_entity(PeerChat(chat_id))
return entity
async def get_user_link(self, user_id, chat_name):
await self.client.connect()
await self.client.get_participants(chat_name)
entity = await self.client.get_entity(PeerUser(user_id))
enter = str(entity).find('access_hash')
access_hash = str(entity)[enter + 13:enter + 32]
link = "https://web.telegram.org/#/im?p=u" + str(
user_id) + "_" + access_hash
return link
def get_entity_rows_by_id(self, id, exact=True):
with switch_db(Entity, self.database) as _Entity:
if exact:
return _Entity.objects(id=id)
else:
ids = (utils.get_peer_id(PeerUser(id)),
utils.get_peer_id(PeerChat(id)),
utils.get_peer_id(PeerChannel(id)))
return _Entity.objects(id__in=ids)
async def _add_forward_header(source: 'AbstractUser', content: TextMessageEventContent,
fwd_from: MessageFwdHeader) -> None:
if not content.formatted_body or content.format != Format.HTML:
content.format = Format.HTML
content.formatted_body = escape(content.body)
fwd_from_html, fwd_from_text = None, None
if fwd_from.from_id:
user = u.User.get_by_tgid(TelegramID(fwd_from.from_id))
if user:
fwd_from_text = user.displayname or user.mxid
fwd_from_html = (f"<a href='https://matrix.to/#/{user.mxid}'>"
f"{escape(fwd_from_text)}</a>")
if not fwd_from_text:
puppet = pu.Puppet.get(TelegramID(fwd_from.from_id), create=False)
if puppet and puppet.displayname:
fwd_from_text = puppet.displayname or puppet.mxid
fwd_from_html = (f"<a href='https://matrix.to/#/{puppet.mxid}'>"
f"{escape(fwd_from_text)}</a>")
if not fwd_from_text:
try:
user = await source.client.get_entity(PeerUser(fwd_from.from_id))
if user:
fwd_from_text = pu.Puppet.get_displayname(user, False)
fwd_from_html = f"<b>{escape(fwd_from_text)}</b>"
except ValueError:
fwd_from_text = fwd_from_html = "unknown user"
elif fwd_from.channel_id:
portal = po.Portal.get_by_tgid(TelegramID(fwd_from.channel_id))
if portal:
fwd_from_text = portal.title
if portal.alias:
fwd_from_html = (f"<a href='https://matrix.to/#/{portal.alias}'>"
f"{escape(fwd_from_text)}</a>")
else:
fwd_from_html = f"channel <b>{escape(fwd_from_text)}</b>"
else:
try:
channel = await source.client.get_entity(PeerChannel(fwd_from.channel_id))
if channel:
fwd_from_text = f"channel {channel.title}"
fwd_from_html = f"channel <b>{escape(channel.title)}</b>"
except ValueError:
fwd_from_text = fwd_from_html = "unknown channel"
elif fwd_from.from_name:
fwd_from_text = fwd_from.from_name
fwd_from_html = f"<b>{escape(fwd_from.from_name)}</b>"
else:
fwd_from_text = "unknown source"
fwd_from_html = f"unknown source"
content.body = "\n".join([f"> {line}" for line in content.body.split("\n")])
content.body = f"Forwarded from {fwd_from_text}:\n{content.body}"
content.formatted_body = (
f"Forwarded message from {fwd_from_html}<br/>"
f"<tg-forward><blockquote>{content.formatted_body}</blockquote></tg-forward>")
def get_entity_rows_by_id(self, id, exact=True):
if exact:
query = "SELECT * FROM c WHERE c.id = {}".format(id)
else:
query = "SELECT * FROM c WHERE c.id in ({}, {}, {})".format(
utils.get_peer_id(PeerUser(id)),
utils.get_peer_id(PeerChat(id)),
utils.get_peer_id(PeerChannel(id))
)
return self.get_entity_from_container(query)
async def end_handler(cls, event: events.NewMessage.Event):
players = [mention_markdown(await client.get_entity(PeerUser(p[0].url)))
if isinstance(p[0], MessageEntityTextUrl)
else f"**{p[1]}**" for p in [e for e in event.get_entities_text()
if isinstance(e[0], (MessageEntityBold, MessageEntityTextUrl))]]
base_score = 1 if len(players) < 6 else 1
res = tuple(zip(players, [True if line[-1] == "贏" else False
for line in event.raw_text.split("\n\n\n")[0].split("\n")]))
results = {"won": [p[0] for p in res if p[1]], "lost": [p[0] for p in res if not p[1]]}
to_send = f"呢場狼人玩完咗啦。\n\n呢局有{len(players)}個玩家，你哋每人至少會獲得{base_score}參與分。"
def get_entity_rows_by_id(self, key, exact=True):
if exact:
row = models.Entity.objects.filter(id=key).first()
else:
ids = (utils.get_peer_id(PeerUser(key)),
utils.get_peer_id(PeerChat(key)),
utils.get_peer_id(PeerChannel(key)))
row = models.Entity.objects.filter(id__in=ids).first()
return (row.id, row.hash) if row else None
def effective_chat_id(update):
if update.CONSTRUCTOR_ID == 0x914fbf11:
return (update.user_id, PeerUser(update.user_id))
elif update.CONSTRUCTOR_ID == 0x16812688:
return (update.chat_id, PeerChat(update.chat_id))
else:
return (update.message.to_id.channel_id, update.message.to_id)
def get_entity_rows_by_id(self, key, exact=True):
if exact:
query = self._db_query(self.Entity, self.Entity.id == key)
else:
ids = (utils.get_peer_id(PeerUser(key)),
utils.get_peer_id(PeerChat(key)),
utils.get_peer_id(PeerChannel(key)))
query = self._db_query(self.Entity, self.Entity.id in ids)
row = query.one_or_none()
return (row.id, row.hash) if row else None
async def get_from_id_param(self, from_id, params):
if params and (len(params) > 0) and params[0]:
try:
entity = await self.tg_bot_controller.tg_client.get_entity(str(params[0]).strip())
except ValueError:
try:
entity = await self.tg_bot_controller.tg_client.get_entity(PeerUser(int(params[0])))
except:
entity = None
if type(entity) == User:
from_id = entity.id
return from_id
async def _add_telegram_user(self, user_id: TelegramID, source: Optional['AbstractUser'] = None
) -> None:
puppet = p.Puppet.get(user_id)
if source:
entity: User = await source.client.get_entity(PeerUser(user_id))
await puppet.update_info(source, entity)
await puppet.intent_for(self).ensure_joined(self.mxid)
user = u.User.get_by_tgid(user_id)
if user:
user.register_portal(self)
await self.invite_to_matrix(user.mxid)
def get_entity_rows_by_id(self, key: int, exact: bool = True) -> Optional[Tuple[int, int]]:
if exact:
query = self._db_query(self.Entity, self.Entity.id == key)
else:
ids = (
utils.get_peer_id(PeerUser(key)),
utils.get_peer_id(PeerChat(key)),
utils.get_peer_id(PeerChannel(key))
)
query = self._db_query(self.Entity, self.Entity.id.in_(ids))
row = query.one_or_none()
return (row.id, row.hash) if row else None
