async def get_me(self) -> TLUser | None:
try:
return (await self.client(GetUsersRequest([InputUserSelf()])))[0]
except UnauthorizedError as e:
self.log.error(f"Authorization error in get_me(): {type(e)}: {e}")
await self.push_bridge_state(
BridgeStateEvent.BAD_CREDENTIALS, error="tg-auth-error", message=str(e), ttl=3600
)
await self.stop()
return None
async def on_update_chan(e):
channel_id = utils.get_peer_id(PeerChannel(e.channel_id))
entity = e._entities.get(channel_id)
if isinstance(entity, tl.types.ChannelForbidden):
return
if isinstance(entity, tl.types.Channel) and entity.left:
return
channel = await borg.get_input_entity(channel_id)
self_participant = await borg(GetParticipantRequest(channel, InputUserSelf()))
if not hasattr(self_participant.participant, 'inviter_id'):
return
inviter_id = self_participant.participant.inviter_id
await on_added(inviter_id, channel_id)
def get_messages(client,
peer_id: Union[Channel],
peer_hash: str,
delete_up_to_date,
limit: int = 100,
offset_id: int = 0,
max_id: int = 0,
min_id: int = 0) -> List[int]:
print(
f'[INFO] Getting messages from peer {peer_id} for user '
f'{client.get_me().username or client.get_me().first_name} until the date {delete_up_to_date}...'
)
add_offset = 0
messages: List[int] = []
while True:
time.sleep(0.1)
search_result = client(
SearchRequest(peer=InputPeerChannel(peer_id, peer_hash),
q='',
filter=InputMessagesFilterEmpty(),
min_date=None,
max_date=None,
offset_id=offset_id,
add_offset=add_offset,
limit=limit,
max_id=max_id,
min_id=min_id,
from_id=InputUserSelf(),
hash=0))
if search_result.messages:
print(
f'[INFO] Received: {len(search_result.messages)} messages. Offset: {add_offset}.'
)
for post in search_result.messages:
if post.date.replace(tzinfo=None) > delete_up_to_date:
messages.extend([post])
add_offset += 1
else:
return messages
else:
print("[INFO] It's stopped because met end of chat.")
return messages
async def purge(client: Client, chat: Channel, msg: Message, args,
kwargs: Dict, event) -> None:
"""Purge all messages from the the point the command was sent to the message that was replied to.
Arguments:
`count`: Delete `count` messages
Examples:
{cmd}
"""
sure = kwargs.get('YesImSure', False)
await msg.delete()
if not chat.megagroup:
return
if not msg.is_reply:
if args:
count = args[0]
message_ids = [msg.id]
async for m in client.iter_messages(chat,
limit=count,
offset_id=msg.id):
message_ids.append(m.id)
else:
return
else:
reply_msg: Message = await msg.get_reply_message()
if event.is_private:
message_ids = await client.get_messages(chat,
min_id=reply_msg.id,
max_id=msg.id)
else:
message_ids = list(range(reply_msg.id, msg.id))
me_user = await client(GetUsersRequest([InputUserSelf()]))
me = me_user[0].id
if sure or msg.sender_id == me:
await client.delete_messages(chat, message_ids)
else:
await client.respond(
reply_msg,
'Please use -YesImSure to clarify you understand the extend of your actions!!'
)
async def _callback(cmd: _Command, args: _Signature, admins: bool, event: NewMessage.Event) -> None:
"""Wrapper around a plugins callback to dynamically pass requested arguments
Args:
args: The arguments of the plugin callback
event: The NewMessage Event
"""
client = event.client
msg: Message = event.message
me_user = await client(GetUsersRequest([InputUserSelf()]))
me = me_user[0]
if msg.via_bot_id is not None:
return
if msg.forward is not None:
forward: Forward = msg.forward
if forward.sender_id is None or forward.sender_id != me.id:
return
if msg.sticker is not None or msg.dice is not None:
return
callback = cmd.callback
skip_args = 1
help_topic = [cmd.commands[0]]
delete = cmd.delete
if cmd.subcommands:
raw_args = msg.raw_text.split()[1:]
if raw_args:
subcommand: Optional[_SubCommand] = cmd.subcommands.get(raw_args[0])
if subcommand:
callback = subcommand.callback
skip_args = 2
args: _Signature = subcommand.signature
cmd: _SubCommand = subcommand
delete = cmd.delete
help_topic.append(cmd.command)
command_name = ''
if isinstance(cmd, _Command):
command_name = cmd.commands[0]
elif isinstance(cmd, _SubCommand):
command_name = cmd.command
_kwargs, _args = await helpers.get_args(event, skip=skip_args)
chat = await event.get_chat()
if admins and event.is_channel:
uid = event.message.sender_id
own_id = (await client.get_me()).id
if uid != own_id and _kwargs.get('self', False) or (not chat.creator and not chat.admin_rights):
return
result = await client(GetParticipantRequest(event.chat_id, uid))
if not isinstance(result.participant, (ChannelParticipantAdmin, ChannelParticipantCreator)) and uid != own_id:
return
if _kwargs.get('help', False):
_cmd: Optional[_Command] = PluginManager.commands.get('help')
if _cmd:
cmd = _cmd
args: _Signature = cmd.signature
callback = cmd.callback
_args = help_topic
_kwargs = {}
callback_args = {}
if args.client:
callback_args['client'] = client
if args.db:
callback_args['db'] = client.db
if args.chat:
callback_args['chat'] = chat
if args.msg:
callback_args['msg'] = event.message
if args.args or args.kwargs:
if args.args:
callback_args['args'] = _args
if args.kwargs:
callback_args['kwargs'] = _kwargs
if args.event:
callback_args['event'] = event
if args.tags:
callback_args['tags'] = await Tags.from_event(event)
if admins and event.from_id != me.id:
try:
entity = await client.get_cached_entity(event.from_id)
name = get_display_name(entity)
except GET_ENTITY_ERRORS:
name = str(event.from_id)
user_link = Mention(name, event.from_id)
group_link = Link(get_display_name(await event.get_chat()), f't.me/c/{event.chat.id}/{event.message.id}')
tlog.info(f'{user_link} ran {Code(command_name)} in {group_link}')
result = None
try:
if delete:
await event.delete()
result = await callback(**callback_args)
if result and cmd.auto_respond:
await client.respond(event, str(result), reply=not delete)
except MessageTooLongError:
if result:
f = BytesIO(str(result).encode())
await client.send_file(chat, f.getvalue(),
attributes=[DocumentAttributeFilename('command_output.md')],
caption='Command output too long.', reply_to=event)
else:
raise
except Exception as err:
if cmd.auto_respond:
error_name = err.__class__.__name__
error_name = re.sub(r'([A-Z])', r' \1', error_name)
sec = Section(error_name,
)
if isinstance(err, FloodWaitError):
sec.append(KeyValueItem('duration', timedelta(seconds=err.seconds)))
sec.append(KeyValueItem('cause', Code(err.request.__class__.__name__)))
print(err.request)
else:
sec.append(Italic(err))
await client.respond(event, str(KanTeXDocument(sec)), reply=not delete)
if not isinstance(err, Error):
tlog.error(f'An error occured while running {Code(command_name)}', exc_info=err)
logger.exception(err)