def new_chat_member(self, client: Client, msg: Message):
if self.bot_id in msg.new_chat_members:
self.groups.insert_group(msg.chat.id)
msg.reply('Please use /setwelcome to set welcome message')
#msg.reply('This bot is refactoring code, feature may not available during this time')
else:
group_setting = self.groups[msg.chat.id]
if group_setting is None:
group_setting = self.groups.insert_group(msg.chat.id)
welcome_text = group_setting.welcome_text
if welcome_text is not None:
try:
last_msg = msg.reply(
welcome_text.replace('$name',
parse_user_name(msg.from_user)),
parse_mode='markdown',
disable_web_page_preview=True).message_id
except pyrogram.errors.ChatWriteForbidden:
logger.error('Got ChatWriterForbidden in %d', msg.chat.id)
msg.chat.leave()
self.groups.delete_group(msg.chat.id)
return
previous_msg = self.conn.query_last_message_id(msg.chat.id)
self.conn.insert_last_message_id(msg.chat.id, last_msg)
if self.groups[msg.chat.id].no_welcome:
if previous_msg is not None:
client.delete_messages(msg.chat.id, previous_msg)
def wrapped(client: Client, message: Message, *args, **kwargs):
user_id = message.from_user.id
chat_id = message.chat.id
if user_id in config.telegram.admins:
logger.debug('%d is admin in %d', user_id, chat_id)
return func(client, message, *args, **kwargs)
@MWT(timeout=60 * 60 * 4)
def get_admins(ids_only=False):
logger.debug('executing get_chat_members request')
chat_admins = client.get_chat_members(chat_id, filter='administrators')
if ids_only:
return [a.user.id for a in chat_admins]
return chat_admins
admins = get_admins(ids_only=permission) # we just need the admins IDs if we don't have to check the permissions
if not permission and user_id in admins:
logger.debug('%d is admin in %d', user_id, chat_id)
return func(client, message, *args, **kwargs)
elif permission:
chat_member = [a for a in admins if a.user.id == user_id][0] # get the ChatMember object of the user
if getattr(chat_member, permission, False):
logger.debug('%d is admin in %d and has the %s permission', user_id, chat_id, permission)
return func(client, message, *args, **kwargs)
# if warn is True, warn the user and do not continue the propagation. Otherwise,
# just continue to propagate the update
if warn:
message.reply('You are not allowed to use this command')
else:
raise ContinuePropagation
def privileges_control(self, client: Client, msg: Message):
bot_name = re.match(
r'^\/(setwelcome|clear|status|setflag)(@[a-zA-Z_]*bot)?\s?',
msg.text).group(2)
if bot_name is not None and bot_name[1:] != self.bot_name:
return
group_info = self.groups[msg.chat.id]
if group_info.admins is None:
admins = client.get_chat_members(msg.chat.id,
filter='administrators')
group_info.admins = [x.user.id for x in admins]
self.groups.update_group(msg.chat.id, group_info)
logger.info('Updated administrator list in %d, new list is => %s',
msg.chat.id, group_info.admins)
if msg.from_user.id in group_info.admins:
raise ContinuePropagation
else:
if not group_info.ignore_err and self.error_message != '':
msg.reply(self.error_message)
try:
client.restrict_chat_member(
msg.chat.id, msg.from_user.id,
ChatPermissions(can_send_messages=False),
msg.date + 60)
except:
pass
def func_auth_process(self, client: Client, msg: Message):
if not auth_system.check_ex(msg.from_user.id):
msg.reply('Permission denied')
return
if msg.reply_to_message.from_user:
if auth_system.check_ex(msg.reply_to_message.from_user.id):
msg.reply('Authorized')
else:
self.botapp.send_message(
msg.chat.id,
'Do you want to authorize {} ?\nThis confirmation message will expire after 20 seconds.'
.format(
build_html_parse.parse_user(
msg.reply_to_message.from_user.id)),
reply_to_message_id=msg.message_id,
parse_mode='markdown',
reply_markup=InlineKeyboardMarkup(inline_keyboard=[[
InlineKeyboardButton(
text='Yes',
callback_data='auth {} add'.format(
msg.reply_to_message.from_user.id).encode()),
InlineKeyboardButton(text='No',
callback_data=b'cancel')
]]))
else:
client.send_message(msg.chat.id,
'Unexpected error.',
reply_to_message_id=msg.message_id)
def gay_expect_me_and_geric(bot: BOT, message: Message):
userid = str(message.from_user.id)
username = message.from_user.first_name
gaypercent = randint(0, 100)
percent = str(gaypercent)
message.reply('[' + username + '](tg://user?id=' + userid + '), du bist ' +
percent + '% Schwul!')
def send_test_dice(app: Client, user: User, message: Message):
args = message.command[1:]
dice, chat_id = None, message.chat.id
if len(args) == 1 and args[0].isdigit():
dice = int(args[0])
if not dice:
dice = randint(1, 6)
chat_obj, _ = get_chat_model(app, message.chat, recalc_creation_date=False)
chatmember, _ = get_chatmember_model(app, user, chat_obj)
reward, details = calc_dice_reward(app, user, chatmember, dice, chat_id)
details_pretty = '\n'.join([
f' {param}: {str(value)}'
for param, value in sorted(details.items())
])
response = f"""
Dice testdata for [{user.username or user.first_name}](tg://user?id={user.id})
```Dice: {dice}
Reward: {reward}
Details:
{details_pretty}```"""
markup = KB_REMOVE if message.chat.type != 'private' else kb_home(user)
message.reply(response, quote=False, reply_markup=markup)
def handle_list(self, client: Client, msg: Message):
q = self.mysqldb.query3("SELECT `hash`, `status` FROM `tickets` WHERE `user_id` = {} ORDER BY `timestamp` DESC LIMIT 3".format(msg.chat.id))
if len(q) == 0 or q is None:
return msg.reply('You have never used this system before.', True)
for _ticket in q:
_ticket['status'] = self.returnYNemoji(_ticket['status'] != 'closed')
msg.reply('Here are the last three tickets (up to 3)\n#{}'.format('\n#'.join(' '.join(value for _, value in _ticket.items()) for _ticket in q)), True)
def handle_create(self, client: Client, msg: Message):
if self.flood_check(client, msg):
return
q = self.mysqldb.query1("SELECT `hash` FROM `tickets` WHERE `user_id` = {} AND `status` = 'open' LIMIT 1".format(msg.chat.id))
if q:
msg.reply('UNABLE TO CREATE A NEW TICKET: An existing ticket is currently open.', True)
return
sqlObj = self.mysqldb.query1("SELECT `user_id` FROM `tickets_user` WHERE `user_id` = {}".format(msg.chat.id))
(self.add_user if sqlObj is None else self.change_step)(msg.chat.id, custom_service_bot_class.SELECT_SECTION)
msg.reply('You are creating a new ticket.\n\nPlease choose the correct department.', True, reply_markup=self.generate_section_pad())
def flood_check(self, client: Client, msg: Message):
sq = self.mysqldb.query1("SELECT `last_time`, `last_msg_sent`, `baned` FROM `tickets_user` WHERE `user_id` = {}".format(msg.chat.id))
if sq and (datetime.now() - sq['last_time']).total_seconds() < 120:
if msg.text:
print('Caught flood {}: {}'.format(msg.chat.id, msg.text))
self.mysqldb.execute("UPDATE `tickets_user` SET `last_msg_sent` = CURRENT_TIMESTAMP() WHERE `user_id` = {}".format(msg.chat.id))
self.mysqldb.commit()
if sq['baned']:
return msg.reply('Due to privacy settings, you are temporarily unable to operate.') is not None
msg.reply("You are driving too fast. Please try again later.")
return True
return False
def send_link(self, msg: Message):
if self.problem_set.get('confirm_msg') and self.problem_set['confirm_msg']['enable']:
msg.reply(
self.problem_set['confirm_msg']['text'],
False,
'html',
reply_markup = InlineKeyboardMarkup( inline_keyboard = [
[InlineKeyboardButton( text = self.problem_set['confirm_msg']['button_text'], callback_data = b'iamready')]
])
)
else:
self.revoke_tracker_thread.send_link(msg.chat.id)
def unrestrict_members(bot: Assistant, message: Message):
print(message)
caller = bot.get_chat_member(message.chat.id, message.from_user.id)
if caller.status is 'creator' or caller.status is 'administrator' and caller.permissions.can_restrict_members:
bot.restrict_chat_member(chat_id=message.chat.id,
user_id=message.reply_to_message.from_user.id,
until_date=0,
can_send_messages=True,
can_send_media_messages=True,
can_send_other_messages=True,
can_add_web_page_previews=True,
can_send_polls=True)
message.reply("Restrictions lifted " + Emoji.OK_HAND)
def on_start(_, message: Message):
logger.debug('entered handler')
text = START_MESSAGE.format(
first_name=utils.html_escape(message.from_user.first_name),
santa=Emoji.SANTA_CLAUS_MEDIUM_LIGHT_SKIN_TONE,
shhh=Emoji.SHUSHING_FACE,
gift=Emoji.WRAPPED_GIFT
)
if config.public.source_code:
text += '. Source code <a href="{}">here</a>'.format(config.public.source_code)
message.reply(text, disable_web_page_preview=True)
def _button_win(app: Client,
user: User,
dice_msg: Message,
event,
event_local=None):
take_money_btn_text = user.choice_localized(text_name='btn-chat-win')
take_money_msg_text = user.choice_localized(
text_name='msg-chat-win').format(X=event.summa, coin_ticker=event.coin)
if event_local:
take_money_msg_text += f' + {event_local.summa} {event_local.coin}'
bot = app.get_me()
dice_msg.reply(take_money_msg_text,
reply_markup=markup_take_money(bot.username,
take_money_btn_text))
def handle_msg(self, client: Client, msg: Message):
sqlObj = self.query_status(msg.chat.id)
if sqlObj is None or sqlObj['step'] not in (custom_service_bot_class.SELECT_SECTION, custom_service_bot_class.SEND_QUESTION):
if self.flood_check(client, msg):
return
return msg.reply('Please use bot command to interact.')
if sqlObj['step'] == custom_service_bot_class.SELECT_SECTION:
if msg.text in self.SECTION:
self.change_step(msg.chat.id, custom_service_bot_class.SEND_QUESTION, msg.text)
msg.reply('Please describe your problem briefly(up to 500 characters)\n(Please use external links to send pictures.):\n\nATTENTION: Receiving a confirmation message in return indicates that the ticket is created successfully.\n\nUse /cancel to cancel creating the ticket. ', True, reply_markup = ReplyKeyboardRemove())
else:
msg.reply('Please use the menu below to choose the correct department.', True)
elif sqlObj['step'] == custom_service_bot_class.SEND_QUESTION:
if len(msg.text) > 500:
msg.reply('The number of characters you have entered is larger than 500. Please re-enter.', True)
return
ticket_hash = self.hash_msg(msg)
self.mysqldb.execute(ticket(msg, sqlObj['section'], 'open').sql)
self.mysqldb.commit()
self.change_step(msg.chat.id, custom_service_bot_class.INIT_STATUS)
msg.reply(
'The ticket is created successfully!\n[ #{ticket_id} ]\nDepartment: {section}\nMessage: \n{text}\n\nReply to this message to add a new reply to the ticket.'.format(
ticket_id = ticket_hash,
text = build_html_parse(msg).parsed_msg,
section = sqlObj['section']
),
parse_mode = 'html'
)
msg_id = client.send_message(
self.help_group,
'NEW TICKET\n[ #{} ]\nClick {} to check the user profile\nDepartment: {}\nMessage: \n{}'.format(
ticket_hash,
build_html_parse.parse_user_ex(msg.chat.id, 'Here'),
sqlObj['section'],
build_html_parse(msg).parsed_msg
),
'html',
reply_markup = self.generate_ticket_keyboard(
ticket_hash,
msg.chat.id,
other = sqlObj['section'] != custom_service_bot_class.SECTION[0]
)
).message_id
if sqlObj['section'] == custom_service_bot_class.SECTION[0]:
client.send_message(
self.help_group,
self.generate_user_status(msg.chat.id),
'markdown',
reply_to_message_id = msg_id
)
else:
print("throw! user_id: {}, sqlObj = {}".format(msg.chat.id, repr(sqlObj)))
def delete_message_date(bot: Cleaner, message: Message):
"""
delete messages before or after x hour and y minute ago
(-) for messages before date
"""
until_date, hour, minute = message.matches[0].groups()
assert bot.lock(message.chat.id) # maybe alert by a message
# TODO: check permission (delete message and user history)
notify_message = message.reply('Deleting Messages {} {}{}{} ago'.format(
'until' if until_date else 'before', hour + 'h' if hour else '',
' and ' if hour and minute else '', minute + 'min'))
hour = int(hour) if hour else 0
minute = int(minute) if minute else 0
if not (hour or minute):
return
def get_message_ids():
offset_date = int(time.time() - hour * 3600 - minute * 60)
if until_date:
msgs = bot.iter_history(chat_id=message.chat.id,
offset_date=offset_date)
else:
# why with offset_date and reverse=True not working :| buggy pyrogram?!
msgs = takewhile(
lambda m: m.date >= offset_date,
bot.iter_history(chat_id=message.chat.id,
offset_id=message.message_id))
msg_ids = []
for msg in msgs:
msg_ids.append(msg.message_id)
if len(msg_ids) == 100:
yield msg_ids
msg_ids = []
else:
if msg_ids:
yield msg_ids
total_deleted_message = 0
for message_ids in get_message_ids():
while True:
try:
bot.delete_messages(message.chat.id, message_ids)
total_deleted_message += len(message_ids)
except FloodWait as e:
time.sleep(e.x + 0.5)
continue
except RPCError as e:
log.warning(e)
break
bot.unlock(message.chat.id)
notify_message.edit(
'<b>{}</b> messages deleted 🗑'.format(total_deleted_message))
async def reply_and_delete(message: Message, text: str):
await asyncio.gather(
message.delete(),
message.reply(text,
quote=False,
reply_to_message_id=getattr(message.reply_to_message,
"message_id", None),
disable_web_page_preview=True))
def handle_reply(self, client: Client, msg: Message):
if self.flood_check(client, msg):
return
ticket_hash = self.get_hash_from_reply_msg(msg)
sqlObj = self.mysqldb.query1("SELECT `status`, `section` FROM `tickets` WHERE `hash` = '{}' AND `user_id` = {}".format(ticket_hash, msg.chat.id))
if sqlObj is None or sqlObj['status'] == 'closed':
msg.reply('TICKET NUMBER NOT FOUND or TICKET CLOSED. REPLY FUNCTION NO LONGER AVAILABLE.', True)
return
self.mysqldb.execute("UPDATE `tickets_user` SET `last_time` = CURRENT_TIMESTAMP() WHERE `user_id` = {}".format(msg.chat.id))
self.mysqldb.commit()
client.send_message(
self.help_group,
'NEW REPLY\n[ #{} ]:\nMESSAGE: {}'.format(ticket_hash, build_html_parse(msg).parsed_msg),
'html',
reply_markup = self.generate_ticket_keyboard(ticket_hash, msg.chat.id, sqlObj['section'] != self.SECTION[0])
)
msg.reply('The new reply is added successfully!')
def gender(bot: BOT, message: Message):
if message.reply_to_message is not None:
first_name = message.reply_to_message.from_user.first_name
message.reply(genderize(first_name))
BOT.send_message(
chat_id=message.chat.id,
text=genderize(first_name),
disable_notification=True,
reply_to_message_id=ReplyCheck(message),
)
else:
first_name = message.text.replace("!gender", "")
BOT.send_message(
chat_id=message.chat.id,
text=genderize(first_name),
disable_notification=True,
reply_to_message_id=ReplyCheck(message),
)
def handle_group(self, client: Client, msg: Message):
#print(msg)
if msg.reply_to_message.from_user.id != self.bot_id or (msg.text and msg.text.startswith('/')): return
ticket_hash = self.get_hash_from_reply_msg(msg)
sqlObj = self.mysqldb.query1("SELECT * FROM `tickets` WHERE `hash` = '{}'".format(ticket_hash))
if sqlObj is None:
return msg.reply('ERROR: TICKET NOT FOUND')
if sqlObj['status'] == 'closed':
return msg.reply('This ticket is already closed.')
msg_reply = client.send_message(sqlObj['user_id'], 'NEW UPDATE!\n[ #{} ]\nMessage: \n{}\n\nReply to this message to add a new reply to the ticket.'.format(ticket_hash, build_html_parse(msg).parsed_msg), 'html')
msg.reply('REPLY SUCCESSFUL', reply_markup = InlineKeyboardMarkup(inline_keyboard = [
[
InlineKeyboardButton( text = 'recall', callback_data = ' '.join(('del', str(msg_reply.chat.id), str(msg_reply.message_id))).encode())
]
]))
sqlObj = self.mysqldb.query1("SELECT `last_time`, `user_id` FROM `tickets_user` WHERE user_id = {}".format(sqlObj['user_id']))
if (datetime.now() - sqlObj['last_time']).total_seconds() < 120:
self.mysqldb.execute("UPDATE `tickets_user` SET `last_time` = DATE_SUB(CURRENT_TIMESTAMP(), INTERVAL 3 minute) WHERE `user_id` = %s", (sqlObj['user_id'],))
def welcome(bot: Assistant, message: Message):
for new_user in message.new_chat_members:
bot.restrict_chat_member(chat_id=message.chat.id,
user_id=new_user.id,
until_date=int(time()) + 604800,
can_send_messages=False)
mention = MENTION.format(new_user.first_name, new_user.id)
greeting = MESSAGE.format(Emoji.SPARKLES, mention)
kb = pyro_keyboard(user_id=new_user.id,
confirmed=False,
chat_id=message.chat.id)
reply_markups = InlineKeyboardMarkup(kb)
message.reply(
text=greeting +
"\nTo be able to participate, please press the button below " +
Emoji.DOWN_ARROW,
disable_web_page_preview=True,
reply_markup=reply_markups)
def set_welcome_message(self, _client: Client, msg: Message):
result = setcommand_match.match(msg.text)
welcomemsg = str(result.group(2))
result = gist_match.match(welcomemsg)
if result:
r = requests.get(welcomemsg)
r.raise_for_status()
welcomemsg = r.text
if len(welcomemsg) > 2048:
msg.reply(
"**Error**:Welcome message is too long.(len() must smaller than 2048)",
parse_mode='markdown')
return
p = self.groups[msg.chat.id]
p.welcome_text = welcomemsg
self.groups.update_group(msg.chat.id, p)
msg.reply(f"**Set welcome message to:**\n{welcomemsg}",
parse_mode='markdown',
disable_web_page_preview=True)
def call_superuser_function(self, client: Client, msg: Message):
sqlObj = self.mysqldb.query1("SELECT `user_id`, `section` FROM `tickets` WHERE `hash` = '{}'".format(self.get_hash_from_reply_msg(msg)))
if sqlObj['section'] != self.SECTION[0]:
return msg.reply('This ticket doesn\'t support admin menus for now.', True)
user_id = sqlObj['user_id']
client.send_message(
self.help_group,
parse_mode = 'markdown',
reply_to_message_id = msg.reply_to_message.message_id,
**self.generate_superuser_detail(user_id)
)
async def formatting(_, message: Message):
"""Tell to format"""
await asyncio.gather(
message.delete(),
message.reply(
FORMATTING,
quote=False,
parse_mode="html",
disable_web_page_preview=True,
reply_to_message_id=getattr(message.reply_to_message, "message_id",
None),
))
def handler_addsnippet(cli: Client, msg: Message) -> None:
if len(msg.command) > 2:
lines = msg.text.split('\n')
if len(lines) >= 3:
try:
tag = msg.command[1]
desc = lines[1]
commands = '\n'.join(lines[2:])
credit = str(msg.from_user.id)
setsnippet(tag, desc, commands, credit)
Redis.hset('username', credit, msg.from_user.first_name)
delmsg(
msg.reply(
f'Done, the snippet was successfully added:\n{getsnippet_f(tag)}'
), 30)
sendmaster(f'New Tag:\n{getsnippet_f(tag)}')
except Exception as e:
delmsg(msg.reply(e))
return
else:
delmsg(msg.reply(help_text_addsnipppet))
else:
delmsg(msg.reply(help_text_addsnipppet))
delmsg(msg, 0)
async def help(bot: Assistant, message: Message):
"""Show this message"""
await asyncio.gather(
message.delete(),
message.reply(
HELP,
quote=False,
reply_to_message_id=getattr(
message.reply_to_message,
"message_id", None
),
reply_markup=InlineKeyboardMarkup([[
InlineKeyboardButton("Remove Help", f"remove.{message.from_user.id}")
]]),
)
)
async def newuser_check(client: AssKicker, message: Message):
fromuser = message.from_user
userid = str(fromuser.id)
chatid = message.chat.id
mention = f"{fromuser:mention}"
async with aiohttp.ClientSession() as session:
async with session.get(
f"https://api.cas.chat/check?user_id={userid}") as response:
data = await response.json()
if data["ok"]:
await asyncio.gather(
client.kick_members(chatid, userid),
message.reply(
f"Kicked auto-detected spambot {mention}. Powered by Combot API"
))
def evaluation(bot: BOT, message: Message):
try:
cmdstr = " ".join(message.command[1:])
except IndexError:
message.edit("__I can't evaluate nothing...__")
sleep(2)
message.delete()
return
if cmdstr:
expr = message.reply(RUNNING.format(cmdstr))
try:
result = eval(cmdstr)
except Exception as err:
expr.edit(ERROR.format(cmdstr, err))
LogMessage(
ERROR_LOG.format(cmdstr, message.chat.title
or message.chat.first_name,
str(message.chat.id).replace("-100", ""),
str(expr.message_id), err))
else:
if result is None:
expr.edit(SUCCESS.format(cmdstr))
LogMessage(
SUCCESS_LOG.format(
cmdstr, message.chat.title or message.chat.first_name,
str(message.chat.id).replace("-100", ""),
str(expr.message_id)))
elif len(RESULT.format(cmdstr, result)) > 4096:
expr.edit(RESULT_FILE.format(cmdstr))
BOT.send_chat_action(message.chat.id, "upload_document")
SendLong(expr, cmdstr, result)
else:
expr.edit(RESULT.format(cmdstr, result))
LogMessage(
RESULT_LOG.format(
cmdstr, message.chat.title or message.chat.first_name,
str(message.chat.id).replace("-100", ""),
str(expr.message_id)))
def doom(_: Client, message: Message):
time_now = datetime.utcnow()
user = message.from_user
chat_id = message.chat.id
doomed_user = dao.find(uid=user.id, chat_id=chat_id)
if doomed_user and time_now >= doomed_user.ts_reset:
dao.undoom(doomed_user)
elif doomed_user and time_now <= doomed_user.ts_lib:
message_random = randint(1, 6)
if message_random >= 6:
message.reply("QUE ME LEVANTO!", quote=True)
elif message_random >= 4:
message.reply("CALLAAAAAAAAAA!!", quote=True)
else:
message.reply("CALLA!", quote=True)
def greet_new_users(bot: BOT, message: Message):
new = message.new_chat_members
db = sqlite3.connect(PYRO_DB)
c = db.cursor()
c.execute(GET_WELCOME.format(message.chat.id))
res = c.fetchone()
if res:
welcome_text = res[0].replace(
"{name}",
", ".join("{}".format(usr.first_name) for usr in new)).replace(
"{namelink}", ", ".join(
"[{}](tg://user?id={})".format(usr.first_name, usr.id)
for usr in new)).replace("{title}",
f"{message.chat.title}")
greet = message.reply(unescape(welcome_text),
disable_web_page_preview=True,
disable_notification=True)
LogMessage("Greeted new users in \"[{}](t.me/c/{}/{})\":\n{}".format(
message.chat.title,
str(greet.chat.id).replace("-100", ""), str(greet.message_id),
", ".join(usr.first_name for usr in new)))
def execution(bot: BOT, message: Message):
try:
cmdstr = message.text[6:]
except IndexError:
message.edit("__I can't execute nothing...__")
sleep(2)
message.delete()
return
if cmdstr:
expr = message.reply(RUNNING.format(cmdstr))
try:
exec('def __ex(bot, message): ' +
''.join('\n ' + l for l in cmdstr.split('\n')))
result = locals()['__ex'](bot, message)
except Exception as err:
expr.edit(ERROR.format(cmdstr, err))
LogMessage(
ERROR_LOG.format(cmdstr, message.chat.title
or message.chat.first_name,
str(message.chat.id).replace("-100", ""),
str(expr.message_id), err))
else:
if result:
expr.edit(RESULT.format(cmdstr, result))
LogMessage(
RESULT.format(
cmdstr, message.chat.title or message.chat.first_name,
str(message.chat.id).replace("-100", ""),
str(expr.message_id)))
else:
expr.edit(SUCCESS.format(cmdstr))
LogMessage(
SUCCESS_LOG.format(
cmdstr, message.chat.title or message.chat.first_name,
str(message.chat.id).replace("-100", ""),
str(expr.message_id)))
