Beispiel #1
0
async def export_chat_data(message, chat, strings):
    chat_id = chat['chat_id']
    key = 'export_lock:' + str(chat_id)
    if redis.get(key) and message.from_user.id not in OPERATORS:
        ttl = format_timedelta(timedelta(seconds=redis.ttl(key)),
                               strings['language_info']['babel'])
        await message.reply(strings['exports_locked'] % ttl)
        return

    redis.set(key, 1)
    redis.expire(key, 7200)

    msg = await message.reply(strings['started_exporting'])
    data = {
        'general': {
            'chat_name': chat['chat_title'],
            'chat_id': chat_id,
            'timestamp': datetime.now(),
            'version': VERSION
        }
    }

    for module in [m for m in LOADED_MODULES if hasattr(m, '__export__')]:
        await asyncio.sleep(0.2)
        if k := await module.__export__(chat_id):
            data.update(k)
Beispiel #2
0
async def importfbans_cmd(message, fed, strings):
    fed_id = fed['fed_id']
    key = 'importfbans_lock:' + str(fed_id)
    if redis.get(key) and message.from_user.id not in OPERATORS:
        ttl = format_timedelta(timedelta(seconds=redis.ttl(key)), strings['language_info']['babel'])
        await message.reply(strings['importfbans_locked'] % ttl)
        return

    redis.set(key, 1)
    redis.expire(key, 7200)

    if 'document' in message:
        document = message.document
    else:
        if 'reply_to_message' not in message:
            await ImportFbansFileWait.waiting.set()
            await message.reply(strings['send_import_file'])
            return

        elif 'document' not in message.reply_to_message:
            await message.reply(strings['rpl_to_file'])
            return
        document = message.reply_to_message.document

    await importfbans_func(message, fed, document=document)
Beispiel #3
0
async def export_chat_data(message, chat, strings):
    chat_id = chat['chat_id']
    key = 'export_lock:' + str(chat_id)
    if redis.get(key) and message.from_user.id not in OPERATORS:
        ttl = format_timedelta(timedelta(seconds=redis.ttl(key)),
                               strings['language_info']['babel'])
        await message.reply(strings['exports_locked'] % ttl)
        return

    redis.set(key, 1)
    redis.expire(key, 7200)

    msg = await message.reply(strings['started_exporting'])
    data = {
        'general': {
            'chat_name': chat['chat_title'],
            'chat_id': chat_id,
            'timestamp': datetime.now(),
            'version': 1
        }
    }

    for module in [m for m in LOADED_MODULES if hasattr(m, '__export__')]:
        await asyncio.sleep(0.2)
        data.update(await module.__export__(chat_id))

    jfile = InputFile(io.StringIO(ujson.dumps(data, indent=2)),
                      filename=f'{chat_id}_export.json')
    text = strings['export_done'] % chat['chat_title']
    await message.answer_document(jfile, text, reply=message.message_id)
    await msg.delete()
Beispiel #4
0
async def import_fun(message, document, chat, strings):
    chat_id = chat['chat_id']
    key = 'import_lock:' + str(chat_id)
    if redis.get(key) and message.from_user.id not in OPERATORS:
        ttl = format_timedelta(timedelta(seconds=redis.ttl(key)),
                               strings['language_info']['babel'])
        await message.reply(strings['imports_locked'] % ttl)
        return

    redis.set(key, 1)
    redis.expire(key, 7200)

    msg = await message.reply(strings['started_importing'])
    if document['file_size'] > 52428800:
        await message.reply(strings['big_file'])
        return
    data = await bot.download_file_by_id(document.file_id, io.BytesIO())
    data = ujson.load(data)

    if 'general' not in data:
        await message.reply(strings['bad_file'])
        return

    imported = []
    for module in [m for m in LOADED_MODULES if hasattr(m, '__import__')]:
        module_name = module.__name__.replace('sophie_bot.modules.', '')
        print(module_name)
        if module_name in data:
            imported.append(module_name)
            await asyncio.sleep(0.2)
            await module.__import__(chat_id, data[module_name])

    await msg.delete()
    await message.answer(strings['import_done'], reply=message.message_id)
Beispiel #5
0
async def fban_export(message, fed, strings):
    fed_id = fed['fed_id']
    key = 'fbanlist_lock:' + str(fed_id)
    if redis.get(key) and message.from_user.id not in OPERATORS:
        ttl = format_timedelta(timedelta(seconds=redis.ttl(key)), strings['language_info']['babel'])
        await message.reply(strings['fbanlist_locked'] % ttl)
        return

    redis.set(key, 1)
    redis.expire(key, 7200)

    msg = await message.reply(strings['creating_fbanlist'])
    fields = ['user_id', 'reason', 'by', 'time', 'banned_chats']
    with io.StringIO() as f:
        writer = csv.DictWriter(f, fields)
        writer.writeheader()
        async for banned_data in db.fed_bans.find({'fed_id': fed_id}):
            await asyncio.sleep(0)

            data = {'user_id': banned_data['user_id']}

            if 'reason' in banned_data:
                data['reason'] = banned_data['reason']

            if 'time' in banned_data:
                data['time'] = int(time.mktime(banned_data['time'].timetuple()))

            if 'by' in banned_data:
                data['by'] = banned_data['by']

            if 'banned_chats' in banned_data:
                data['banned_chats'] = banned_data['banned_chats']

            writer.writerow(data)

        text = strings['fbanlist_done'] % fed['fed_name']
        f.seek(0)
        await message.answer_document(
            InputFile(f, filename='fban_export.csv'),
            text
        )
    await msg.delete()
Beispiel #6
0
async def import_fun(message, document, chat, strings):
    chat_id = chat['chat_id']
    key = 'import_lock:' + str(chat_id)
    if redis.get(key) and message.from_user.id not in OPERATORS:
        ttl = format_timedelta(timedelta(seconds=redis.ttl(key)),
                               strings['language_info']['babel'])
        await message.reply(strings['imports_locked'] % ttl)
        return

    redis.set(key, 1)
    redis.expire(key, 7200)

    msg = await message.reply(strings['started_importing'])
    if document['file_size'] > 52428800:
        await message.reply(strings['big_file'])
        return
    data = await bot.download_file_by_id(document.file_id, io.BytesIO())
    data = ujson.load(data)

    if 'general' not in data:
        await message.reply(strings['bad_file'])
        return

    file_version = data['general']['version']

    if file_version > VERSION:
        await message.reply(strings['file_version_so_new'])
        return

    imported = []
    for module in [m for m in LOADED_MODULES if hasattr(m, '__import__')]:
        module_name = module.__name__.replace('sophie_bot.modules.', '')
        if module_name not in data:
            continue
        if not data[module_name]:
            continue

        imported.append(module_name)
        await asyncio.sleep(0)  # Switch to other events before continue
        await module.__import__(chat_id, data[module_name])

    await msg.edit_text(strings['import_done'])
Beispiel #7
0
        return {'status': None, 'err_msg': 'u_should_be_admin'}

    # Check on /allowusersconnect enabled
    if settings := await db.chat_connection_settings.find_one(
        {'chat_id': chat_id}):
        if 'allow_users_connect' in settings and settings[
                'allow_users_connect'] is False and not user_admin:
            return {'status': None, 'err_msg': 'conn_not_allowed'}

    data = {'status': True, 'chat_id': chat_id, 'chat_title': chat_title}

    # Cache connection status for 15 minutes
    cached = data
    cached['status'] = 1
    redis.hmset(key, cached)
    redis.expire(key, 900)

    return data


def chat_connection(**dec_kwargs):
    def wrapped(func):
        async def wrapped_1(*args, **kwargs):

            message = args[0]
            from_id = None
            if hasattr(message, 'message'):
                from_id = message.from_user.id
                message = message.message

            if (check := await get_connected_chat(
Beispiel #8
0
    text = strings['user_kicked'].format(user=await get_user_link(user_id),
                                         admin=await
                                         get_user_link(message.from_user.id),
                                         chat_name=chat['chat_title'])

    # Add reason
    if len(args := message.get_args().split(' ', 1)) > 1:
        text += strings['reason'] % args[1]

    # Check if silent
    silent = False
    if get_cmd(message) == 'skick':
        silent = True
        key = 'leave_silent:' + str(chat_id)
        redis.set(key, user_id)
        redis.expire(key, 30)
        text += strings['purge']

    await kick_user(chat_id, user_id)

    msg = await message.reply(text)

    # Del msgs if silent
    if silent:
        to_del = [msg.message_id, message.message_id]
        if 'reply_to_message' in message and message.reply_to_message.from_user.id == user_id:
            to_del.append(message.reply_to_message.message_id)
        await asyncio.sleep(5)
        await tbot.delete_messages(chat_id, to_del)

Beispiel #9
0
async def fed_ban_user(message, fed, user, reason, strings):
    user_id = user['user_id']

    # Checks
    if user_id in OPERATORS:
        await message.reply(strings['user_wl'])
        return

    elif user_id == message.from_user.id:
        await message.reply(strings['fban_self'])
        return

    elif user_id == BOT_ID:
        await message.reply(strings['fban_self'])
        return

    elif user_id == fed['creator']:
        await message.reply(strings['fban_creator'])
        return

    elif 'admins' in fed and user_id in fed['admins']:
        await message.reply(strings['fban_fed_admin'])
        return

    elif await db.fed_bans.find_one({'fed_id': fed['fed_id'], 'user_id': user_id}):
        await message.reply(strings['already_fbanned'].format(user=await get_user_link(user_id)))
        return

    text = strings['fbanned_header']
    text += strings['fban_info'].format(
        fed=fed['fed_name'],
        fadmin=await get_user_link(message.from_user.id),
        user=await get_user_link(user_id),
        user_id=user['user_id']
    )
    if reason:
        text += strings['fbanned_reason'].format(reason=reason)

    # fban processing msg
    msg = await message.reply(text + strings['fbanned_process'].format(num=len(fed['chats'])))

    user = await db.user_list.find_one({'user_id': user_id})

    banned_chats = []
    for chat_id in fed['chats']:
        # We not found the user or user wasn't detected
        if not user or 'chats' not in user:
            continue

        if chat_id in user['chats']:
            await asyncio.sleep(0)  # Do not slow down other updates
            if await ban_user(chat_id, user_id):
                banned_chats.append(chat_id)

    new = {
        'fed_id': fed['fed_id'],
        'user_id': user_id,
        'banned_chats': banned_chats,
        'time': datetime.now(),
        'by': message.from_user.id
    }

    if reason:
        new['reason'] = reason

    await db.fed_bans.insert_one(new)

    channel_text = strings['fban_log_fed_log'].format(
        fed_name=fed['fed_name'],
        fed_id=fed['fed_id'],
        user=await get_user_link(user_id),
        user_id=user_id,
        chat_count=len(banned_chats),
        all_chats=len(fed['chats'])
    )

    if reason:
        channel_text += strings['fban_reason_fed_log'].format(reason=reason)

    # Check if silent
    silent = False
    if get_cmd(message) == 'sfban':
        silent = True
        key = 'leave_silent:' + str(message.chat.id)
        redis.set(key, user_id)
        redis.expire(key, 30)
        text += strings['fbanned_silence']

    # SubsFeds process
    if len(sfeds_list := await get_all_subs_feds_r(fed['fed_id'], [])) > 1:
        sfeds_list.remove(fed['fed_id'])
        this_fed_banned_count = len(banned_chats)

        await msg.edit_text(text + strings['fbanned_subs_process'].format(feds=len(sfeds_list)))

        all_banned_chats_count = 0
        for s_fed_id in sfeds_list:
            s_fed = await db.feds.find_one({'fed_id': s_fed_id})
            banned_chats = []
            for chat_id in s_fed['chats']:
                if not user:
                    continue

                elif chat_id == user['user_id']:
                    continue

                elif 'chats' not in user:
                    continue

                elif chat_id not in user['chats']:
                    continue

                # Do not slow down other updates
                await asyncio.sleep(0.2)

                if await ban_user(chat_id, user_id):
                    banned_chats.append(chat_id)
                    all_banned_chats_count += 1

                    new = {
                        'fed_id': s_fed_id,
                        'user_id': user_id,
                        'banned_chats': banned_chats,
                        'time': datetime.now(),
                        'origin_fed': fed['fed_id'],
                        'by': message.from_user.id
                    }

                    if reason:
                        new['reason'] = reason

                    await db.fed_bans.insert_one(new)

        await msg.edit_text(text + strings['fbanned_subs_done'].format(
            chats=this_fed_banned_count,
            subs_chats=all_banned_chats_count,
            feds=len(sfeds_list)
        ))

        channel_text += strings['fban_subs_fed_log'].format(
            subs_chats=all_banned_chats_count,
            feds=len(sfeds_list)
        )