def main():
test_handler = CommandHandler("test", test)
start_handler = CommandHandler("start", start)
help_handler = CommandHandler("help", get_help)
help_callback_handler = CallbackQueryHandler(help_button, pattern=r"help_.*")
settings_handler = CommandHandler("settings", get_settings)
settings_callback_handler = CallbackQueryHandler(settings_button, pattern=r"stngs_")
donate_handler = CommandHandler("donate", donate)
migrate_handler = MessageHandler(Filters.status_update.migrate, migrate_chats)
# dispatcher.add_handler(test_handler)
dispatcher.add_handler(start_handler)
dispatcher.add_handler(help_handler)
dispatcher.add_handler(settings_handler)
dispatcher.add_handler(help_callback_handler)
dispatcher.add_handler(settings_callback_handler)
dispatcher.add_handler(migrate_handler)
dispatcher.add_handler(donate_handler)
dispatcher.add_error_handler(error_callback)
if WEBHOOK:
LOGGER.info("Using webhooks.")
updater.start_webhook(listen="0.0.0.0", port=PORT, url_path=TOKEN)
if CERT_PATH:
updater.bot.set_webhook(url=URL + TOKEN, certificate=open(CERT_PATH, "rb"))
else:
updater.bot.set_webhook(url=URL + TOKEN)
else:
LOGGER.info("Using long polling.")
updater.start_polling(timeout=15, read_latency=4, clean=True)
if len(argv) not in (1, 3, 4):
telethn.disconnect()
else:
telethn.run_until_disconnected()
updater.idle()
def shell(update: Update, context: CallbackContext):
message = update.effective_message
cmd = message.text.split(" ", 1)
if len(cmd) == 1:
message.reply_text("No command to execute was given.")
return
cmd = cmd[1]
process = subprocess.Popen(cmd,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
shell=True)
stdout, stderr = process.communicate()
msg = ""
stderr = stderr.decode()
stdout = stdout.decode()
if stdout:
msg += f"*Stdout*\n`{stdout}`\n"
LOGGER.info(f"Shell - {cmd} - {stdout}")
if stderr:
msg += f"*Stderr*\n`{stderr}`\n"
LOGGER.error(f"Shell - {cmd} - {stderr}")
if len(msg) > 3000:
with open("shell_output.txt", "w") as file:
file.write(msg)
with open("shell_output.txt", "rb") as doc:
delmsg = message.reply_document(
document=doc,
filename=doc.name,
reply_to_message_id=message.message_id,
)
else:
delmsg = message.reply_text(
text=msg,
parse_mode=ParseMode.MARKDOWN,
disable_web_page_preview=True,
)
context.dispatcher.run_async(delete, delmsg, 120)
def term(cmd, info):
process = subprocess.Popen(
cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True
)
stdout, stderr = process.communicate()
stderr = stderr.decode()
stdout = stdout.decode()
if stdout:
log.info(f"{info} successful!")
log.info(f"{stdout}")
if stderr:
log.error(f"error while running {info}")
log.info(f"{stderr}")
dispatcher.add_handler(donate_handler)
dispatcher.add_error_handler(error_callback)
if WEBHOOK:
LOGGER.info("Using webhooks.")
updater.start_webhook(listen="0.0.0.0", port=PORT, url_path=TOKEN)
if CERT_PATH:
updater.bot.set_webhook(
url=URL + TOKEN, certificate=open(CERT_PATH, 'rb'))
else:
updater.bot.set_webhook(url=URL + TOKEN)
else:
LOGGER.info("Using long polling.")
updater.start_polling(timeout=15, read_latency=4, clean=True)
if len(argv) not in (1, 3, 4):
telethn.disconnect()
else:
telethn.run_until_disconnected()
updater.idle()
if __name__ == '__main__':
LOGGER.info("Successfully loaded modules: " + str(ALL_MODULES))
telethn.start(bot_token=TOKEN)
main()
if isfile(f) and f.endswith(".py") and not f.endswith("__init__.py")
]
if LOAD or NO_LOAD:
to_load = LOAD
if to_load:
if not all(
any(mod == module_name for module_name in all_modules)
for mod in to_load):
LOGGER.error("Invalid loadorder names. Quitting.")
quit(1)
all_modules = sorted(set(all_modules) - set(to_load))
to_load = list(all_modules) + to_load
else:
to_load = all_modules
if NO_LOAD:
LOGGER.info("Not loading: {}".format(NO_LOAD))
return [item for item in to_load if item not in NO_LOAD]
return to_load
return all_modules
ALL_MODULES = __list_all_modules()
LOGGER.info("Modules to load: %s", str(ALL_MODULES))
__all__ = ALL_MODULES + ["ALL_MODULES"]
def log_input(update):
user = update.effective_user.id
chat = update.effective_chat.id
LOGGER.info(
f"IN: {update.effective_message.text} (user={user}, chat={chat})")
def backup_db(_: CallbackContext):
bot = dispatcher.bot
tmpmsg = "Performing backup, Please wait..."
tmp = bot.send_message(OWNER_ID, tmpmsg)
datenow = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
dbbkpname = "db_{}_{}.tar".format(bot.username, datenow)
bkplocation = "backups/{}".format(datenow)
bkpcmd = "pg_dump {} --format=tar > {}/{}".format(DB_NAME, bkplocation, dbbkpname)
if not os.path.exists(bkplocation):
os.makedirs(bkplocation)
log.info("performing db backup")
loginfo = "db backup"
term(bkpcmd, loginfo)
if not os.path.exists('{}/{}'.format(bkplocation, dbbkpname)):
bot.send_message(OWNER_ID, "An error occurred during the db backup")
tmp.edit_text("Backup Failed!")
sleep(8)
tmp.delete()
return
else:
log.info("copying config, and logs to backup location")
if os.path.exists('log.txt'):
print("logs copied")
shutil.copyfile('log.txt', '{}/log.txt'.format(bkplocation))
if os.path.exists('AstrakoBot/config.py'):
print("config copied")
shutil.copyfile('AstrakoBot/config.py', '{}/config.py'.format(bkplocation))
log.info("zipping the backup")
zipcmd = "zip --password '{}' {} {}/*".format(zip_pass, bkplocation, bkplocation)
zipinfo = "zipping db backup"
log.info("zip started")
term(zipcmd, zipinfo)
log.info("zip done")
sleep(1)
with open('backups/{}'.format(f'{datenow}.zip'), 'rb') as bkp:
nm = "{} backup \n".format(bot.username) + datenow
bot.send_document(OWNER_ID,
document=bkp,
caption=nm,
timeout=20
)
log.info("removing zipped files")
shutil.rmtree("backups/{}".format(datenow))
log.info("backup done")
tmp.edit_text("Backup complete!")
sleep(5)
tmp.delete()