def guild_disable(self, event):
guild_list = PluginConfig.load("guild_list")
# Check if arguments used
if len(event.args) < 1:
return event.msg.reply(GlobalAdmin.nea)
guild_id = convert_guild_self(event.args[0], event.msg)
# Ensure guild not enabled
if guild_id not in guild_list.keys():
return event.msg.reply(
GlobalAdmin.guild_not_enabled.format(
guild_id
)
)
# Add guild to file
try:
guild_list.pop(guild_id)
PluginConfig.write("guild_list", guild_list)
except:
return event.msg.reply(GlobalAdmin.error)
event.msg.reply(
GlobalAdmin.guild_disabled.format(
guild_id
)
)
def plugin_enable(self, event):
# Argument checking
if len(event.args) < 2:
return event.msg.reply(GlobalAdmin.nea)
guild_id = convert_guild_self(event.args[0], event.msg)
plugin = event.args[1]
# Ensure the plugin exists
if plugin not in self.bot.plugins.keys():
return event.msg.reply(
GlobalAdmin.invalid_plugin.format(
plugin
)
)
else:
plugin = self.bot.plugins[plugin]
# Ensure the plugin is allowed to be enabled
if not plugin.can_be_enabled:
return event.msg.reply(
GlobalAdmin.cannot_be_enabled.format(
plugin
)
)
config = PluginConfig.load("guild_list")
# Plugin enabled already?
if plugin.name not in config[guild_id]:
config[guild_id].append(plugin.name)
PluginConfig.write("guild_list", config)
return event.msg.reply(
GlobalAdmin.added_plugin.format(
plugin.name,
guild_id
)
)
else:
return event.msg.reply(
GlobalAdmin.plugin_already_enabled.format(
guild_id,
plugin.name
)
)
def command_list(self, event):
# Ensure guild
if event.guild:
# Load guild_list so we can check enabled guilds
guild_list = PluginConfig.load("guild_list.json")
cmds = []
# Cycle through plugins for command data
for plugin in self.bot.plugins:
plugin = self.bot.plugins[plugin]
print(plugin.name)
# Ensure guild
if event.guild:
# Check if plugin is enabled
if ((plugin.name in guild_list[str(event.guild.id)])
or plugin.bypass_enabled):
# Cycle through commands in the plugin
for cmd in plugin.commands:
print(cmd)
# See if command has group
if cmd.group:
cmds.append("{} {}".format(
cmd.group,
cmd.name
))
else:
cmds.append(cmd.name)
else:
# Cycle through commands in the plugin
for cmd in plugin.commands:
print(cmd)
# See if command has group
if cmd.group:
cmds.append("{} {}".format(
cmd.group,
cmd.name
))
else:
cmds.append(cmd.name)
print("====================")
return event.msg.reply(Util.cmd_list.format(list=", ".join(cmds), pre="~"))
def guild_list(self, event):
# Convert arguments if given
try:
# End only
if len(event.args) == 1:
start = 0
end = int(event.args[0])
# Both
elif len(event.args) == 2:
start = int(event.args[0])
end = int(event.args[1])
# No arguments given
else:
start = 0
end = len(self.state.guilds)
# Invalid integer given
except ValueError:
return event.msg.reply(GlobalAdmin.invalid_int)
# Ensure start is not greater than end
if (start - end) > 0:
return event.msg.reply(GlobalAdmin.error)
# Start == end (meaning no guilds to list)
elif (start - end) == 0:
return event.msg.reply(
GlobalAdmin.no_list_zero.format(
"guilds"
)
)
# Ensure user's "start" is lower than highest index
if start > (len(self.state.guilds) - 1):
return event.msg.reply(
GlobalAdmin.start_too_big.format(
len(self.state.guilds) - 1
)
)
# Loading the guild list
guild_list = PluginConfig.load("guild_list")
guilds = []
# Cycle through all guilds bot has loaded
for guild in self.state.guilds:
guild = self.state.guilds[guild]
if str(guild.id) in guild_list:
enabled = "+"
else:
enabled = "-"
guilds.append(
"{e} {g.name} ({g.id})".format(
e=enabled,
g=guild
)
)
response = GlobalAdmin.guild_list.format(
"\n".join(guilds[start:end])
)
# Ensure message length
if len(response) > 2000:
return event.msg.reply(GlobalAdmin.message_too_long)
# Acknowledge
event.msg.reply(response)
def plugin_list(self, event):
# Ensure the user supplies at least one argument
if len(event.args) < 1:
return event.msg.reply(GlobalAdmin.nea)
guild_id = convert_guild_self(event.args[0], event.msg)
try:
# Loading the guild's plugins
enabled_plugins = PluginConfig.load("guild_list")[guild_id]
except KeyError:
return event.msg.reply(GlobalAdmin.invalid_arg.format(guild_id))
# Convert arguments if given
try:
# End only
if len(event.args) == 2:
start = 0
end = int(event.args[1])
# Both
elif len(event.args) == 3:
start = int(event.args[1])
end = int(event.args[2])
# No arguments given
else:
start = 0
end = len(self.bot.plugins)
# Invalid integer given
except ValueError:
return event.msg.reply(GlobalAdmin.invalid_int)
# Ensure start is not greater than end
if (start - end) > 0:
return event.msg.reply(GlobalAdmin.error)
# Start == end (meaning no plugins to list)
elif (start - end) == 0:
return event.msg.reply(
GlobalAdmin.no_list_zero.format(
"plugins"
)
)
# Ensure user's "start" is lower than highest index
if start > (len(self.bot.plugins) - 1):
return event.msg.reply(
GlobalAdmin.start_too_big.format(
len(self.bot.plugins) - 1
)
)
response = GlobalAdmin.plugin_list.format(
guild_id,
filter_plugins(
self.bot.plugins,
enabled_plugins,
start,
end
)
)
# Ensure message length
if len(response) > 2000:
return event.msg.reply(GlobalAdmin.message_too_long)
# Acknowledge
return event.msg.reply(response)
def plugin_disable(self, event):
# Argument checking
if len(event.args) < 2:
return event.msg.reply(GlobalAdmin.nea)
guild_id = convert_guild_self(guild_id, event.msg)
plugin = event.args[1]
# Ensure the plugin exists
if plugin not in self.bot.plugins:
return event.msg.reply(
GlobalAdmin.invalid_plugin.format(
plugin
)
)
plugin = self.bot.plugins[plugin]
# Ensure the plugin is enabled so we can disable it
if not plugin.can_be_enabled:
return event.msg.reply(
GlobalAdmin.cannot_be_enabled.format(
plugin.name
)
)
config = PluginConfig.load("guild_list")
# Ensure guild is enabled
if guild_id not in config:
return event.msg.reply(
GlobalAdmin.guild_not_enabled.format(guild_id)
)
# Plugin enabled?
if plugin.name in config[guild_id]:
config[guild_id].remove(plugin.name)
event.msg.reply(
GlobalAdmin.removed_plugin.format(
plugin.name,
guild_id
)
)
# Update file
PluginConfig.write("guild_list", config)
else:
# Acknowledge error
event.msg.reply(
GlobalAdmin.plugin_not_enabled.format(
plugin.name,
guild_id
)
)
def command_info(self, event):
if Perms.integer(event.msg.member) <= 4:
return event.msg.reply("This command has been temporarily" +
" disabled due to a bug within Disco. Please refrain from " +
"attempting to use this command while the bug is being fixed.")
# Check if we received multiple arguments
if len(event.args) == 1:
cmd = event.args[0]
elif len(event.args) >= 2:
cmd = event.args[0] + " " + event.args[1]
else:
cmd = "cmd info"
# Ensure that supplied command is valid
if cmd not in cmd_list.keys():
return event.msg.reply(Util.invalid_arg.format(cmd))
cmd = cmd_list[cmd]
me = self.state.me
me_member = event.guild.get_member(me)
# Ensure the plugin is enabled in the guild
if event.guild:
guilds = PluginConfig.load("guild_list")
g_id = str(event.guild.id)
# Ensure guild has been enabled
if g_id in guilds:
# Ensure the plugin doesn't bypass enabled
if not cmd.plugin.bypass_enabled:
# Check if the plugin is not enabled
if cmd.plugin.name not in guilds[g_id]:
return event.msg.reply(
Util.plugin_not_enabled.format(
cmd.plugin.name
)
)
# Get command data
plugin = cmd.plugin
cmd_config = plugin.commands_config[str(cmd.group)][cmd.name]
config = GuildConfig.load(event.guild.id)
try:
cmd_level = config["cmd_lvls"][plugin.name][str(cmd.group)][cmd.name]
except KeyError:
cmd_level = cmd_config["default_level"]
try:
bypass_user_perms = config["permissions"]["bypass_user_perms"]
except KeyError:
bypass_user_perms = cmd_config["bypass_user_perms"]
user_level = Perms.integer(event.msg.member)
user_perms = filter_perms(
event.channel.get_permissions(event.msg.member),
cmd_config["user_perms"]
)
bot_perms = filter_perms(
event.channel.get_permissions(me_member),
cmd_config["bot_perms"]
)
# Cycle through command triggers making the alias list
cmd_aliases = []
for name in cmd.triggers:
cmd_aliases.append(name)
cmd_aliases.remove(cmd.name)
variables = {
# Constants or config values
"pre": Config.load()["bot"]["commands_prefix"],
"max_perm_int": max_permission_int,
"perm_levels": perm_ints,
"emoji": custom_emojis,
# User variables
"user_discrim": event.msg.author.discriminator,
"user_username": event.msg.author.username,
"user_nickname": event.msg.member.name,
"user_id": event.msg.author.id,
# Bot variables
"bot_nickname": me_member.name,
"bot_username": me.username,
"bot_id": me.id,
# Miscellanious information we may want to display
"cmd_total": len(plugin.commands), #TODO: Make this works
"plg_name": plugin.name
}
# Format data nicely in an embed
embed = MessageEmbed()
embed.title = "{bot_nickname} Help:".format(**variables)
embed.color = 0x00aa00
embed.set_footer(
text="Requested by: {user_username}#{user_discrim} ({user_id})".format(
**variables
)
)
# Command description
embed.add_field(
name="Command Description:",
value=" ".join(
cmd_config["info"]
).format(
**variables
).replace(
"& &",
""
),
inline=False
)
# Command syntax
embed.add_field(
name="Command Syntax:",
value="```" + " ".join(
cmd_config["syntax"]
).format(
**variables
).replace(
"& &",
""
) + "```",
inline=False
)
# Check if user permissions are bypassed
if not bypass_user_perms:
# Ensure that the permissions didn't return `None`
if user_perms:
# Permissions that the user needs to have
embed.add_field(
name="Required User Permissions:",
value="Green indicates that the permission requirement is met, red indicates it is not met.\n```diff\n{}\n```".format(user_perms),
inline=False
)
# Check if we are adding bot permissions
if user_level >= 1:
# Ensure that the permissions didn't return `None`
if bot_perms:
embed.add_field(
name="Required Bot Permissions:",
value="Green indicates that the permission requirement is met, red indicates it is not met.\n```diff\n{}\n```".format(bot_perms),
inline=False
)
# Can the command be ran in Direct Messages
embed.add_field(
name="Allowed in DMs:",
value=cmd_config["allow_DMs"],
inline=True
)
# Whether or not the requestee can run the command
embed.add_field(
name="Can Requestee Run It:",
value=(user_level >= cmd_level),
inline=True
)
# Whether or not this command is bypassing user permissions
embed.add_field(
name="Bypasses User Permissions:",
value=bypass_user_perms,
inline=True
)
# The internal permission level that the bot requires for the user
embed.add_field(
name="Permission Level:",
value=cmd_level,
inline=True
)
# Check if there are actully any aliases before adding it
if len(cmd_aliases):
# A list of aliases that the command has
embed.add_field(
name="Aliases:",
value=", ".join(cmd_aliases),
inline=True
)
# Alert user what plugin the command comes from
embed.add_field(
name="Plugin Name:",
value=plugin.name,
inline=True
)
# Respond with the embed
return event.msg.reply(embed=embed)
def tags_parser(self, event):
# Ensure no commands triggered
if triggers_commands(self, event):
return
guild_tags = GuildConfig.load(event.message.guild.id)
global_tags = GuildConfig.load("default")
guild_list = PluginConfig.load("guild_list")
prefix = Config.load()["bot"]["commands_prefix"]
both_have = False
# Ensure message starts with prefix
if not event.message.content.startswith(prefix):
return
command, *args = event.message.content.split()
command = command[len(prefix):]
# Check if both the guild and global have a tag of that name
if command in global_tags["tags"]["list"].keys():
if command in guild_tags["tags"]["list"].keys():
both_have = True
# Ensure guild has global commands allowed
if guild_tags["tags"]["options"]["allow_global"]:
# Retrieve tag data
if command in global_tags["tags"]["list"].keys():
tag_data = global_tags["tags"]["list"][command]
# Check if we are embedding the response
if tag_data["embed"]:
# Ensure we have the proper permissions:
if not event.message.channel.get_permissions(
self.state.me).can(
discord_permission_values["embed_links"]):
return event.message.reply(Tags.embed_error)
# Respond to command
response = respond_to_tag(event, tag_data)
# Ensure command doesn't error
if response.content != Tags.invalid_perms:
# Increment counter
global_tags["tags"]["list"][command]["count"] += 1
GuildConfig.write("default", global_tags)
# Ensure guild has tags enabled
if "CustomCommands" in guild_list[str(event.message.guild.id)]:
# Ensure the tag isn't in both guild/global
if both_have:
return
# Retrieve tag data
if command in guild_tags["tags"]["list"].keys():
tag_data = guild_tags["tags"]["list"][command]
print(event.channel.get_permissions(self.state.me).to_dict())
# Check if we are embedding the response
if tag_data["embed"]:
# Ensure we have the proper permissions:
if not event.message.channel.get_permissions(
self.state.me).can(
discord_permission_values["embed_links"]):
return event.message.reply(Tags.embed_error)
# Respond to command
response = respond_to_tag(event, tag_data)
# Ensure command doesn't error
if response.content != Tags.invalid_perms:
# Increment counter
guild_tags["tags"]["list"][command]["count"] += 1
GuildConfig.write(event.message.guild.id, guild_tags)
else:
return event.message.reply(Tags.tags_not_enabled)
def message_handling(self, event, is_edited=False):
config = Config.load()
#=============================================================================#
# MISC CHECKS
# ensure only the custom parser is enabled
if not config["bot"]["commands_enabled"]:
# Ignore bots
if event.message.author.bot:
return
# blacklist enabled?
if config["parser"]["blacklist_enabled"]:
if is_blacklisted(event):
return
# ensure guild
guild = None
if event.message.guild != None:
guild = event.message.guild
# ensure message object content isn't unset
if not hasattr(event.message.content, "startswith"):
return
#=============================================================================#
# EDITED MESSAGE CHECKS
# Ensure that config allows edited message commands
if config["bot"]["commands_allow_edit"]:
# Ensure that we are checking an edited message
if is_edited:
# Ensure message is the most recent in channel
msg_list = self.client.api.channels_messages_list(
event.message.channel_id, limit=1)
# Ensure message is most recent
if msg_list[0].id != event.message.id:
return
#=============================================================================#
# BASIC COMMAND PARSING
#-----------------------------------------------------------------#
# No command responses
# Get list of commands triggered
commands = triggers_commands(self, event)
# No commands triggered
if commands == None:
prefix = config["bot"]["commands_prefix"]
#-----------------------------------------------------------------#
# Ensure message startswith the prefix
if event.message.content.startswith(prefix):
# See if we're responding to invalid
if config["parser"]["respond_to_invalid"]:
# Ensure we can send messages
if event.channel.get_permissions(
self.state.me).can(2048):
return event.message.reply(Invalid.command)
# if we can't send messages check if we can add reactions
elif event.channel.get_permissions(
self.state.me).can(262208):
return event.message.add_reaction(
custom_emojis["red_tick"])
else:
return
else:
return
else:
return
#-----------------------------------------------------------------#
# Parsing message if it has a command trigger
# commands are indeed triggered:
command = commands[0][0]
plugin = command.plugin
try:
cmd_config = plugin.commands_config[str(
command.group)][command.name]
DM_level = cmd_config["DM_level"]
allow_DMs = cmd_config["allow_DMs"]
bot_perms = cmd_config["bot_perms"]
user_perms = cmd_config["user_perms"]
default_level = cmd_config["guild_level"]
bypass_user_perms = cmd_config["bypass_user_perms"]
except:
return event.message.reply(Parser.generic_error)
#-----------------------------------------------------------------#
# Ensure that we are not attempting to run an indev plugin from a
# production bot.
config = Config.load()
# Ensure environment is production, in dev we want to allow all
env = config["do_not_change"]["env"]
if env in ["prod", "testing"]:
# Ensure plugin is not in dev
if plugin.in_dev:
# Ensure guild is not allowing development plugins
if GuildConfig.load(event.message.guild.id)["allow_dev"]:
return event.message.reply(Parser.plugin_in_dev)
#-----------------------------------------------------------------#
# Ensure that we have a guild to work with for permissions,
# otherwise use defaults for DMs and ensure command is enabled
# in DMs
# message in guild
if guild:
# Ensure we have send message permissions, else, die silently
if not event.channel.get_permissions(self.state.me).can(2048):
return
guild_list = PluginConfig.load("guild_list")
#-------------------------------------------------------------#
# Plugin doesn't need to be enabled then ensure that the guild
# is enabled with the plugin enabled, otherwise error
# accordingly.
# Check if plugin bypasses the enabled checks.
if not plugin.bypass_enabled:
# ensure guild is enabled
if str(guild.id) not in guild_list:
return event.message.reply(Parser.guild_not_enabled)
# ensure guild has the plugin enabled
if plugin.name not in guild_list[str(guild.id)]:
return event.message.reply(
Parser.not_plugin_enabled.format(plugin.name))
#-------------------------------------------------------------#
# Ensure that the plugin isn't restricted and that the guild
# can is also not restricted if the plugin is
# load guild's configuration
config = GuildConfig.load(event.message.guild.id)
# Check if the plugin and guild are restricted then deny if so
if ((config["restricted"] and plugin.restricted)
and (env == "prod")):
return event.message.reply(Parser.restricted)
#-------------------------------------------------------------#
# Ensure that the plugin isn't one where we force the default
# configuration on otherwise try to load the guild config,
# and if something goes wrong with the guild config, resort
# to the default config.
# Check if we're forcing default
if not plugin.force_default:
# get command permission level
try:
plg_data = config["cmd_lvls"][plugin.name]
# command with group
if command.group:
cmd_level = plg_data[command.group][command.name]
# command no group
else:
cmd_level = plg_data[command.name]
bypass_user_perms = config["permissions"][
"bypass_user_perms"]
# something went wrong, resort to default config
except KeyError:
cmd_level = default_level
# Loading the default config file
else:
cmd_level = default_level
#-------------------------------------------------------------#
# Ensure user has the proper permission level to run the
# command and return an invalid permissions response if they
# do not.
user_level = Perms.integer(event.message.member)
if user_level < cmd_level:
return event.message.reply(Invalid.permissions)
#-------------------------------------------------------------#
# Checking to see if the bot/user have all the mandatory
# permissions
# Ensure we aren't ignoring user_perms
if not bypass_user_perms:
# Ensure user has full permissions
if not event.message.channel.get_permissions(
event.message.member).can(user_perms):
# Ensure there is a command group
if command.group:
cmd = command.group + " " + command.name
else:
cmd = command.name
return event.msg.reply(
Parser.bot_perm_missing.format(
Config["bot"]["commands_prefix"], cmd))
# Ensure bot has all permissions needed
if not event.message.channel.get_permissions(
self.state.me).can(bot_perms):
# Ensure there is a command group
if command.group:
cmd = command.group + " " + command.name
else:
cmd = command.name
return event.msg.reply(
Parser.bot_perm_missing.format(
Config["bot"]["commands_prefix"], cmd))
# command ran in DMs
elif allow_DMs:
# Ensure user has proper permission level
if Perms.integer(event.message.author, False) < DM_level:
return event.message.reply(Invalid.permissions)
# not allowing direct message commands
else:
return event.message.reply(Parser.not_DM_enabled)
# handle message
self.bot.handle_message(event.message)