847 lines
29 KiB
Python
847 lines
29 KiB
Python
from discord.ext import commands
|
|
from asyncpg import UniqueViolationError
|
|
|
|
import utils
|
|
|
|
import discord
|
|
|
|
|
|
class ConfigException(Exception):
|
|
pass
|
|
|
|
|
|
class WrongSettingType(ConfigException):
|
|
def __init__(self, message):
|
|
self.message = message
|
|
|
|
|
|
class MessageFormatError(ConfigException):
|
|
def __init__(self, original, keys):
|
|
self.original = original
|
|
self.keys = keys
|
|
|
|
|
|
# noinspection PyMethodMayBeStatic,PyUnusedLocal
|
|
class GuildConfiguration(commands.Cog):
|
|
"""Handles configuring the different settings that can be used on the bot"""
|
|
|
|
keys = {}
|
|
|
|
def _str_to_bool(self, opt, setting):
|
|
setting = setting.title()
|
|
if setting.title() not in ["True", "False"]:
|
|
raise WrongSettingType(
|
|
f"The {opt} setting requires either 'True' or 'False', not {setting}"
|
|
)
|
|
|
|
return setting.title() == "True"
|
|
|
|
async def _get_channel(self, ctx, setting):
|
|
converter = commands.converter.TextChannelConverter()
|
|
return await converter.convert(ctx, setting)
|
|
|
|
async def _set_db_guild_opt(self, opt, setting, ctx):
|
|
if opt == "prefix":
|
|
ctx.bot.cache.update_prefix(ctx.guild, setting)
|
|
try:
|
|
return await ctx.bot.db.execute(
|
|
f'INSERT INTO guilds (id, "{opt}") VALUES ($1, $2)',
|
|
ctx.guild.id,
|
|
setting,
|
|
)
|
|
except UniqueViolationError:
|
|
return await ctx.bot.db.execute(
|
|
f"UPDATE guilds SET {opt} = $1 WHERE id = $2", setting, ctx.guild.id
|
|
)
|
|
|
|
async def _show_bool_options(self, ctx, opt):
|
|
result = await ctx.bot.db.fetchrow(
|
|
"SELECT * FROM guilds WHERE id = $1", ctx.guild.id
|
|
)
|
|
return f"`{opt}` are currently {'enabled' if result is not None and result[opt] else 'disabled'}"
|
|
|
|
async def _show_channel_options(self, ctx, opt):
|
|
"""For showing options that rely on a certain channel"""
|
|
result = await ctx.bot.db.fetchrow(
|
|
"SELECT * FROM guilds WHERE id = $1", ctx.guild.id
|
|
)
|
|
if result is None:
|
|
return f"You do not have a channel set for {opt}"
|
|
channel_id = result[opt]
|
|
if channel_id:
|
|
channel = ctx.guild.get_channel(channel_id)
|
|
if channel:
|
|
return (
|
|
f"Your {opt} alerts channel is currently set to {channel.mention}"
|
|
)
|
|
else:
|
|
return (
|
|
"It looks like you used to have a channel set for this,"
|
|
"however the channel has since been deleted"
|
|
)
|
|
else:
|
|
return f"You do not have a channel set for {opt}"
|
|
|
|
# These are handles for each setting type
|
|
# Just the bool ones, they're all handled the exact same way
|
|
_handle_show_birthday_notifications = _show_bool_options
|
|
_handle_show_welcome_notifications = _show_bool_options
|
|
_handle_show_goodbye_notifications = _show_bool_options
|
|
_handle_show_colour_roles = _show_bool_options
|
|
_handle_show_include_default_battles = _show_bool_options
|
|
_handle_show_include_default_hugs = _show_bool_options
|
|
# The channel ones
|
|
_handle_show_default_alerts = _show_channel_options
|
|
_handle_show_welcome_alerts = _show_channel_options
|
|
_handle_show_goodbye_alerts = _show_channel_options
|
|
_handle_show_picarto_alerts = _show_channel_options
|
|
_handle_show_birthday_alerts = _show_channel_options
|
|
_handle_show_raffle_alerts = _show_channel_options
|
|
|
|
async def _handle_show_welcome_msg(self, ctx, setting):
|
|
result = await ctx.bot.db.fetchrow(
|
|
"SELECT welcome_msg FROM guilds WHERE id = $1", ctx.guild.id
|
|
)
|
|
try:
|
|
msg = result["welcome_msg"].format(
|
|
server=ctx.guild.name, member=ctx.author.mention
|
|
)
|
|
return f"Your current welcome message will appear like this:\n\n{msg}"
|
|
except (AttributeError, TypeError):
|
|
return "You currently have no welcome message setup"
|
|
|
|
async def _handle_show_goodbye_msg(self, ctx, setting):
|
|
result = await ctx.bot.db.fetchrow(
|
|
"SELECT goodbye_msg FROM guilds WHERE id = $1", ctx.guild.id
|
|
)
|
|
try:
|
|
msg = result["goodbye_msg"].format(
|
|
server=ctx.guild.name, member=ctx.author.mention
|
|
)
|
|
return f"Your current goodbye message will appear like this:\n\n{msg}"
|
|
except (AttributeError, TypeError):
|
|
return "You currently have no goodbye message setup"
|
|
|
|
async def _handle_show_prefix(self, ctx, setting):
|
|
result = await ctx.bot.db.fetchrow(
|
|
"SELECT prefix FROM guilds WHERE id = $1", ctx.guild.id
|
|
)
|
|
|
|
if result is not None:
|
|
prefix = result["prefix"]
|
|
if prefix is not None:
|
|
return f"Your current prefix is `{prefix}`"
|
|
|
|
return "You do not have a custom prefix set, you are using the default prefix"
|
|
|
|
async def _handle_show_followed_picarto_channels(self, ctx, opt):
|
|
result = await ctx.bot.db.fetchrow(
|
|
"SELECT followed_picarto_channels FROM guilds WHERE id = $1", ctx.guild.id
|
|
)
|
|
|
|
if result and result["followed_picarto_channels"]:
|
|
try:
|
|
pages = utils.Pages(ctx, entries=result["followed_picarto_channels"])
|
|
await pages.paginate()
|
|
except utils.CannotPaginate as e:
|
|
await ctx.send(str(e))
|
|
else:
|
|
return "This server is not following any picarto channels"
|
|
|
|
async def _handle_show_ignored_channels(self, ctx, opt):
|
|
result = await ctx.bot.db.fetchrow(
|
|
"SELECT ignored_channels FROM guilds WHERE id = $1", ctx.guild.id
|
|
)
|
|
|
|
if result and result["ignored_channels"]:
|
|
try:
|
|
entries = [
|
|
ctx.guild.get_channel(ch).mention
|
|
for ch in result["ignored_members"]
|
|
if ctx.guild.get_channel(ch) is not None
|
|
]
|
|
pages = utils.Pages(ctx, entries=entries)
|
|
await pages.paginate()
|
|
except utils.CannotPaginate as e:
|
|
await ctx.send(str(e))
|
|
else:
|
|
return "This server is not ignoring any channels"
|
|
|
|
async def _handle_show_ignored_members(self, ctx, opt):
|
|
result = await ctx.bot.db.fetchrow(
|
|
"SELECT ignored_members FROM guilds WHERE id = $1", ctx.guild.id
|
|
)
|
|
|
|
if result and result["ignored_members"]:
|
|
try:
|
|
entries = [
|
|
ctx.guild.get_member(m).display_name
|
|
for m in result["ignored_members"]
|
|
if ctx.guild.get_member(m) is not None
|
|
]
|
|
pages = utils.Pages(ctx, entries=entries)
|
|
await pages.paginate()
|
|
except utils.CannotPaginate as e:
|
|
await ctx.send(str(e))
|
|
else:
|
|
return "This server is not ignoring any members"
|
|
|
|
async def _handle_show_rules(self, ctx, opt):
|
|
result = await ctx.bot.db.fetchrow(
|
|
"SELECT rules FROM guilds WHERE id = $1", ctx.guild.id
|
|
)
|
|
|
|
if result and result["rules"]:
|
|
try:
|
|
pages = utils.Pages(ctx, entries=result["rules"])
|
|
await pages.paginate()
|
|
except utils.CannotPaginate as e:
|
|
await ctx.send(str(e))
|
|
else:
|
|
return "This server has no rules"
|
|
|
|
async def _handle_show_assignable_roles(self, ctx, opt):
|
|
result = await ctx.bot.db.fetchrow(
|
|
"SELECT assignable_roles FROM guilds WHERE id = $1", ctx.guild.id
|
|
)
|
|
|
|
if result and result["assignable_roles"]:
|
|
try:
|
|
entries = [
|
|
ctx.guild.get_role(r).name
|
|
for r in result["assignable_roles"]
|
|
if ctx.guild.get_role(r) is not None
|
|
]
|
|
pages = utils.Pages(ctx, entries=entries)
|
|
await pages.paginate()
|
|
except utils.CannotPaginate as e:
|
|
await ctx.send(str(e))
|
|
else:
|
|
return "This server has no assignable roles"
|
|
|
|
async def _handle_show_custom_battles(self, ctx, opt):
|
|
result = await ctx.bot.db.fetchrow(
|
|
"SELECT custom_battles FROM guilds WHERE id = $1", ctx.guild.id
|
|
)
|
|
|
|
if result and result["custom_battles"]:
|
|
try:
|
|
pages = utils.Pages(ctx, entries=result["custom_battles"])
|
|
await pages.paginate()
|
|
except utils.CannotPaginate as e:
|
|
await ctx.send(str(e))
|
|
else:
|
|
return "This server has no custom battles"
|
|
|
|
async def _handle_show_custom_hugs(self, ctx, opt):
|
|
result = await ctx.bot.db.fetchrow(
|
|
"SELECT custom_hugs FROM guilds WHERE id = $1", ctx.guild.id
|
|
)
|
|
|
|
if result and result["custom_hugs"]:
|
|
try:
|
|
pages = utils.Pages(ctx, entries=result["custom_hugs"])
|
|
await pages.paginate()
|
|
except utils.CannotPaginate as e:
|
|
await ctx.send(str(e))
|
|
else:
|
|
return "This server has no custom hugs"
|
|
|
|
async def _handle_show_join_role(self, ctx, opt):
|
|
result = await ctx.bot.db.fetchrow(
|
|
"SELECT join_role FROM guilds WHERE id = $1", ctx.guild.id
|
|
)
|
|
|
|
if result and result["join_role"]:
|
|
role = ctx.guild.get_role(result["join_role"])
|
|
if role is None:
|
|
return "You had a role set, but I can't find it...it's most likely been deleted afterwords!"
|
|
else:
|
|
return f"When people join I will give them the role {role.name}"
|
|
else:
|
|
return "You have no join_role setting for when people join this server"
|
|
|
|
async def _handle_set_birthday_notifications(self, ctx, setting):
|
|
opt = "birthday_notifications"
|
|
setting = self._str_to_bool(opt, setting)
|
|
return await self._set_db_guild_opt(opt, setting, ctx)
|
|
|
|
async def _handle_set_welcome_notifications(self, ctx, setting):
|
|
opt = "welcome_notifications"
|
|
setting = self._str_to_bool(opt, setting)
|
|
return await self._set_db_guild_opt(opt, setting, ctx)
|
|
|
|
async def _handle_set_goodbye_notifications(self, ctx, setting):
|
|
opt = "goodbye_notifications"
|
|
setting = self._str_to_bool(opt, setting)
|
|
return await self._set_db_guild_opt(opt, setting, ctx)
|
|
|
|
async def _handle_set_colour_roles(self, ctx, setting):
|
|
opt = "colour_roles"
|
|
setting = self._str_to_bool(opt, setting)
|
|
return await self._set_db_guild_opt(opt, setting, ctx)
|
|
|
|
async def _handle_set_include_default_battles(self, ctx, setting):
|
|
opt = "include_default_battles"
|
|
setting = self._str_to_bool(opt, setting)
|
|
return await self._set_db_guild_opt(opt, setting, ctx)
|
|
|
|
async def _handle_set_include_default_hugs(self, ctx, setting):
|
|
opt = "include_default_hugs"
|
|
setting = self._str_to_bool(opt, setting)
|
|
return await self._set_db_guild_opt(opt, setting, ctx)
|
|
|
|
async def _handle_set_welcome_msg(self, ctx, setting):
|
|
try:
|
|
setting.format(member="test", server="test")
|
|
except KeyError as e:
|
|
raise MessageFormatError(e, ["member", "server"])
|
|
else:
|
|
return await self._set_db_guild_opt("welcome_msg", setting, ctx)
|
|
|
|
async def _handle_set_goodbye_msg(self, ctx, setting):
|
|
try:
|
|
setting.format(member="test", server="test")
|
|
except KeyError as e:
|
|
raise MessageFormatError(e, ["member", "server"])
|
|
else:
|
|
return await self._set_db_guild_opt("goodbye_msg", setting, ctx)
|
|
|
|
async def _handle_set_prefix(self, ctx, setting):
|
|
if len(setting) > 20:
|
|
raise WrongSettingType("Please keep the prefix under 20 characters")
|
|
if setting.lower().strip() == "none":
|
|
setting = None
|
|
|
|
return await self._set_db_guild_opt("prefix", setting, ctx)
|
|
|
|
async def _handle_set_default_alerts(self, ctx, setting):
|
|
channel = await self._get_channel(ctx, setting)
|
|
return await self._set_db_guild_opt("default_alerts", channel.id, ctx)
|
|
|
|
async def _handle_set_welcome_alerts(self, ctx, setting):
|
|
channel = await self._get_channel(ctx, setting)
|
|
return await self._set_db_guild_opt("welcome_alerts", channel.id, ctx)
|
|
|
|
async def _handle_set_goodbye_alerts(self, ctx, setting):
|
|
channel = await self._get_channel(ctx, setting)
|
|
return await self._set_db_guild_opt("goodbye_alerts", channel.id, ctx)
|
|
|
|
async def _handle_set_picarto_alerts(self, ctx, setting):
|
|
channel = await self._get_channel(ctx, setting)
|
|
return await self._set_db_guild_opt("picarto_alerts", channel.id, ctx)
|
|
|
|
async def _handle_set_birthday_alerts(self, ctx, setting):
|
|
channel = await self._get_channel(ctx, setting)
|
|
return await self._set_db_guild_opt("birthday_alerts", channel.id, ctx)
|
|
|
|
async def _handle_set_raffle_alerts(self, ctx, setting):
|
|
channel = await self._get_channel(ctx, setting)
|
|
return await self._set_db_guild_opt("raffle_alerts", channel.id, ctx)
|
|
|
|
async def _handle_set_followed_picarto_channels(self, ctx, setting):
|
|
user = await utils.request(f"http://api.picarto.tv/v1/channel/name/{setting}")
|
|
if user is None:
|
|
raise WrongSettingType(
|
|
f"Could not find a picarto user with the username {setting}"
|
|
)
|
|
|
|
query = """
|
|
UPDATE
|
|
guilds
|
|
SET
|
|
followed_picarto_channels = array_append(followed_picarto_channels, $1)
|
|
WHERE
|
|
id=$2 AND
|
|
NOT $1 = ANY(followed_picarto_channels);
|
|
"""
|
|
return await ctx.bot.db.execute(query, setting, ctx.guild.id)
|
|
|
|
async def _handle_set_ignored_channels(self, ctx, setting):
|
|
channel = await self._get_channel(ctx, setting)
|
|
|
|
query = """
|
|
UPDATE
|
|
guilds
|
|
SET
|
|
ignored_channels = array_append(ignored_channels, $1)
|
|
WHERE
|
|
id=$2 AND
|
|
NOT $1 = ANY(ignored_channels);
|
|
"""
|
|
ctx.bot.loop.create_task(ctx.bot.cache.load_ignored())
|
|
return await ctx.bot.db.execute(query, channel.id, ctx.guild.id)
|
|
|
|
async def _handle_set_ignored_members(self, ctx, setting):
|
|
# We want to make it possible to have members that aren't in the server ignored
|
|
# So first check if it's a digit (the id)
|
|
if not setting.isdigit():
|
|
converter = commands.converter.MemberConverter()
|
|
member = await converter.convert(ctx, setting)
|
|
setting = member.id
|
|
|
|
query = """
|
|
UPDATE
|
|
guilds
|
|
SET
|
|
ignored_members = array_append(ignored_members, $1)
|
|
WHERE
|
|
id=$2 AND
|
|
NOT $1 = ANY(ignored_members);
|
|
"""
|
|
ctx.bot.loop.create_task(ctx.bot.cache.load_ignored())
|
|
return await ctx.bot.db.execute(query, setting, ctx.guild.id)
|
|
|
|
async def _handle_set_rules(self, ctx, setting):
|
|
query = """
|
|
UPDATE
|
|
guilds
|
|
SET
|
|
rules = array_append(rules, $1)
|
|
WHERE
|
|
id=$2 AND
|
|
NOT $1 = ANY(rules);
|
|
"""
|
|
return await ctx.bot.db.execute(query, setting, ctx.guild.id)
|
|
|
|
async def _handle_set_assignable_roles(self, ctx, setting):
|
|
converter = commands.converter.RoleConverter()
|
|
role = await converter.convert(ctx, setting)
|
|
|
|
query = """
|
|
UPDATE
|
|
guilds
|
|
SET
|
|
assignable_roles = array_append(assignable_roles, $1)
|
|
WHERE
|
|
id=$2 AND
|
|
NOT $1 = ANY(assignable_roles);
|
|
"""
|
|
return await ctx.bot.db.execute(query, role.id, ctx.guild.id)
|
|
|
|
async def _handle_set_custom_battles(self, ctx, setting):
|
|
try:
|
|
setting.format(loser="player1", winner="player2")
|
|
except (KeyError, ValueError) as e:
|
|
raise MessageFormatError(e, ["loser", "winner"])
|
|
else:
|
|
query = """
|
|
UPDATE
|
|
guilds
|
|
SET
|
|
custom_battles = array_append(custom_battles, $1)
|
|
WHERE
|
|
id=$2 AND
|
|
NOT $1 = ANY(custom_battles);
|
|
"""
|
|
return await ctx.bot.db.execute(query, setting, ctx.guild.id)
|
|
|
|
async def _handle_set_custom_hugs(self, ctx, setting):
|
|
try:
|
|
setting.format(user="user")
|
|
except (KeyError, ValueError) as e:
|
|
raise MessageFormatError(e, ["user"])
|
|
else:
|
|
query = """
|
|
UPDATE
|
|
guilds
|
|
SET
|
|
custom_hugs = array_append(custom_hugs, $1)
|
|
WHERE
|
|
id=$2 AND
|
|
NOT $1 = ANY(custom_hugs);
|
|
"""
|
|
return await ctx.bot.db.execute(query, setting, ctx.guild.id)
|
|
|
|
async def _handle_set_join_role(self, ctx, setting):
|
|
converter = commands.converter.RoleConverter()
|
|
role = await converter.convert(ctx, setting)
|
|
|
|
query = """
|
|
UPDATE
|
|
guilds
|
|
SET
|
|
join_role = $1
|
|
where
|
|
ID=$2
|
|
"""
|
|
|
|
return await ctx.bot.db.execute(query, role.id, ctx.guild.id)
|
|
|
|
async def _handle_remove_birthday_notifications(self, ctx, setting=None):
|
|
return await self._set_db_guild_opt("birthday_notifications", False, ctx)
|
|
|
|
async def _handle_remove_welcome_notifications(self, ctx, setting=None):
|
|
return await self._set_db_guild_opt("welcome_notifications", False, ctx)
|
|
|
|
async def _handle_remove_goodbye_notifications(self, ctx, setting=None):
|
|
return await self._set_db_guild_opt("goodbye_notifications", False, ctx)
|
|
|
|
async def _handle_remove_colour_roles(self, ctx, setting=None):
|
|
return await self._set_db_guild_opt("colour_roles", False, ctx)
|
|
|
|
async def _handle_remove_include_default_battles(self, ctx, setting=None):
|
|
return await self._set_db_guild_opt("include_default_battles", False, ctx)
|
|
|
|
async def _handle_remove_include_default_hugs(self, ctx, setting=None):
|
|
return await self._set_db_guild_opt("include_default_hugs", False, ctx)
|
|
|
|
async def _handle_remove_welcome_msg(self, ctx, setting=None):
|
|
return await self._set_db_guild_opt("welcome_msg", None, ctx)
|
|
|
|
async def _handle_remove_goodbye_msg(self, ctx, setting=None):
|
|
return await self._set_db_guild_opt("goodbye_msg", None, ctx)
|
|
|
|
async def _handle_remove_prefix(self, ctx, setting=None):
|
|
return await self._set_db_guild_opt("prefix", None, ctx)
|
|
|
|
async def _handle_remove_default_alerts(self, ctx, setting=None):
|
|
return await self._set_db_guild_opt("default_alerts", None, ctx)
|
|
|
|
async def _handle_remove_welcome_alerts(self, ctx, setting=None):
|
|
return await self._set_db_guild_opt("welcome_alerts", None, ctx)
|
|
|
|
async def _handle_remove_goodbye_alerts(self, ctx, setting=None):
|
|
return await self._set_db_guild_opt("goodbye_alerts", None, ctx)
|
|
|
|
async def _handle_remove_picarto_alerts(self, ctx, setting=None):
|
|
return await self._set_db_guild_opt("picarto_alerts", None, ctx)
|
|
|
|
async def _handle_remove_birthday_alerts(self, ctx, setting=None):
|
|
return await self._set_db_guild_opt("birthday_alerts", None, ctx)
|
|
|
|
async def _handle_remove_raffle_alerts(self, ctx, setting=None):
|
|
return await self._set_db_guild_opt("raffle_alerts", None, ctx)
|
|
|
|
async def _handle_remove_join_role(self, ctx, setting=None):
|
|
return await self._set_db_guild_opt("join_role", None, ctx)
|
|
|
|
async def _handle_remove_followed_picarto_channels(self, ctx, setting=None):
|
|
if setting is None:
|
|
raise WrongSettingType(
|
|
"Specifying which channel you want to remove is required"
|
|
)
|
|
|
|
query = """
|
|
UPDATE
|
|
guilds
|
|
SET
|
|
followed_picarto_channels = array_remove(followed_picarto_channels, $1)
|
|
WHERE
|
|
id=$2
|
|
"""
|
|
return await ctx.bot.db.execute(query, setting, ctx.guild.id)
|
|
|
|
async def _handle_remove_ignored_channels(self, ctx, setting=None):
|
|
if setting is None:
|
|
raise WrongSettingType(
|
|
"Specifying which channel you want to remove is required"
|
|
)
|
|
|
|
channel = await self._get_channel(ctx, setting)
|
|
|
|
query = """
|
|
UPDATE
|
|
guilds
|
|
SET
|
|
ignored_channels = array_remove(ignored_channels, $1)
|
|
WHERE
|
|
id=$2
|
|
"""
|
|
return await ctx.bot.db.execute(query, channel.id, ctx.guild.id)
|
|
|
|
async def _handle_remove_ignored_members(self, ctx, setting=None):
|
|
if setting is None:
|
|
raise WrongSettingType(
|
|
"Specifying which channel you want to remove is required"
|
|
)
|
|
# We want to make it possible to have members that aren't in the server ignored
|
|
# So first check if it's a digit (the id)
|
|
if not setting.isdigit():
|
|
converter = commands.converter.MemberConverter()
|
|
member = await converter.convert(ctx, setting)
|
|
setting = member.id
|
|
else:
|
|
setting = int(setting)
|
|
|
|
query = """
|
|
UPDATE
|
|
guilds
|
|
SET
|
|
ignored_members = array_remove(ignored_members, $1)
|
|
WHERE
|
|
id=$2
|
|
"""
|
|
return await ctx.bot.db.execute(query, setting, ctx.guild.id)
|
|
|
|
async def _handle_remove_rules(self, ctx, setting=None):
|
|
if setting is None or not setting.isdigit():
|
|
raise WrongSettingType(
|
|
"Please provide the number of the rule you want to remove"
|
|
)
|
|
|
|
query = """
|
|
UPDATE
|
|
guilds
|
|
SET
|
|
rules = array_remove(rules, rules[$1])
|
|
WHERE
|
|
id=$2
|
|
"""
|
|
return await ctx.bot.db.execute(query, int(setting), ctx.guild.id)
|
|
|
|
async def _handle_remove_assignable_roles(self, ctx, setting=None):
|
|
if setting is None:
|
|
raise WrongSettingType(
|
|
"Specifying which channel you want to remove is required"
|
|
)
|
|
if not setting.isdigit():
|
|
converter = commands.converter.RoleConverter()
|
|
role = await converter.convert(ctx, setting)
|
|
setting = role.id
|
|
else:
|
|
setting = int(setting)
|
|
|
|
query = """
|
|
UPDATE
|
|
guilds
|
|
SET
|
|
assignable_roles = array_remove(assignable_roles, $1)
|
|
WHERE
|
|
id=$2
|
|
"""
|
|
return await ctx.bot.db.execute(query, setting, ctx.guild.id)
|
|
|
|
async def _handle_remove_custom_battles(self, ctx, setting=None):
|
|
if setting is None or not setting.isdigit():
|
|
raise WrongSettingType(
|
|
"Please provide the number of the custom battle you want to remove"
|
|
)
|
|
else:
|
|
setting = int(setting)
|
|
|
|
query = """
|
|
UPDATE
|
|
guilds
|
|
SET
|
|
custom_battles = array_remove(custom_battles, custom_battles[$1])
|
|
WHERE
|
|
id=$2
|
|
"""
|
|
return await ctx.bot.db.execute(query, int(setting), ctx.guild.id)
|
|
|
|
async def _handle_remove_custom_hugs(self, ctx, setting=None):
|
|
if setting is None or not setting.isdigit():
|
|
raise WrongSettingType(
|
|
"Please provide the number of the custom hug you want to remove"
|
|
)
|
|
else:
|
|
setting = int(setting)
|
|
|
|
query = """
|
|
UPDATE
|
|
guilds
|
|
SET
|
|
custom_hugs = array_remove(custom_hugs, custom_hugs[$1])
|
|
WHERE
|
|
id=$2
|
|
"""
|
|
return await ctx.bot.db.execute(query, int(setting), ctx.guild.id)
|
|
|
|
async def cog_after_invoke(self, ctx):
|
|
"""Here we will facilitate cleaning up settings, will remove channels/roles that no longer exist, etc."""
|
|
pass
|
|
|
|
@commands.group(invoke_without_command=True)
|
|
@commands.guild_only()
|
|
@utils.can_run(manage_guild=True)
|
|
async def config(self, ctx, *, opt=None):
|
|
"""Handles the configuration of the bot for this server"""
|
|
if opt:
|
|
try:
|
|
coro = getattr(self, f"_handle_show_{opt}")
|
|
except AttributeError:
|
|
await ctx.send(
|
|
f"{opt} is not a valid config option. Use {ctx.prefix}config to list all config options"
|
|
)
|
|
else:
|
|
try:
|
|
msg = await coro(ctx, opt)
|
|
except WrongSettingType as exc:
|
|
await ctx.send(exc.message)
|
|
except commands.BadArgument:
|
|
pass
|
|
else:
|
|
return await ctx.send(msg)
|
|
|
|
settings = await ctx.bot.db.fetchrow(
|
|
"SELECT * FROM guilds WHERE id=$1", ctx.guild.id
|
|
)
|
|
|
|
# For convenience, if it's None, just create it and return the default values
|
|
if settings is None:
|
|
await ctx.bot.db.execute(
|
|
"INSERT INTO guilds (id) VALUES ($1)", ctx.guild.id
|
|
)
|
|
settings = await ctx.bot.db.fetchrow(
|
|
"SELECT * FROM guilds WHERE id=$1", ctx.guild.id
|
|
)
|
|
|
|
alerts = {}
|
|
# This is dirty I know, but oh well...
|
|
for alert_type in [
|
|
"default",
|
|
"welcome",
|
|
"goodbye",
|
|
"picarto",
|
|
"birthday",
|
|
"raffle",
|
|
]:
|
|
channel = ctx.guild.get_channel(settings.get(f"{alert_type}_alerts"))
|
|
name = channel.name if channel else None
|
|
alerts[alert_type] = name
|
|
|
|
fmt = f"""
|
|
**Notification Settings**
|
|
birthday_notifications
|
|
*Notify on the birthday that users in this guild have saved*
|
|
**{settings.get("birthday_notifications")}**
|
|
|
|
welcome_notifications
|
|
*Notify when someone has joined this guild*
|
|
**{settings.get("welcome_notifications")}**
|
|
|
|
goodbye_notifications
|
|
*Notify when someone has left this guild
|
|
**{settings.get("goodbye_notifications")}**
|
|
|
|
welcome_msg
|
|
*A message that can be customized and used when someone joins the server*
|
|
**{"Set" if settings.get("welcome_msg") is not None else "Not set"}**
|
|
|
|
goodbye_msg
|
|
*A message that can be customized and used when someone leaves the server*
|
|
**{"Set" if settings.get("goodbye_msg") is not None else "Not set"}**
|
|
|
|
**Alert Channels**
|
|
default_alerts
|
|
*The channel to default alert messages to*
|
|
**{alerts.get("default_alerts")}**
|
|
|
|
welcome_alerts
|
|
*The channel to send welcome alerts to (when someone joins the server)*
|
|
**{alerts.get("welcome_alerts")}**
|
|
|
|
goodbye_alerts
|
|
*The channel to send goodbye alerts to (when someone leaves the server)*
|
|
**{alerts.get("goodbye_alerts")}**
|
|
|
|
picarto_alerts
|
|
*The channel to send Picarto alerts to (when a channel the server follows goes on/offline)*
|
|
**{alerts.get("picarto_alerts")}**
|
|
|
|
birthday_alerts
|
|
*The channel to send birthday alerts to (on the day of someone's birthday)*
|
|
**{alerts.get("birthday_alerts")}**
|
|
|
|
raffle_alerts
|
|
*The channel to send alerts for server raffles to*
|
|
**{alerts.get("raffle_alerts")}**
|
|
|
|
|
|
**Misc Settings**
|
|
followed_picarto_channels
|
|
*Channels for the bot to "follow" and notify this server when they go live*
|
|
**{len(settings.get("followed_picarto_channels"))}**
|
|
|
|
ignored_channels
|
|
*Channels that the bot ignores*
|
|
**{len(settings.get("ignored_channels"))}**
|
|
|
|
ignored_members
|
|
*Members that the bot ignores*
|
|
**{len(settings.get("ignored_members"))}**
|
|
|
|
rules
|
|
*Rules for this server*
|
|
**{len(settings.get("rules"))}**
|
|
|
|
assignable_roles
|
|
*Roles that can be self-assigned by users*
|
|
**{len(settings.get("assignable_roles"))}**
|
|
|
|
custom_battles
|
|
*Possible outcomes to battles that can be received on this server*
|
|
**{len(settings.get("custom_battles"))}**
|
|
|
|
custom_hugs
|
|
*Possible outcomes to hugs that can be received on this server*
|
|
**{len(settings.get("custom_hugs"))}**
|
|
""".strip()
|
|
|
|
embed = discord.Embed(
|
|
title=f"Configuration for {ctx.guild.name}", description=fmt
|
|
)
|
|
embed.set_image(url=ctx.guild.icon_url)
|
|
await ctx.send(embed=embed)
|
|
|
|
@config.command(name="set", aliases=["add"])
|
|
@commands.guild_only()
|
|
@utils.can_run(manage_guild=True)
|
|
async def _set_setting(self, ctx, option, *, setting):
|
|
"""Sets one of the configuration settings for this server"""
|
|
try:
|
|
coro = getattr(self, f"_handle_set_{option}")
|
|
except AttributeError:
|
|
await ctx.send(
|
|
f"{option} is not a valid config option. Use {ctx.prefix}config to list all config options"
|
|
)
|
|
else:
|
|
# First make sure there's an entry for this guild before doing anything
|
|
try:
|
|
await ctx.bot.db.execute(
|
|
"INSERT INTO guilds(id) VALUES ($1)", ctx.guild.id
|
|
)
|
|
except UniqueViolationError:
|
|
pass
|
|
|
|
try:
|
|
await coro(ctx, setting=setting)
|
|
except WrongSettingType as exc:
|
|
await ctx.send(exc.message)
|
|
except MessageFormatError as exc:
|
|
fmt = f"""
|
|
Failed to parse the format string provided, possible keys are: {', '.join(k for k in exc.keys)}
|
|
Extraneous args provided: {', '.join(k for k in exc.original.args)}
|
|
"""
|
|
await ctx.send(fmt)
|
|
except commands.BadArgument as exc:
|
|
await ctx.send(exc)
|
|
else:
|
|
await ctx.invoke(ctx.bot.get_command("config"), opt=option)
|
|
|
|
@config.command(name="unset", aliases=["remove"])
|
|
@commands.guild_only()
|
|
@utils.can_run(manage_guild=True)
|
|
async def _remove_setting(self, ctx, option, *, setting=None):
|
|
"""Unsets/removes an option from one of the settings."""
|
|
try:
|
|
coro = getattr(self, f"_handle_remove_{option}")
|
|
except AttributeError:
|
|
await ctx.send(
|
|
f"{option} is not a valid config option. Use {ctx.prefix}config to list all config options"
|
|
)
|
|
else:
|
|
try:
|
|
await coro(ctx, setting=setting)
|
|
except WrongSettingType as exc:
|
|
await ctx.send(exc.message)
|
|
except commands.BadArgument:
|
|
pass
|
|
else:
|
|
await ctx.invoke(ctx.bot.get_command("config"), opt=option)
|
|
|
|
|
|
def setup(bot):
|
|
bot.add_cog(GuildConfiguration())
|