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)
