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)))