def post(self, row_id, **options):
args = self.post_parser.parse_args()
try:
new_state = int(args["new_state"])
except (ValueError, KeyError):
return {"error": "Invalid `new_state` parameter."}, 400
with DBManager.create_session_scope() as db_session:
row = db_session.query(Module).filter_by(id=row_id).one_or_none()
if not row:
return {"error": "Module with this ID not found"}, 404
if validate_module(row_id) is False:
return {"error": "cannot modify module"}, 400
row.enabled = True if new_state == 1 else False
db_session.commit()
payload = {"id": row.id, "new_state": row.enabled}
AdminLogManager.post(
"Module toggled",
options["user"].discord_id,
"Enabled" if row.enabled else "Disabled",
row.id,
)
SocketClientManager.send("module.update", payload)
return {"success": "successful toggle", "new_state": new_state}
def get(self, timer_id, **options):
with DBManager.create_session_scope() as db_session:
timer = db_session.query(Timer).filter_by(
id=timer_id).one_or_none()
if timer is None:
return {"error": "Invalid timer ID"}, 404
AdminLogManager.post("Timer removed", options["user"].discord_id,
timer.name)
db_session.delete(timer)
SocketClientManager.send("timer.remove", {"id": timer.id})
return {"success": "good job"}
def add_link_whitelist(self, bot, source, message, **rest):
parts = message.split(" ")
try:
for link in parts:
self.whitelist_url(link)
AdminLogManager.post("Whitelist link added", source.discord_id, link)
except:
log.exception("Unhandled exception in add_link")
bot.whisper(source, "Some error occurred white adding your links")
return False
bot.whisper(source, "Successfully added your links")
def get(self, banphrase_id, **options):
with DBManager.create_session_scope() as db_session:
banphrase = (
db_session.query(Banphrase).filter_by(id=banphrase_id).one_or_none()
)
if banphrase is None:
return {"error": "Invalid banphrase ID"}, 404
AdminLogManager.post(
"Banphrase removed", options["user"].discord_id, banphrase.id, banphrase.phrase
)
db_session.delete(banphrase)
db_session.delete(banphrase.data)
SocketClientManager.send("banphrase.remove", {"id": banphrase.id})
return {"success": "good job"}, 200
def add_link_blacklist(self, bot, source, message, **rest):
options, new_links = self.parse_link_blacklist_arguments(message)
if new_links:
parts = new_links.split(" ")
try:
for link in parts:
if len(link) > 1:
self.blacklist_url(link, **options)
AdminLogManager.post("Blacklist link added", source.discord_id, link)
bot.whisper(source, "Successfully added your links")
return True
except:
log.exception("Unhandled exception in add_link_blacklist")
bot.whisper(source, "Some error occurred while adding your links")
return False
else:
bot.whisper(source, "Usage: !add link blacklist LINK")
return False
def remove_link_whitelist(self, bot, source, message, **rest):
if not message:
bot.whisper(source, "Usage: !remove link whitelist ID")
return False
id = None
try:
id = int(message)
except ValueError:
pass
link = self.db_session.query(WhitelistedLink).filter_by(id=id).one_or_none()
if link:
self.whitelisted_links.remove(link)
self.db_session.delete(link)
self.db_session.commit()
else:
bot.whisper(source, "No link with the given id found")
return False
AdminLogManager.post("Whitelist link removed", source.discord_id, link.domain)
bot.whisper(source, f"Successfully removed whitelisted link with id {link.id}")
def timers_create(**options):
session.pop("timer_created_id", None)
session.pop("timer_edited_id", None)
if request.method != "POST":
return render_template("admin/create_timer.html")
id = None
try:
if "id" in request.form:
id = int(request.form["id"])
name = request.form["name"].strip()
interval_online = int(request.form["interval_online"])
interval_offline = int(request.form["interval_offline"])
message_type = request.form["message_type"]
message = request.form["message"].strip()
except (KeyError, ValueError):
abort(403)
if interval_online < 0 or interval_offline < 0:
abort(403)
if message_type not in ["say", "me"]:
abort(403)
if not message:
abort(403)
user = options.get("user", None)
if user is None:
abort(403)
options = {
"name": name,
"interval_online": interval_online,
"interval_offline": interval_offline,
}
action = {"type": message_type, "message": message}
options["action"] = action
if id is None:
timer = Timer(**options)
with DBManager.create_session_scope(expire_on_commit=False) as db_session:
if id is not None:
timer = db_session.query(Timer).filter_by(id=id).one_or_none()
if timer is None:
return redirect("/admin/timers/", 303)
old_message = ""
new_message = ""
try:
old_message = timer.action.response
new_message = action["message"]
except:
pass
timer.set(**options)
if old_message and old_message != new_message:
log_msg = f'Timer "{timer.name}" has been updated from "{old_message}" to "{new_message}"'
else:
log_msg = f'Timer "{timer.name}" has been updated'
AdminLogManager.add_entry(
"Timer edited",
user.discord_id,
log_msg,
data={"old_message": old_message, "new_message": new_message},
)
else:
db_session.add(timer)
AdminLogManager.post("Timer added", user.discord_id, timer.name)
SocketClientManager.send("timer.update", {"id": timer.id})
if id is None:
session["timer_created_id"] = timer.id
else:
session["timer_edited_id"] = timer.id
return redirect("/admin/timers/", 303)
def cmd_module(bot, author, channel, message, whisper, args):
module_manager = bot.module_manager
if not message:
return
msg_args = message.split(" ")
if len(msg_args) < 1:
return
sub_command = msg_args[0].lower()
if sub_command == "list":
messages = split_into_chunks_with_prefix(
[{
"prefix": "Available modules:",
"parts":
[module.ID for module in module_manager.all_modules],
}],
" ",
default="No modules available.",
)
for message in messages:
if whisper:
bot.private_message(author, message)
continue
bot.say(channel, message)
elif sub_command == "disable":
if len(msg_args) < 2:
return
module_id = msg_args[1].lower()
module = module_manager.get_module(module_id)
if not module:
if whisper:
bot.private_message(
author, f"No module with the id {module_id} found")
return
bot.say(channel, f"No module with the id {module_id} found")
return
if module.MODULE_TYPE > ModuleType.TYPE_NORMAL:
if whisper:
bot.private_message(
author, f"Unable to disable module {module_id}")
return
bot.say(channel, f"Unable to disable module {module_id}")
return
if not module_manager.disable_module(module_id):
if whisper:
bot.private_message(
author,
f"Unable to disable module {module_id}, maybe it's not enabled?",
)
return
bot.say(
channel,
f"Unable to disable module {module_id}, maybe it's not enabled?",
)
return
# Rebuild command cache
bot.commands.rebuild()
with DBManager.create_session_scope() as db_session:
db_module = db_session.query(Module).filter_by(
id=module_id).one()
db_module.enabled = False
AdminLogManager.post("Module toggled", source.discord_id,
"Disabled", module_id)
if whisper:
bot.private_message(author, f"Disabled module {module_id}")
return
bot.say(channel, f"Disabled module {module_id}")
elif sub_command == "enable":
if len(msg_args) < 2:
return
module_id = msg_args[1].lower()
module = module_manager.get_module(module_id)
if not module:
if whisper:
bot.private_message(
author, f"No module with the id {module_id} found")
return
bot.say(channel, f"No module with the id {module_id} found")
return
if module.MODULE_TYPE > ModuleType.TYPE_NORMAL:
if whisper:
bot.private_message(
author, f"Unable to enable module {module_id}")
return
bot.say(channel, f"Unable to enable module {module_id}")
return
if not module_manager.enable_module(module_id):
if whisper:
bot.private_message(
author,
f"Unable to enable module {module_id}, maybe it's already enabled?",
)
return
bot.say(
channel,
f"Unable to enable module {module_id}, maybe it's already enabled?",
)
return
# Rebuild command cache
bot.commands.rebuild()
with DBManager.create_session_scope() as db_session:
db_module = db_session.query(Module).filter_by(
id=module_id).one()
db_module.enabled = True
AdminLogManager.post("Module toggled", source.discord_id,
"Enabled", module_id)
if whisper:
bot.private_message(author, "Enabled module {module_id}")
return
bot.say(channel, "Enabled module {module_id}")
def modules_edit(module_id, **options):
module_manager = ModuleManager(None).load(do_reload=False)
current_module = find(lambda m: m.ID == module_id,
module_manager.all_modules)
user = options["user"]
if user.level < current_module.CONFIGURE_LEVEL:
return (
render_template(
"errors/403.html",
extra_message=
"You do not have permission to configure this module.",
),
403,
)
if current_module is None:
return render_template("admin/module_404.html"), 404
sub_modules = []
for module in module_manager.all_modules:
module.db_module = None
with DBManager.create_session_scope() as db_session:
for db_module in db_session.query(Module):
module = find(lambda m: m.ID == db_module.id,
module_manager.all_modules)
if module:
module.db_module = db_module
if module.PARENT_MODULE == current_module.__class__:
sub_modules.append(module)
if current_module.db_module is None:
return render_template("admin/module_404.html"), 404
if request.method != "POST":
settings = None
try:
settings = json.loads(current_module.db_module.settings)
except (TypeError, ValueError):
pass
current_module.load(settings=settings)
return render_template(
"admin/configure_module.html",
module=current_module,
sub_modules=sub_modules,
)
form_values = {key: value for key, value in request.form.items()}
res = current_module.parse_settings(**form_values)
if res is False:
return render_template("admin/module_404.html"), 404
current_module.db_module.settings = json.dumps(res)
db_session.commit()
settings = None
try:
settings = json.loads(current_module.db_module.settings)
except (TypeError, ValueError):
pass
current_module.load(settings=settings)
payload = {"id": current_module.db_module.id}
SocketClientManager.send("module.update", payload)
AdminLogManager.post("Module edited", user.discord_id,
current_module.NAME)
return render_template(
"admin/configure_module.html",
module=current_module,
sub_modules=sub_modules,
)
def banphrases_create(**options):
session.pop("banphrase_created_id", None)
session.pop("banphrase_edited_id", None)
if request.method == "POST":
id = None
try:
if "id" in request.form:
id = int(request.form["id"])
name = request.form["name"].strip()
permanent = request.form.get("permanent", "off")
warning = request.form.get("warning", "off")
notify = request.form.get("notify", "off")
case_sensitive = request.form.get("case_sensitive", "off")
sub_immunity = request.form.get("sub_immunity", "off")
remove_accents = request.form.get("remove_accents", "off")
length = int(request.form["length"])
phrase = request.form["phrase"]
operator = request.form["operator"].strip().lower()
except (KeyError, ValueError):
abort(403)
permanent = permanent == "on"
warning = warning == "on"
notify = notify == "on"
case_sensitive = case_sensitive == "on"
sub_immunity = sub_immunity == "on"
remove_accents = remove_accents == "on"
if not name:
abort(403)
if not phrase:
abort(403)
if length < 0 or length > 1209600:
abort(403)
valid_operators = [
"contains", "startswith", "endswith", "exact", "regex"
]
if operator not in valid_operators:
abort(403)
user = options.get("user", None)
if user is None:
abort(403)
options = {
"name": name,
"phrase": phrase,
"permanent": permanent,
"warning": warning,
"notify": notify,
"case_sensitive": case_sensitive,
"sub_immunity": sub_immunity,
"remove_accents": remove_accents,
"length": length,
"added_by": user.discord_id,
"edited_by": user.discord_id,
"operator": operator,
}
if id is None:
banphrase = Banphrase(**options)
banphrase.data = BanphraseData(banphrase.id,
added_by=options["added_by"])
with DBManager.create_session_scope(
expire_on_commit=False) as db_session:
if id is not None:
banphrase = (db_session.query(Banphrase).options(
joinedload(
Banphrase.data)).filter_by(id=id).one_or_none())
if banphrase is None:
return redirect("/admin/banphrases/", 303)
banphrase.set(**options)
banphrase.data.set(edited_by=options["edited_by"])
log.info(
f"Updated banphrase ID {banphrase.id} by user ID {options['edited_by']}"
)
AdminLogManager.post("Banphrase edited", user.discord_id,
banphrase.id, banphrase.phrase)
else:
db_session.add(banphrase)
db_session.add(banphrase.data)
db_session.flush()
log.info(
f"Added a new banphrase by user ID {options['added_by']}"
)
AdminLogManager.post("Banphrase added", user.discord_id,
banphrase.id, banphrase.phrase)
SocketClientManager.send("banphrase.update", {"id": banphrase.id})
if id is None:
session["banphrase_created_id"] = banphrase.id
else:
session["banphrase_edited_id"] = banphrase.id
return redirect("/admin/banphrases/", 303)
else:
return render_template("admin/create_banphrase.html")
