示例#1
0
def demontion(app, msg):
    try:
        user_id = msg.reply_to_message.from_user.id
        app.promote_chat_member(msg.chat.id, user_id, False, False, False,
                                False, False, False, False, False)
        msg.edit('**Понижен(а)**')
    except pyrogram.errors.exceptions.bad_request_400.ChannelInvalid:
        msg.edit('**Это не чат**')
    except AttributeError:
        msg.edit('**Кого понижаем?**')
示例#2
0
def promontion(app, msg):
    try:
        user_id = msg.reply_to_message.from_user.id
        try:
            pref = msg.text.split()[1]
        except:
            pref = "Админ"
        app.promote_chat_member(msg.chat.id, user_id)
        app.set_administrator_title(msg.chat.id, user_id, title=pref)
        msg.edit('**Повышен(а)**')
    except pyrogram.errors.exceptions.bad_request_400.ChannelInvalid:
        msg.edit('**Это не чат**')
    except AttributeError:
        msg.edit('**Кого повышаем?**')
示例#3
0
def promote_chat_member(
        client: Client,
        cid: int,
        uid: Union[int, str],
        can_change_info: bool = False,
        can_post_messages: bool = False,
        can_edit_messages: bool = False,
        can_delete_messages: bool = False,
        can_restrict_members: bool = False,
        can_invite_users: bool = False,
        can_pin_messages: bool = False,
        can_promote_members: bool = False) -> Union[bool, None]:
    # Promote or demote a user in a supergroup or a channel
    result = None

    try:
        result = client.promote_chat_member(
            chat_id=cid,
            user_id=uid,
            can_change_info=can_change_info,
            can_post_messages=can_post_messages,
            can_edit_messages=can_edit_messages,
            can_delete_messages=can_delete_messages,
            can_restrict_members=can_restrict_members,
            can_invite_users=can_invite_users,
            can_pin_messages=can_pin_messages,
            can_promote_members=can_promote_members)
    except FloodWait as e:
        raise e
    except Exception as e:
        logger.warning(f"Promote chat member {uid} in {cid} error: {e}",
                       exc_info=True)

    return result
示例#4
0
class bot_controller(object):
    def __init__(self):
        self.problems_load()
        self.target_group = int(config['fuduji']['target_group'])
        self.fudu_group = int(config['fuduji']['fudu_group'])

        self.bot_id = int(config['account']['api_key'].split(':')[0])
        self.emerg_contact = eval(config['account']['emerg_contact']) \
         if config.has_option('account', 'emerg_contact') and config['account']['emerg_contact'] != '' else \
         int(config['account']['owner'])
        self.app = Client(session_name='session',
                          api_id=config['account']['api_id'],
                          api_hash=config['account']['api_hash'],
                          app_version='repeater')
        self.botapp = Client(session_name=config['account']['api_key'],
                             api_id=config['account']['api_id'],
                             api_hash=config['account']['api_hash'])

        self.conn = mysqldb(config['database']['host'],
                            config['database']['user'],
                            config['database']['passwd'],
                            config['database']['db_name'], self.emerg_contact)
        self.media_sender = mediaSender(self.app.send_message, self.conn)
        self.join_group_verify = join_group_verify_class(
            self.conn, self.botapp, self.target_group, extern_load_problem_set)
        self.revoke_tracker_thread = self.join_group_verify.get_revoke_tracker_thread(
        )
        self.custom_service = custom_service_bot_class(
            config, self.conn, self.revoke_tracker_thread.send_link)
        self.db_keepAlive = Thread(target=self.conn.keep_alive, daemon=True)
        self.db_keepAlive.start()

    def init(self):
        global bot_username
        bot_username = self.botapp.get_me().username

    def problems_load(self):
        self.problem_set = extern_load_problem_set()

    def idle(self):
        return self.app.idle()

    def start(self):
        self.app.add_handler(
            MessageHandler(
                self.handle_edit,
                Filters.chat(self.target_group) & ~Filters.user(self.bot_id)
                & Filters.edited))
        self.app.add_handler(
            MessageHandler(
                self.handle_new_member,
                Filters.chat(self.target_group) & Filters.new_chat_members))
        self.app.add_handler(
            MessageHandler(
                self.handle_document,
                Filters.chat(self.target_group) & ~Filters.user(self.bot_id)
                & Filters.document))
        self.app.add_handler(
            MessageHandler(
                self.handle_photo,
                Filters.chat(self.target_group) & ~Filters.user(self.bot_id)
                & Filters.photo))
        self.app.add_handler(
            MessageHandler(
                self.handle_sticker,
                Filters.chat(self.target_group) & ~Filters.user(self.bot_id)
                & Filters.sticker))
        self.app.add_handler(
            MessageHandler(
                self.handle_gif,
                Filters.chat(self.target_group) & ~Filters.user(self.bot_id)
                & Filters.animation))
        self.app.add_handler(
            MessageHandler(
                self.handle_video,
                Filters.chat(self.target_group) & ~Filters.user(self.bot_id)
                & Filters.video))
        self.app.add_handler(
            MessageHandler(
                self.handle_speak,
                Filters.chat(self.target_group) & ~Filters.user(self.bot_id)
                & Filters.text))
        self.app.add_handler(
            MessageHandler(self.handle_incoming,
                           Filters.incoming & Filters.chat(self.fudu_group)))
        self.botapp.add_handler(CallbackQueryHandler(self.handle_callback))
        self.join_group_verify.init()
        self.app.start()
        self.botapp.start()
        self.init()
        self.custom_service.start()

    def stop(self):
        self.revoke_tracker_thread.set_stop()
        self.revoke_tracker_thread.join(1.5)
        if self.revoke_tracker_thread.is_alive():
            print('[WARN] revoke_tracker_thread still running!')
        self.custom_service.stop()
        self.botapp.stop()
        self.app.stop()

    def emerg_send_message(self, msg_str: str):
        '''
			Send message to emergancy contacts.
		'''
        if isinstance(self.emerg_contact, int):
            self.app.send_message(self.emerg_contact, msg_str, 'html')
        else:
            for user_id in self.emerg_contact:
                self.app.send_message(user_id, msg_str, 'html')

    def process_imcoming_command(self, client: Client, msg: Message):
        r = re.match(r'^\/bot (on|off)$', msg.text)
        if r is None: r = re.match(r'^\/b?(on|off)$', msg.text)
        if r:
            if not auth_system.check_ex(
                    msg.reply_to_message.from_user.id if msg.
                    reply_to_message else msg.from_user.id):
                return
            auth_system.mute_or_unmute(
                r.group(1), msg.reply_to_message.from_user.id
                if msg.reply_to_message else msg.from_user.id)
            client.delete_messages(msg.chat.id, msg.message_id)
        if msg.text == '/status':
            user_id = msg.reply_to_message.from_user.id if msg.reply_to_message else msg.from_user.id
            status = [
                str(user_id), ' summary:\n\n',
                'A' if auth_system.check_ex(user_id) else 'Una',
                'uthorized user\nBot status: ',
                '✅' if not auth_system.check_muted(user_id) else '❌'
            ]
            sleep_to_delete(
                client, msg.chat.id,
                (msg.message_id, msg.reply(''.join(status), True).message_id))
            del status
        elif msg.text.startswith('/p'):
            if msg.text.startswith('/promote'):
                if len(msg.text.split()) == 1:
                    if msg.reply_to_message is None or not auth_system.check_ex(
                            msg.reply_to_message.from_user.id):
                        self.botapp.send_message(
                            msg.chat.id,
                            'Please reply to an Authorized user.',
                            reply_to_message_id=msg.message_id)
                        return
                    user_id = msg.reply_to_message.from_user.id
                else:
                    user_id = int(msg.text.split()[1])
                self.botapp.send_message(
                    msg.chat.id,
                    'Please use bottom to make sure you want to add {} to Administrators'
                    .format(build_html_parse.parse_user(user_id)),
                    parse_mode='markdown',
                    reply_to_message_id=msg.message_id,
                    reply_markup=InlineKeyboardMarkup(
                        inline_keyboard=[[
                            InlineKeyboardButton(text='Yes, confirm',
                                                 callback_data='promote {}'.
                                                 format(user_id).encode())
                        ],
                                         [
                                             InlineKeyboardButton(
                                                 text='Cancel',
                                                 callback_data=b'cancel d')
                                         ]]))
            else:
                if not auth_system.check_ex(msg.from_user.id): return
                self.botapp.promote_chat_member(self.target_group,
                                                int(msg.from_user.id),
                                                True,
                                                can_delete_messages=True,
                                                can_restrict_members=True,
                                                can_invite_users=True,
                                                can_pin_messages=True,
                                                can_promote_members=True)
                self.botapp.send_message(
                    msg.chat.id,
                    '[Emergency]: Privileges has been promoted',
                    reply_to_message_id=msg.message_id)
            return
        if msg.reply_to_message:
            if msg.text == '/del':
                try:
                    client.forward_messages(
                        msg.chat.id, self.target_group,
                        self.conn.get_reply_id_Reverse(msg))
                    self.botapp.delete_messages(
                        self.target_group, self.conn.get_reply_id_Reverse(msg))
                except:
                    client.send_message(msg.chat.id,
                                        traceback.format_exc(),
                                        disable_web_page_preview=True)
                try:
                    client.delete_messages(
                        int(config['fuduji']['fudu_group']),
                        [msg.message_id, msg.reply_to_message.message_id])
                except:
                    pass
            elif msg.text == '/getid':
                user_id = self.conn.get_user_id(msg)
                client.send_message(
                    msg.chat.id,
                    'user_id is `{}`'.format(
                        user_id['user_id'] if user_id is not None and
                        user_id['user_id'] != 0 else 'ERROR_INVALID_USER_ID'),
                    parse_mode='markdown',
                    reply_to_message_id=msg.reply_to_message.message_id)
            elif msg.text == '/get' and self.conn.get_reply_id_Reverse(msg):
                try:
                    client.forward_messages(
                        int(config['fuduji']['fudu_group']), self.target_group,
                        self.conn.get_reply_id_Reverse(msg))
                except:
                    client.send_message(
                        msg.chat.id,
                        traceback.format_exc().splitlines()[-1])
            elif msg.text == '/getn':
                pass
            elif msg.text == '/fw':
                self.conn.insert_ex(
                    self.botapp.forward_messages(
                        self.target_group, self.target_group,
                        self.conn.get_reply_id_Reverse(msg)).message_id,
                    msg.message_id)
            elif msg.text.startswith('/ban'):
                user_id = self.conn.get_user_id(msg)
                if len(msg.text) == 4:
                    restrict_time = 0
                else:
                    r = re.match(r'^([1-9]\d*)(s|m|h|d)$', msg.text[5:])
                    if r is not None:
                        restrict_time = int(r.group(1)) * {
                            's': 1,
                            'm': 60,
                            'h': 60 * 60,
                            'd': 60 * 60 * 24
                        }.get(r.group(2))
                    else:
                        self.botapp.send_message(
                            msg.chat.id,
                            'Usage: `/ban` or `/ban <Duration>`',
                            reply_to_message_id=msg.message_id,
                            parse_mode='markdown')
                if user_id is not None and user_id['user_id'] != 0:
                    if user_id['user_id'] not in auth_system.whitelist:
                        self.botapp.send_message(
                            msg.chat.id,
                            'What can {} only do? Press the button below.\nThis confirmation message will expire after 20 seconds.'
                            .format(
                                build_html_parse.parse_user(
                                    user_id['user_id'])),
                            reply_to_message_id=msg.message_id,
                            parse_mode='markdown',
                            reply_markup=InlineKeyboardMarkup(inline_keyboard=[
                                [
                                    InlineKeyboardButton(
                                        text='READ',
                                        callback_data='res {} read {}'.format(
                                            restrict_time,
                                            user_id['user_id']).encode())
                                ],
                                [
                                    InlineKeyboardButton(
                                        text='SEND_MESSAGES',
                                        callback_data='res {} write {}'.format(
                                            restrict_time,
                                            user_id['user_id']).encode()),
                                    InlineKeyboardButton(
                                        text='SEND_MEDIA',
                                        callback_data='res {} media {}'.format(
                                            restrict_time,
                                            user_id['user_id']).encode())
                                ],
                                [
                                    InlineKeyboardButton(
                                        text='SEND_STICKERS',
                                        callback_data='res {} stickers {}'.
                                        format(restrict_time,
                                               user_id['user_id']).encode()),
                                    InlineKeyboardButton(
                                        text='EMBED_LINKS',
                                        callback_data='res {} link {}'.format(
                                            restrict_time,
                                            user_id['user_id']).encode())
                                ],
                                [
                                    InlineKeyboardButton(
                                        text='Cancel', callback_data=b'cancel')
                                ]
                            ]))
                    else:
                        self.botapp.send_message(
                            msg.chat.id,
                            'ERROR_WHITELIST_USER_ID',
                            reply_to_message_id=msg.message_id)
                else:
                    self.botapp.send_message(
                        msg.chat.id,
                        'ERROR_INVALID_USER_ID',
                        reply_to_message_id=msg.message_id)
            elif msg.text == '/kick':
                user_id = self.conn.get_user_id(msg)
                if user_id is not None and user_id['user_id'] != 0:
                    if user_id['user_id'] not in auth_system.whitelist:
                        self.botapp.send_message(
                            msg.chat.id,
                            'Do you really want to kick {}?\nIf you really want to kick this user, press the button below.\nThis confirmation message will expire after 15 seconds.'
                            .format(
                                build_html_parse.parse_user(
                                    user_id['user_id'])),
                            reply_to_message_id=msg.message_id,
                            parse_mode='markdown',
                            reply_markup=InlineKeyboardMarkup(inline_keyboard=[
                                [
                                    InlineKeyboardButton(
                                        text='Yes, kick it',
                                        callback_data=b' '.join((
                                            b'kick',
                                            str(msg.from_user.id).encode(),
                                            str(user_id['user_id']).encode())))
                                ],
                                [
                                    InlineKeyboardButton(
                                        text='No', callback_data=b'cancel')
                                ],
                            ]))
                    else:
                        self.botapp.send_message(
                            msg.chat.id,
                            'ERROR_WHITELIST_USER_ID',
                            reply_to_message_id=msg.message_id)
                else:
                    self.botapp.send_message(
                        msg.chat.id,
                        'ERROR_INVALID_USER_ID',
                        reply_to_message_id=msg.message_id)
        else:  # Not reply message
            if msg.text == '/ban':
                client.send_message(
                    msg.chat.id,
                    'Reply to the user you wish to restrict, if you want to kick this user, please use the /kick command.'
                )
            elif msg.text == '/join':
                pass
            elif msg.text.startswith('/set'):
                auth_system.user_suffix[
                    msg.from_user.id] = msg.text.split()[-1]
                client.send_message(msg.chat.id,
                                    'Set suffix to `{}`'.format(
                                        msg.text.split()[-1]),
                                    'markdown',
                                    reply_to_message_id=msg.message_id)

    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 cross_group_forward_request(self, msg: Message):
        kb = [[
            InlineKeyboardButton(text='Yes, I know what I\'m doing.',
                                 callback_data=b'fwd original')
        ],
              [
                  InlineKeyboardButton(text='Yes, but don\'t use forward.',
                                       callback_data=b'fwd text')
              ],
              [
                  InlineKeyboardButton(text='No, please don\'t.',
                                       callback_data=b'cancel d')
              ]]
        if msg.text is None: kb.pop(1)
        self.botapp.send_message(
            msg.chat.id,
            '<b>Warning:</b> You are requesting forwarding an authorized user\'s message to the main group, please comfirm your action.',
            'html',
            reply_to_message_id=msg.message_id,
            reply_markup=InlineKeyboardMarkup(inline_keyboard=kb))
        del kb

    def handle_new_member(self, client: Client, msg: Message):
        for new_user_id in (x.id for x in msg.new_chat_members):
            # Exam check goes here
            try:
                if not self.join_group_verify.query_user_passed(new_user_id):
                    self.botapp.kick_chat_member(self.target_group,
                                                 new_user_id)
                    self.botapp.send_message(
                        self.fudu_group,
                        'Kicked challenge failure user {}'.format(
                            build_html_parse.parse_user(new_user_id)),
                        'markdown',
                    )
            except:
                traceback.print_exc()
        self.conn.insert(
         msg,
         client.send_message(
          self.fudu_group,
          '`{}` invite `{}` joined the group'.format(
           build_html_parse.user_name(msg.from_user).full_name,
           '`,`'.join(
            build_html_parse.user_name(user).full_name for user in msg.new_chat_members
           )
          ),
          'markdown'
         ) \
         if msg.new_chat_members[0].id != msg.from_user.id else \
          client.send_message(
           self.fudu_group,
           '`{}` joined the group'.format(
            '`,`'.join(
             build_html_parse.user_name(user).full_name for user in msg.new_chat_members
            )
           ),
           'markdown'
          )
         )

    def handle_edit(self, client: Client, msg: Message):
        if msg.via_bot and msg.via_bot.id == 166035794: return
        if self.conn.get_id(msg.message_id) is None:
            time.sleep(3)
            if self.conn.get_id(msg.message_id) is None:
                print(msg)
                return print('Editing Failure: get_id return None')
        try:
            (client.edit_message_text if msg.text else
             client.edit_message_caption)(self.fudu_group,
                                          self.conn.get_id(msg.message_id),
                                          build_html_parse(msg).call(), 'html')
        except:
            traceback.print_exc()

    def handle_document(self, client: Client, msg: Message):
        self.media_sender.put((client.send_document, msg, msg.document, False))

    def handle_photo(self, client: Client, msg: Message):
        self.media_sender.put(
            (client.send_photo, msg, msg.photo.sizes[0], False))

    def handle_sticker(self, client: Client, msg: Message):
        self.conn.insert(
            msg,
            client.send_message(
                self.fudu_group,
                '{} {} sticker'.format(
                    build_html_parse(msg).call(), msg.sticker.emoji),
                'html',
                True,
                reply_to_message_id=self.conn.get_reply_id(msg),
            ))

    def handle_gif(self, client: Client, msg: Message):
        self.media_sender.put(
            (client.send_animation, msg, msg.animation, False))

    def handle_video(self, client: Client, msg: Message):
        self.media_sender.put((client.send_video, msg, msg.video, False))

    def handle_speak(self, client: Client, msg: Message):
        if msg.text.startswith('/') and re.match(r'^\/\w+(@\w*)?$', msg.text):
            return
        self.conn.insert(
            msg,
            client.send_message(
                self.fudu_group,
                build_html_parse(msg).call(),
                'html',
                reply_to_message_id=self.conn.get_reply_id(msg),
                disable_web_page_preview=True))

    def handle_incoming(self, client: Client, msg: Message):
        client.send(
            api.functions.channels.ReadHistory(
                client.resolve_peer(msg.chat.id), msg.message_id))
        if msg.text == '/auth' and msg.reply_to_message:
            return self.func_auth_process(client, msg)
        if not auth_system.check_ex(msg.from_user.id): return
        if msg.text and re.match(
                r'^\/(bot (on|off)|del|getn?|fw|ban( (([1-9]\d*)(s|m|h|d)|f))?|kick( confirm| -?\d+)?|status|b?o(n|ff)|join|p(romote( \d+)?)?|set [a-zA-Z])$',
                msg.text):
            return self.process_imcoming_command(client, msg)
        if msg.text and msg.text.startswith('/') and re.match(
                r'^\/\w+(@\w*)?$', msg.text):
            return
        if auth_system.check_muted(msg.from_user.id) or (
                msg.text and msg.text.startswith('//')) or (
                    msg.caption and msg.caption.startswith('//')):
            return

        if msg.forward_from or msg.forward_from_chat:
            if msg.forward_from:
                if msg.forward_from.is_self: return
                elif auth_system.check_ex(msg.forward_from.id):
                    return self.cross_group_forward_request(msg)
            self.conn.insert_ex(
                self.botapp.forward_messages(self.target_group,
                                             self.fudu_group,
                                             msg.message_id).message_id,
                msg.message_id)
        elif msg.text and (not msg.edit_date or
                           (msg.edit_date and
                            self.conn.get_id(msg.message_id, True) is None)):
            self.conn.insert_ex(
                self.botapp.send_message(
                    self.target_group,
                    build_html_parse(msg).split_offset(),
                    'html',
                    True,
                    reply_to_message_id=self.conn.get_reply_id_Reverse(msg),
                ).message_id, msg.message_id)
        elif msg.photo:
            self.media_sender.Locker.acquire()
            msg.download('tmp.jpg')
            self.media_sender.put((self.botapp.send_photo, msg,
                                   media_path('downloads/tmp.jpg'), True),
                                  True)
        elif msg.video:
            self.media_sender.put(
                (self.botapp.send_video, msg, msg.video, True), True)
        elif msg.document:
            self.media_sender.put(
                (self.botapp.send_document, msg, msg.document, True), True)
        elif msg.edit_date:
            try:
                (self.botapp.edit_message_text
                 if msg.text else self.botapp.edit_message_caption)(
                     self.target_group,
                     self.conn.get_id(msg.message_id, True),
                     build_html_parse(msg).split_offset(),
                     parse_mode='html',
                     disable_web_page_preview=True)
            except:
                traceback.print_exc()
        elif msg.sticker:
            self.media_sender.put(
                (self.botapp.send_sticker, msg, msg.sticker, True), True)

    def handle_callback(self, client: Client, msg: CallbackQuery):
        msg.data = msg.data.decode(errors='ignore')
        try:
            if msg.data.startswith('cancel') or msg.data == 'rm':
                msg.answer(
                    msg.id,
                    'Canceled' if not msg.data == 'rm' else 'Button removed')
                if msg.data.endswith('d'):
                    client.delete_messages(msg.message.chat.id,
                                           msg.message.message_id)
                else:
                    client.edit_message_reply_markup(msg.message.chat.id,
                                                     msg.message.message_id)
            if self.join_group_verify is not None and self.join_group_verify.click_to_join(
                    client, msg):
                return
            if msg.data.startswith('res'):
                if time.time() - msg.message.date > 20:
                    raise OperationTimeoutError()
                _, dur, _type, _user_id = msg.data.split()
                if client.restrict_chat_member(
                        self.target_group, int(_user_id),
                        int(time.time()) + int(dur),
                        **({
                            'write': {
                                'can_send_messages': True
                            },
                            'media': {
                                'can_send_media_messages': True
                            },
                            'stickers': {
                                'can_send_other_messages': True
                            },
                            'link': {
                                'can_add_web_page_previews': True
                            },
                            'read': {}
                        }.get(_type))):
                    msg.answer('The user is restricted successfully.')
                    client.edit_message_text(
                        msg.message.chat.id,
                        msg.message.message_id,
                        'Restrictions applied to {} Duration: {}'.format(
                            build_html_parse.parse_user(_user_id),
                            '{}s'.format(dur) if int(dur) else 'Forever'),
                        parse_mode='markdown',
                        reply_markup=InlineKeyboardMarkup([[
                            InlineKeyboardButton(
                                text='UNBAN',
                                callback_data='unban {}'.format(
                                    _user_id).encode())
                        ]]))

            elif msg.data.startswith('unban'):
                if client.restrict_chat_member(self.target_group,
                                               int(msg.data.split()[-1]), 0,
                                               True, True, True, True):
                    msg.answer('Unban successfully')
                    client.edit_message_reply_markup(msg.message.chat.id,
                                                     msg.message.message_id)
            elif msg.data.startswith('auth'):
                if time.time() - msg.message.date > 20:
                    raise OperationTimeoutError()
                auth_system.add_user(msg.data.split()[1])
                msg.answer('{} added to the authorized group'.format(
                    msg.data.split()[1]))
                client.edit_message_text(
                    msg.message.chat.id, msg.message.message_id,
                    '{} added to the authorized group'.format(
                        msg.data.split()[1]))
                with open('config.ini', 'w') as fout:
                    config.write(fout)
            elif msg.data.startswith('fwd'):
                if time.time() - msg.message.date > 30:
                    raise OperationTimeoutError()
                if 'original' in msg.data:
                    self.conn.insert_ex(
                        client.forward_messages(
                            self.target_group, msg.message.chat.id, msg.
                            message.reply_to_message.message_id).message_id,
                        msg.message.reply_to_message.message_id)
                else:
                    self.conn.insert_ex(
                        client.send_message(
                            self.target_group,
                            build_html_parse(
                                msg.message.reply_to_message).split_offset(),
                            'html').message_id,
                        msg.message.reply_to_message.message_id)
                msg.answer('Forward successfully')
                client.delete_messages(msg.message.chat.id,
                                       msg.message.message_id)
            elif msg.data.startswith('kick'):
                if not msg.data.startswith(
                        'kickc') and msg.from_user.id != int(
                            msg.data.split()[-2]):
                    raise OperatorError()
                if 'true' not in msg.data:
                    if not msg.data.startswith(
                            'kickc') and time.time() - msg.message.date > 15:
                        raise OperationTimeoutError()
                    args = [
                        msg.message.chat.id,
                        msg.message.message_id,
                        'Press the button again to kick {}\nThis confirmation message will expire after 10 seconds.'
                        .format(
                            build_html_parse.parse_user(msg.data.split()[-1])),
                    ]
                    if msg.data.startswith('kickc'):
                        args.pop(1)
                        r = msg.data.split()
                        r.insert(1, msg.from_user.id)
                        msg.data = ' '.join(str(x) for x in r)
                        del r
                    kwargs = {
                        'parse_mode':
                        'markdown',
                        'reply_markup':
                        InlineKeyboardMarkup(
                            inline_keyboard=[[
                                InlineKeyboardButton(
                                    text='Yes, please.',
                                    callback_data=b' '.join((
                                        b'kick true', ' '.join(
                                            msg.data.split()[1:]).encode())))
                            ],
                                             [
                                                 InlineKeyboardButton(
                                                     text='Cancel',
                                                     callback_data=b'cancel')
                                             ]])
                    }
                    (client.send_message if msg.data.startswith('kickc') else
                     client.edit_message_text)(*args, **kwargs)
                    msg.answer(
                        'Please press again to make sure. Do you really want to kick {} ?'
                        .format(msg.data.split()[-1]), True)
                else:
                    if msg.message.edit_date:
                        if time.time() - msg.message.edit_date > 10:
                            raise OperationTimeoutError()
                    else:
                        if time.time() - msg.message.date > 10:
                            raise OperationTimeoutError()
                    client.kick_chat_member(self.target_group,
                                            int(msg.data.split()[-1]))
                    msg.answer('Kicked {}'.format(msg.data.split()[-1]))
                    client.edit_message_text(
                        msg.message.chat.id, msg.message.message_id,
                        'Kicked {}'.format(
                            build_html_parse.parse_user(msg.data.split()[-1])))
                    #app.send_message(self.fudu_group, 'Kicked {}'.format(msg.message.entities[0].user.id))
                #client.delete_messages(msg.message.chat.id, msg.message.message_id)
            elif msg.data.startswith('promote'):
                if not msg.data.endswith('undo'):
                    if time.time() - msg.message.date > 10:
                        raise OperationTimeoutError()
                    self.botapp.promote_chat_member(self.target_group,
                                                    int(msg.data.split()[1]),
                                                    True,
                                                    can_delete_messages=True,
                                                    can_restrict_members=True,
                                                    can_invite_users=True,
                                                    can_pin_messages=True,
                                                    can_promote_members=True)
                    msg.answer('Promote successfully')
                    client.edit_message_text(
                        msg.message.chat.id,
                        msg.message.message_id,
                        'Promoted {}'.format(
                            build_html_parse.parse_user(
                                int(msg.data.split()[1]))),
                        parse_mode='markdown',
                        reply_markup=InlineKeyboardMarkup(inline_keyboard=[
                            [
                                InlineKeyboardButton(text='UNDO',
                                                     callback_data=' '.join((
                                                         msg.data,
                                                         'undo')).encode())
                            ],
                            [
                                InlineKeyboardButton(text='remove button',
                                                     callback_data=b'rm')
                            ]
                        ]))
                else:
                    self.botapp.promote_chat_member(self.target_group,
                                                    int(msg.data.split()[1]),
                                                    False,
                                                    can_delete_messages=False,
                                                    can_invite_users=False,
                                                    can_restrict_members=False)
                    msg.answer('Undo Promote successfully')
                    client.edit_message_text(
                        msg.message.chat.id,
                        msg.message.message_id,
                        'Unpromoted {}'.format(
                            build_html_parse.parse_user(
                                int(msg.data.split()[1]))),
                        parse_mode='markdown')
        except OperationTimeoutError:
            msg.answer('Confirmation time out')
            client.edit_message_reply_markup(msg.message.chat.id,
                                             msg.message.message_id)
        except OperatorError:
            msg.answer(
                'The operator should be {}.'.format(msg.data.split()[-2]),
                True)
        except:
            self.app.send_message(int(config['fuduji']['help_group']),
                                  traceback.format_exc().splitlines()[-1])
            traceback.print_exc()