async def await_cmd(message: types.message): check_id(message.from_user) await message.chat.do(types.ChatActions.TYPING) with Session as session: user = session.query(User).filter_by(id=message.from_user.id).first() logger.info(f"{message.from_user.username} do edt awaited command") url = str() if message.photo: file_path = await bot.get_file(message.photo[0].file_id) file_url = f"https://api.telegram.org/file/bot{API_TOKEN}/{file_path['file_path']}" qr = decode(Image.open(requests.get(file_url, stream=True).raw)) if qr: url = str(qr[0].data) elif message.text: msg_url = re_url.findall(message.text) if msg_url: url = msg_url[0] if url: resources = url[url.find("resources") + 10:][:4] elif message.text: resources = message.text try: string_to_container(requests.get(Calendar("", int(resources)).url).text) except (ParseError, ConnectionError, InvalidSchema, MissingSchema, ValueError, UnboundLocalError): msg = lang(user, "setedt_err_res") else: user.resources = int(resources) msg = lang(user, "setedt") user.await_cmd = str() session.commit() await message.reply(msg, parse_mode=ParseMode.MARKDOWN, reply_markup=key)
def load(): logger.info(f"Load {module_name} module") dp.register_message_handler(kfet, lambda msg: msg.text.lower() == "kfet") dp.register_message_handler(kfet_set, lambda msg: msg.text.lower() == "setkfet") dp.register_message_handler(await_cmd, lambda msg: have_await_cmd(msg)) modules_active.append(module_name)
async def get_logs(message: types.Message): check_id(message.from_user) logger.info(f"{message.from_user.username} do getlog command") if message.from_user.id == ADMIN_ID: try: int(message.text[9:]) except ValueError: await message.chat.do(types.ChatActions.UPLOAD_DOCUMENT) await message.reply_document(types.InputFile(f"logs/current.log"), caption="The logs file", reply_markup=key) else: await message.chat.do(types.ChatActions.TYPING) logs = (open(f"logs/current.log", "r").readlines())[-int(message.text[9:]):] log = str() for i in logs: log += i msg = markdown.text(markdown.italic("logs:"), markdown.code(log), sep="\n") try: await message.reply(msg, parse_mode=ParseMode.MARKDOWN, reply_markup=key) except MessageIsTooLong: await message.reply(markdown.bold("Too much logs ! ❌"), reply_markup=key)
def load(): logger.info(f"Load {module_name} module") dp.register_message_handler(get_id, commands="getid") dp.register_message_handler(get_logs, commands="getlogs") dp.register_message_handler(get_db, commands="getdb") dp.register_message_handler(eval_cmd, commands="eval") dp.register_errors_handler(errors) modules_active.append(module_name)
def unload(): logger.info(f"Unload {module_name} module") dp.message_handlers.unregister(get_id) dp.message_handlers.unregister(get_logs) dp.message_handlers.unregister(get_db) dp.message_handlers.unregister(eval_cmd) dp.errors_handlers.unregister(errors) modules_active.remove(module_name)
def load(): logger.info(f"Load {module_name} module") dp.register_message_handler(notif_cmd, lambda msg: msg.text.lower() == "notif") dp.register_callback_query_handler( notif_query, posts_cb.filter(action=["toggle", "time", "cooldown"])) dp.register_message_handler(await_cmd, lambda msg: have_await_cmd(msg)) modules_active.append(module_name)
async def help_cmd(message: types.Message): check_id(message.from_user) await message.chat.do(types.ChatActions.TYPING) logger.info(f"{message.from_user.username} do help command") with Session as session: user = session.query(User).filter_by(id=message.from_user.id).first() msg = lang(user, "help") await message.reply(msg, parse_mode=ParseMode.MARKDOWN, reply_markup=key)
def unload(): logger.info(f"Unload {module_name} module") dp.message_handlers.unregister(edt_cmd) dp.inline_query_handlers.unregister(inline_edt) dp.callback_query_handlers.unregister(edt_query) dp.message_handlers.unregister(edt_await) dp.message_handlers.unregister(await_cmd) dp.message_handlers.unregister(edt_geturl) modules_active.remove(module_name)
def load(): logger.info(f"Load {module_name} module") dp.register_message_handler(edt_cmd, lambda msg: msg.text.lower() == "edt") dp.register_inline_handler(inline_edt) dp.register_callback_query_handler(edt_query, posts_cb.filter(action=["day", "next", "week", "next week"])) dp.register_message_handler(edt_await, lambda msg: msg.text.lower() == "setedt") dp.register_message_handler(await_cmd, lambda msg: have_await_cmd(msg), content_types=[ContentType.TEXT, ContentType.PHOTO]) dp.register_message_handler(edt_geturl, commands="getedt") modules_active.append(module_name)
async def unload_cmd(message: Message): logger.info(f"{message.from_user.username} do unload command") if message.from_user.id == ADMIN_ID: module = message.text[8:] if unload_module(module): msg = f"Module {module} unloaded !" else: msg = f"Fail to unload module {module} !" await message.reply(msg)
async def eval_cmd(message: types.Message): check_id(message.from_user) logger.info(f"{message.from_user.username} do eval command") if message.from_user.id == ADMIN_ID: msg = markdown.text(markdown.italic("eval:"), markdown.code(eval(message.text[6:])), sep="\n") await message.reply(msg, parse_mode=ParseMode.MARKDOWN, reply_markup=key)
async def edt_geturl(message: types.Message): check_id(message.from_user) await message.chat.do(types.ChatActions.TYPING) logger.info(f"{message.from_user.username} do getedt command") with Session as session: user = session.query(User).filter_by(id=message.from_user.id).first() if user.resources: msg = user.resources else: msg = lang(user, "getedt_err") await message.reply(msg, reply_markup=key)
async def get_db(message: types.Message): check_id(message.from_user) logger.info(f"{message.from_user.username} do getdb command") if message.from_user.id == ADMIN_ID: with Session as session: users = dict() for u in session.query(User).all(): users[u] = u.__dict__ msg = markdown.text(markdown.italic("db:"), markdown.code(users), sep="\n") await message.reply(msg, parse_mode=ParseMode.MARKDOWN, reply_markup=key)
async def kfet_set(message: types.Message): check_id(message.from_user) await message.chat.do(types.ChatActions.TYPING) logger.info(f"{message.from_user.username} do setkfet") with Session as session: user = session.query(User).filter_by(id=message.from_user.id).first() if not 9 < get_now().hour < 14 or not get_now().isoweekday() < 5: msg = lang(user, "kfet_close") else: user.await_cmd = "setkfet" msg = lang(user, "kfet_set_await") session.commit() await message.reply(msg, parse_mode=ParseMode.MARKDOWN, reply_markup=key)
async def notif_cmd(message: types.Message): check_id(message.from_user) await message.chat.do(types.ChatActions.TYPING) logger.info(f"{message.from_user.username} do notif") keys = InlineKeyboardMarkup() for i, n in enumerate(["Toggle", "Time", "Cooldown"]): keys.add( InlineKeyboardButton(n, callback_data=posts_cb.new(id=i, action=n.lower()))) with Session as session: user = session.query(User).filter_by(id=message.from_user.id).first() msg = lang(user, "notif_info").format(user.nt, user.nt_time, user.nt_cooldown) await message.reply(msg, parse_mode=ParseMode.MARKDOWN, reply_markup=keys)
async def await_cmd(message: types.message): check_id(message.from_user) await message.chat.do(types.ChatActions.TYPING) with Session as session: user = session.query(User).filter_by(id=message.from_user.id).first() logger.info(f"{message.from_user.username} do awaited command") if not len(parse(message.text).entries): msg = lang(user, "settomuss_error") else: user.tomuss_rss = message.text user.tomuss_last = str() msg = lang(user, "settomuss") user.await_cmd = str() session.commit() await message.reply(msg, parse_mode=ParseMode.MARKDOWN, reply_markup=key)
async def await_cmd(message: types.message): check_id(message.from_user) await message.chat.do(types.ChatActions.TYPING) with Session as session: user = session.query(User).filter_by(id=message.from_user.id).first() logger.info(f"{message.from_user.username} do awaited command") try: int(message.text) except ValueError: msg = lang(user, "err_num") else: user.kfet = int(message.text) msg = lang(user, "kfet_set") user.await_cmd = str() session.commit() await message.reply(msg, parse_mode=ParseMode.MARKDOWN, reply_markup=key)
async def notif_query(query: types.CallbackQuery, callback_data: dict): check_id(query.message.from_user) await query.message.chat.do(types.ChatActions.TYPING) logger.info(f"{query.message.from_user.username} do notif query") with Session as session: user = session.query(User).filter_by(id=query.from_user.id).first() if callback_data["action"] == "toggle": if user.nt: res = False else: res = True user.nt = res msg = lang(user, "notif_set").format(res) elif callback_data["action"] in ["time", "cooldown"]: user.await_cmd = callback_data["action"] msg = lang(user, "notif_await") session.commit() await query.message.reply(msg, parse_mode=ParseMode.MARKDOWN)
async def kfet(message: types.Message): check_id(message.from_user) await message.chat.do(types.ChatActions.TYPING) logger.info(f"{message.from_user.username} do kfet") with Session as session: user = session.query(User).filter_by(id=message.from_user.id).first() if not 9 < get_now().hour < 14 or not get_now().isoweekday() < 6: msg = lang(user, "kfet_close") else: msg = lang(user, "kfet_list") try: cmds = requests.get(KFET_URL).json() except (requests.exceptions.ConnectionError, requests.exceptions.ConnectTimeout): msg = markdown.bold(lang(user, "kfet_error")) else: if cmds: for c in cmds: msg += markdown.code( c) + " " if cmds[c] == "ok" else "" await message.reply(msg, parse_mode=ParseMode.MARKDOWN, reply_markup=key)
async def await_cmd(message: types.message): check_id(message.from_user) await message.chat.do(types.ChatActions.TYPING) with Session as session: user = session.query(User).filter_by(id=message.from_user.id).first() logger.info(f"{message.from_user.username} do awaited command") try: value = int(message.text) except ValueError: msg = lang(user, "err_num") else: if user.await_cmd == "time": user.nt_time = value else: user.nt_cooldown = value msg = lang(user, "notif_time_cooldown").format(user.await_cmd, value) user.await_cmd = str() session.commit() await message.reply(msg, parse_mode=ParseMode.MARKDOWN, reply_markup=key)
def unload(): logger.info(f"Unload {module_name} module") dp.message_handlers.unregister(notif_cmd) dp.callback_query_handlers.unregister(notif_query) dp.message_handlers.unregister(await_cmd) modules_active.remove(module_name)
def unload(): logger.info(f"Unload {module_name} module") dp.message_handlers.unregister(load_cmd) dp.message_handlers.unregister(unload_cmd) modules_active.remove(module_name)
def load(): logger.info(f"Load {module_name} module") dp.register_message_handler(load_cmd, commands="load") dp.register_message_handler(unload_cmd, commands="unload") modules_active.append(module_name)
async def edt_query(query: types.CallbackQuery, callback_data: dict): check_id(query.message.from_user) await query.message.chat.do(types.ChatActions.TYPING) logger.info(f"{query.message.from_user.username} do edt query") await query.message.reply(calendar(callback_data["action"], query.from_user.id), parse_mode=ParseMode.MARKDOWN, reply_markup=edt_key())
async def get_id(message: types.Message): check_id(message.from_user) await message.chat.do(types.ChatActions.TYPING) logger.info(f"{message.from_user.username} do getid command") await message.reply(message.from_user.id, reply_markup=key)
def load(): logger.info(f"Load {module_name} module") dp.register_message_handler(start, commands="start") dp.register_message_handler(help_cmd, commands="help") modules_active.append(module_name)
async def edt_cmd(message: types.Message): check_id(message.from_user) await message.chat.do(types.ChatActions.TYPING) logger.info(f"{message.from_user.username} do edt") await message.reply(calendar("day", message.from_user.id), parse_mode=ParseMode.MARKDOWN, reply_markup=edt_key())
def unload(): logger.info(f"Unload {module_name} module") dp.message_handlers.unregister(settomuss) dp.message_handlers.unregister(await_cmd) modules_active.remove(module_name)