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 add_alias(bot, author, channel, message, args):
"""Dispatch method for adding aliases to already-existing commands.
Usage: !add alias EXISTING_ALIAS NEW_ALIAS_1 NEW_ALIAS_2 ...
"""
if message:
message = message.replace("!", "").lower()
# Make sure we got both an existing alias and at least one new alias
message_parts = message.split()
if len(message_parts) < 2:
bot.private_message(
author, "Usage: !add alias existingalias newalias")
return False
existing_alias = message_parts[0]
new_aliases = re.split(r"\|| ", " ".join(message_parts[1:]))
added_aliases = []
already_used_aliases = []
if existing_alias not in bot.commands:
bot.private_message(
author, f'No command called "{existing_alias}" found')
return False
command = bot.commands[existing_alias]
# error out on commands that are not from the DB, e.g. module commands like !8ball that cannot have
# aliases registered. (command.command and command.data are None on those commands)
if command.data is None or command.command is None:
bot.private_message(
author, "That command cannot have aliases added to.")
return False
for alias in set(new_aliases):
if alias in bot.commands:
already_used_aliases.append(alias)
else:
added_aliases.append(alias)
bot.commands[alias] = command
if len(added_aliases) > 0:
new_aliases = f"{command.command}|{'|'.join(added_aliases)}"
bot.commands.edit_command(command, command=new_aliases)
bot.private_message(
author,
f"Successfully added the aliases {', '.join(added_aliases)} to {existing_alias}",
)
log_msg = f"The aliases {', '.join(added_aliases)} has been added to {existing_alias}"
AdminLogManager.add_entry("Alias added", str(author.id),
log_msg)
if len(already_used_aliases) > 0:
bot.private_message(
author,
f"The following aliases were already in use: {', '.join(already_used_aliases)}",
)
else:
bot.private_message(author,
"Usage: !add alias existingalias newalias")
async def edit_funccommand(bot, author, channel, message, args):
"""Dispatch method for editing function commands.
Usage: !edit funccommand ALIAS [options] CALLBACK
See greenbot/managers/command.py parse_command_arguments for available options
"""
if message:
# Make sure we got both an alias and a response
message_parts = message.split(" ")
if len(message_parts) < 2:
await bot.private_message(
author,
"Usage: !edit funccommand ALIAS [options] [CALLBACK]")
return False
options, response = bot.commands.parse_command_arguments(
message_parts[1:])
options["edited_by"] = str(author.id)
if options is False:
await bot.private_message(author, "Invalid command")
return False
alias = message_parts[0].replace("!", "").lower()
type = "reply"
if options["privatemessage"] is True:
type = "privatemessage"
elif options["reply"] is True:
type = "reply"
options["action"] = {
"type": type,
"message": None,
"functions": response,
}
if "channels" in options:
options["channels"] = json.dumps(options["channels"])
command = bot.commands.get(alias, None)
if command is None:
await bot.private_message(
author,
f"No command found with the alias {alias}. Did you mean to create the command? If so, use !add funccommand instead.",
)
return False
bot.commands.edit_command(command, **options)
await bot.private_message(
author, f"Updated the command (ID: {command.id})")
AdminLogManager.add_entry(
"Command edited",
str(author.id),
f"The !{command.command.split('|')[0]} command has been updated",
)
async def remove_alias(bot, author, channel, message, args):
"""Dispatch method for removing aliases from a command.
Usage: !remove alias EXISTING_ALIAS_1"""
if message:
aliases = re.split(r"\|| ", message.lower())
if len(aliases) < 1:
await bot.private_message(
author,
"Usage: !remove alias EXISTING_ALIAS_1|EXISTING_ALIAS_2|..."
)
return False
for alias in aliases:
if alias not in bot.commands:
await bot.private_message(
author,
f"{alias} is not currently an alias",
)
continue
command = bot.commands[alias]
# error out on commands that are not from the DB, e.g. module commands like !8ball that cannot have
# aliases registered. (command.command and command.data are None on those commands)
if command.data is None or command.command is None:
await bot.private_message(
author,
f"That command, {alias}, cannot have aliases removed from."
)
continue
current_aliases = command.aliases
current_aliases.remove(alias)
if len(current_aliases) == 0:
await bot.private_message(
author,
f"{alias} is the only remaining alias for this command and can't be removed.",
)
continue
new_aliases = "|".join(current_aliases)
bot.commands.edit_command(command,
command=new_aliases.replace(
command.group, ""))
del bot.commands[alias]
log_msg = (
f"The alias {alias} has been removed from {new_aliases.split('|')[0]}"
)
AdminLogManager.add_entry("Alias removed", str(author.id),
log_msg)
await bot.private_message(
author, f"Successfully removed aliase {alias}.")
else:
await bot.private_message(
author, "Usage: !remove alias EXISTINGALIAS")
async def add_funccommand(bot, author, channel, message, args):
"""Dispatch method for creating function commands.
Usage: !add funccommand ALIAS [options] CALLBACK
See greenbot/managers/command.py parse_command_arguments for available options
"""
if message:
# Make sure we got both an alias and a response
message_parts = message.split(" ")
if len(message_parts) < 2:
await bot.private_message(
author, "Usage: !add funccommand ALIAS [options] CALLBACK")
return False
options, response = bot.commands.parse_command_arguments(
message_parts[1:])
options["added_by"] = str(author.id)
if options is False:
await bot.private_message(author, "Invalid command")
return False
alias_str = message_parts[0].replace("!", "").lower()
type = "reply"
if options["privatemessage"] is True:
type = "privatemessage"
elif options["reply"] is True:
type = "reply"
action = {
"type": type,
"message": None,
"functions": response,
}
if "channels" in options:
options["channels"] = json.dumps(options["channels"])
command, new_command, alias_matched = bot.commands.create_command(
alias_str, action=action, **options)
if new_command is True:
await bot.private_message(
author, f"Added your command (ID: {command.id})")
AdminLogManager.add_entry(
"Command created",
str(author.id),
f"The !{command.command.split('|')[0]} command has been created",
)
return True
# At least one alias is already in use, notify the user to use !edit command instead
await bot.private_message(
author,
f"The alias {alias_matched} is already in use. To edit that command, use !edit command instead of !add funccommand.",
)
return False
def remove_alias(bot, author, channel, message, args):
"""Dispatch method for removing aliases from a command.
Usage: !remove alias EXISTING_ALIAS_1 EXISTING_ALIAS_2"""
if message:
aliases = re.split(r"\|| ", message.lower())
if len(aliases) < 1:
bot.private_message(author,
"Usage: !remove alias EXISTINGALIAS")
return False
num_removed = 0
commands_not_found = []
for alias in aliases:
if alias not in bot.commands:
commands_not_found.append(alias)
continue
command = bot.commands[alias]
# error out on commands that are not from the DB, e.g. module commands like !8ball that cannot have
# aliases registered. (command.command and command.data are None on those commands)
if command.data is None or command.command is None:
bot.private_message(
author,
"That command cannot have aliases removed from.")
return False
current_aliases = command.command.split("|")
current_aliases.remove(alias)
if len(current_aliases) == 0:
bot.private_message(
author,
f"{alias} is the only remaining alias for this command and can't be removed.",
)
continue
new_aliases = "|".join(current_aliases)
bot.commands.edit_command(command, command=new_aliases)
num_removed += 1
del bot.commands[alias]
log_msg = f"The alias {alias} has been removed from {new_aliases.split('|')[0]}"
AdminLogManager.add_entry("Alias removed", str(author.id),
log_msg)
whisper_str = ""
if num_removed > 0:
whisper_str = f"Successfully removed {num_removed} aliases."
if len(commands_not_found) > 0:
whisper_str += f" Aliases {', '.join(commands_not_found)} not found"
if len(whisper_str) > 0:
bot.private_message(author, whisper_str)
else:
bot.private_message(author, "Usage: !remove alias EXISTINGALIAS")
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")
async def remove_command(bot, author, channel, message, args):
if message:
id = None
command = None
try:
id = int(message)
except Exception:
pass
if id is None:
split = message.split(" ")
potential_cmd = "".join(split[:1]).lower().replace("!", "")
if potential_cmd in bot.commands:
command = bot.commands[potential_cmd]
potential_cmd += (" " + split[1]) if len(split) > 1 else ""
if potential_cmd in bot.commands:
command = bot.commands[potential_cmd]
else:
for key, check_command in bot.commands.items():
if check_command.id == id:
command = check_command
break
if command is None:
await bot.private_message(
author, "No command with the given parameters found")
return False
if command.id == -1:
await bot.private_message(
author,
"That command is an internal command, it cannot be removed."
)
return False
if args["user_level"] < 1500:
if command.action is not None and not command.action.type == "message":
await bot.private_message(
author,
"That command is not a normal command, it cannot be removed by you.",
)
return False
await bot.private_message(
author, f"Successfully removed command with id {command.id}")
log_msg = f"The !{command.aliases[0]} command has been removed"
AdminLogManager.add_entry("Command removed", str(author.id),
log_msg)
bot.commands.remove_command(command)
else:
await bot.private_message(
author, "Usage: !remove command (COMMAND_ID|COMMAND_ALIAS)")
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 get(self, command_id, **options):
with DBManager.create_session_scope() as db_session:
command = db_session.query(Command).filter_by(
id=command_id).one_or_none()
if command is None:
return {"error": "Invalid command ID"}, 404
if command.level > options["user"].level or (
command.action.functions and options["user"].level < 1500):
return {"error": "Unauthorized"}, 403
log_msg = f"The !{command.command.split('|')[0]} command has been removed"
AdminLogManager.add_entry("Command removed",
options["user"].discord_id, log_msg)
db_session.delete(command.data)
db_session.delete(command)
if (SocketClientManager.send("command.remove",
{"command_id": command_id}) is True):
return {"success": "good job"}, 200
else:
return {"error": "could not push update"}, 500
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}")
async def edit_command(bot, author, channel, message, args):
"""Dispatch method for editing commands.
Usage: !edit command "ALIAS" [options] RESPONSE
See greenbot/managers/command.py parse_command_arguments for available options
"""
if message:
# Make sure we got both an alias and a response
search = re.compile(r"\"([^\"]+)\" (.*)").search(message)
alias = search.group(1).replace("!", "").lower()
message_parts = search.group(2).split()
if not alias or not message_parts:
await bot.private_message(
author, "Usage: !add command \"ALIAS\" [options] RESPONSE")
return False
options, response = bot.commands.parse_command_arguments(
message_parts)
options["edited_by"] = str(author.id)
if options is False:
await bot.private_message(author, "Invalid command")
return False
type = "reply"
if options["privatemessage"] is True:
type = "privatemessage"
elif options["reply"] is True:
type = "reply"
action = {"type": type, "message": response}
command = bot.commands.get(alias, None)
if command is None:
await bot.private_message(
author,
f"No command found with the alias {alias}. Did you mean to create the command? If so, use !add command instead.",
)
return False
old_message = ""
new_message = ""
if len(action["message"]) > 0:
options["action"] = action
old_message = command.action.response
new_message = action["message"]
elif not type == command.action.subtype:
options["action"] = {
"type": type,
"message": command.action.response
}
if "channels" in options:
options["channels"] = json.dumps(options["channels"])
bot.commands.edit_command(command, **options)
await bot.private_message(
author, f"Updated the command (ID: {command.id})")
if len(new_message) > 0:
log_msg = f'The !{command.aliases[0]} command has been updated from "{old_message}" to "{new_message}"'
else:
log_msg = (
f"The !{command.aliases[0]} command has been updated")
AdminLogManager.add_entry(
"Command edited",
str(author.id),
log_msg,
data={
"old_message": old_message,
"new_message": new_message
},
)
def post(self, command_id, **extra_args):
args = greenbot.utils.remove_none_values(self.post_parser.parse_args())
if len(args) == 0:
return {"error": "Missing parameter to edit."}, 400
valid_names = [
"enabled",
"level",
"delay_all",
"delay_user",
"cost",
"can_execute_with_whisper",
"sub_only",
]
valid_action_names = ["type", "message", "functions"]
with DBManager.create_session_scope() as db_session:
command = (db_session.query(Command).options(
joinedload(Command.data).joinedload(
CommandData.user)).filter_by(id=command_id).one_or_none())
if command is None:
return {"error": "Invalid command ID"}, 404
if command.level > extra_args["user"].level:
return {"error": "Unauthorized"}, 403
parsed_action = json.loads(command.action_json)
options = {"edited_by": extra_args["user"].discord_id}
for key in args:
if key.startswith("data_"):
name = key[5:]
value = args[key]
if name.startswith("action_"):
name = name[7:]
if (name in valid_action_names
and name in parsed_action
and command.action.type == "message"):
value_type = type(parsed_action[name])
if value_type is bool:
parsed_value = True if value == "1" else False
elif value_type is int:
try:
parsed_value = int(value)
except ValueError:
continue
else:
parsed_value = value
if name == "type":
parsed_value = (
"privatemessage" if parsed_value
== "Private Message" else "reply")
if name == "functions":
if extra_args["user"].level < 1500:
continue
parsed_action[name] = parsed_value
command.action_json = json.dumps(parsed_action)
else:
if name in valid_names:
value_type = type(getattr(command, name))
if value_type is bool:
parsed_value = True if value == "1" else False
elif value_type is int:
try:
parsed_value = int(value)
except ValueError:
continue
else:
parsed_value = value
options[name] = parsed_value
aj = json.loads(command.action_json)
old_message = ""
new_message = ""
try:
old_message = command.action.response
new_message = aj["message"]
except:
pass
command.set(**options)
command.data.set(**options)
if old_message and len(
old_message) > 0 and old_message != new_message:
log_msg = f'The !{command.aliases[0]} command has been updated from "{old_message}" to "{new_message}"'
else:
log_msg = (
f"The !{command.aliases[0]} command has been updated")
AdminLogManager.add_entry(
"Command edited",
extra_args["user"].discord_id,
log_msg,
data={
"old_message": old_message,
"new_message": new_message
},
)
if (SocketClientManager.send("command.update",
{"command_id": command_id}) is True):
return {"success": "good job"}, 200
else:
return {"error": "could not push update"}, 500
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")
def edit_command(bot, author, channel, message, args):
"""Dispatch method for editing commands.
Usage: !edit command ALIAS [options] RESPONSE
See greenbot/managers/command.py parse_command_arguments for available options
"""
if message:
# Make sure we got both an alias and a response
message_parts = message.split()
if len(message_parts) < 2:
bot.private_message(
author, "Usage: !add command ALIAS [options] RESPONSE")
return False
options, response = bot.commands.parse_command_arguments(
message_parts[1:])
options["edited_by"] = str(author.id)
if "functions" in options:
del options["functions"]
if options is False:
bot.private_message(author, "Invalid command")
return False
alias = message_parts[0].replace("!", "").lower()
type = "reply"
if options["privatemessage"] is True:
type = "privatemessage"
elif options["reply"] is True:
type = "reply"
action = {"type": type, "message": response}
command = bot.commands.get(alias, None)
if command is None:
bot.private_message(
author,
f"No command found with the alias {alias}. Did you mean to create the command? If so, use !add command instead.",
)
return False
old_message = ""
new_message = ""
if len(action["message"]) > 0:
options["action"] = action
old_message = command.action.response
new_message = action["message"]
elif not type == command.action.subtype:
options["action"] = {
"type": type,
"message": command.action.response
}
bot.commands.edit_command(command, **options)
bot.private_message(author,
f"Updated the command (ID: {command.id})")
if len(new_message) > 0:
log_msg = f'The !{command.command.split("|")[0]} command has been updated from "{old_message}" to "{new_message}"'
else:
log_msg = (
f"The !{command.command.split('|')[0]} command has been updated"
)
AdminLogManager.add_entry(
"Command edited",
str(author.id),
log_msg,
data={
"old_message": old_message,
"new_message": new_message
},
)
def commands_create(**options):
session.pop("command_created_id", None)
session.pop("command_edited_id", None)
if request.method != "POST":
return render_template("admin/create_command.html")
if "aliases" not in request.form:
abort(403)
alias_str = request.form.get("aliases", "").replace("!", "").lower()
delay_all = request.form.get("cd", Command.DEFAULT_CD_ALL)
delay_user = request.form.get("usercd", Command.DEFAULT_CD_USER)
level = request.form.get("level", Command.DEFAULT_LEVEL)
cost = request.form.get("cost", 0)
try:
delay_all = int(delay_all)
delay_user = int(delay_user)
level = int(level)
cost = int(cost)
except ValueError:
abort(403)
if not alias_str:
abort(403)
if delay_all < 0 or delay_all > 9999:
abort(403)
if delay_user < 0 or delay_user > 9999:
abort(403)
if level < 0 or level > 2000:
abort(403)
if cost < 0 or cost > 9999999:
abort(403)
user = options.get("user", None)
if user is None:
abort(403)
options = {
"delay_all": delay_all,
"delay_user": delay_user,
"level": level,
"cost": cost,
"added_by": user.discord_id,
}
valid_action_types = ["reply", "privatemessage"]
action_type = request.form.get("type").lower()
if action_type not in valid_action_types:
abort(403)
response = request.form.get("response", "")
log.info(user.level)
functions = (
request.form.get("functions", "").split(" ") if user.level >= 1500 else []
)
log.info(functions)
action = {"type": action_type, "message": response, "functions": functions}
options["action"] = action
command_manager = greenbot.managers.command.CommandManager(
socket_manager=None, module_manager=ModuleManager(None).load(), bot=None
).load(enabled=None)
command_aliases = []
for alias, command in command_manager.items():
command_aliases.append(alias)
if command.command and len(command.command) > 0:
command_aliases.extend(command.command.split("|"))
command_aliases = set(command_aliases)
alias_str = alias_str.replace(" ", "").replace("!", "").lower()
alias_list = alias_str.split("|")
alias_list = [alias for alias in alias_list if len(alias) > 0]
if not alias_list:
return render_template("admin/create_command_fail.html")
for alias in alias_list:
if alias in command_aliases:
return render_template("admin/create_command_fail.html")
alias_str = "|".join(alias_list)
command = Command(command=alias_str, **options)
command.data = CommandData(command.id, **options)
log_msg = f"The !{command.command.split('|')[0]} command has been created"
AdminLogManager.add_entry("Command created", user.discord_id, log_msg)
with DBManager.create_session_scope(expire_on_commit=False) as db_session:
db_session.add(command)
db_session.add(command.data)
db_session.commit()
db_session.expunge(command)
db_session.expunge(command.data)
SocketClientManager.send("command.update", {"command_id": command.id})
session["command_created_id"] = command.id
return redirect("/admin/commands/", 303)
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,
)
