async def on_channel_create(self, channel):
guild_data = get_servers_data()[str(channel.guild.id)]
jail_role = discord.utils.get(channel.guild.roles,
id=guild_data["jail_role"])
channel.set_permissions(jail_role,
read_messages=True,
send_messages=True)
async def jail(self, ctx, *members: discord.Member):
self.update_response()
responses = self.responses['jail']['jail']
if not members:
raise commands.BadArgument("invalid_users")
await ctx.send(responses['starting'])
guild_id = str(ctx.guild.id)
guild_data = get_servers_data()[guild_id]
jail_role = discord.utils.get(ctx.guild.roles,
id=guild_data["jail_role"])
# add channel overwrites if it doesnt have them
for channel in ctx.guild.text_channels:
if channel.id == guild_data["jail_channel"]:
continue
overwrites = channel.overwrites_for(jail_role)
if overwrites.is_empty():
overwrites.update(read_messages=False)
await channel.set_permissions(jail_role, overwrite=overwrites)
for member in members:
member_roles = [
role for role in member.roles if role.name != '@everyone'
]
if jail_role not in member_roles:
await member.add_roles(jail_role)
await member.remove_roles(*member_roles)
names = [f"{member.mention}" for member in members]
await ctx.send(responses["success"].format(names=', '.join(names)))
def get_profile(self, guild_id: str, profile: str):
data = get_servers_data()
profiles = data[guild_id]['profiles']
if profile in profiles:
return profiles[profile]
else:
return None
async def permission_type(self, ctx):
self.update_response()
responses = self.responses['permissions']['permission_type']
data = get_servers_data()
guild_id = str(ctx.guild.id)
guild_exists(guild_id)
permission_type = data[guild_id]["permission_type"]
embed = embed_template(
title=responses["embed_data"]["title"].format(
server=ctx.guild.name),
description=responses["embed_data"]["description"])
embed.add_field(name=f"Permission type:", value=permission_type)
if permission_type == "custom":
user_ids = data[guild_id]['custom_has_permission']
users = []
for user_id in user_ids:
user_obj = discord.utils.get(ctx.guild.members, id=user_id)
users.append(f"{user_obj.name}#{user_obj.discriminator}")
users.append(
f"{ctx.guild.owner.name}#{ctx.guild.owner.discriminator} (server owner)"
)
embed.add_field(name="Custom permission access",
value=', '.join(users))
await ctx.send(content=None, embed=embed)
async def predicate(ctx):
guild_id = str(ctx.guild.id)
guild_data = get_servers_data()[guild_id]
permission_type = guild_data["permission_type"]
author_perms = ctx.message.author.guild_permissions
if ctx.message.author.id == ctx.guild.owner_id or ctx.message.author.id in get_config(
)['has_access'] or permission_type == "everyone":
return True
elif permission_type == "administrator" or permission_type == "manage_server":
if getattr(author_perms, permission_type, False):
return True
elif permission_type == "custom" and guild_data[
"custom_has_permission"]:
if ctx.message.author.id in guild_data[
"custom_has_permission"]:
return True
# if the check has gone this far and returned nothing, then the check has failed and permission is denied
with open("info/responses.json", "r") as f:
responses = json.load(f)['fail_check']['perms']
embed = embed_template(
title=responses['embed_data']['title'].format(
command=ctx.invoked_with),
description=responses['embed_data']['description'].format(
permission_type=permission_type))
embed.color = 15138816
await ctx.send(content=responses['content'], embed=embed)
async def profile_info(self, ctx, profile: str):
# self.update_responses()
responses = self.responses['profile']['profile_info']
guild_id = str(ctx.guild.id)
profiles = get_servers_data()[guild_id]['profiles']
if profile in profiles:
profile_roles = profiles[profile]
embed = embed_template(
title=responses['embed_data']['title'].format(profile=profile),
description=responses['embed_data']['description'].format(
number=format(len(profile_roles), "bold")))
content = responses['content']
field = ""
for role_id in profile_roles:
role = discord.utils.get(ctx.guild.roles, id=role_id)
if role is None:
self.remove_profile_role(guild_id, role_id, profile)
else:
field += f"{role.mention}, "
field = field.rstrip(', ')
embed.add_field(name="Roles:", value=field)
await ctx.send(content=content, embed=embed)
else:
raise commands.BadArgument(profile, "invalid_profile")
async def create_jail(self, ctx, jail_role: discord.Role,
jail_channel: discord.TextChannel):
self.update_response()
responses = self.responses['jail']['create_jail']
await ctx.send(responses['starting'])
guild_id = str(ctx.guild.id)
data = get_servers_data()
# FIXME: if new channels are created after a jail role has been created, the role will have permissions to access it (assuming channel @everyone is open to everyone)
channels = ctx.guild.channels
for channel in channels:
if channel.id == jail_channel.id:
await channel.set_permissions(jail_role,
read_messages=True,
send_messages=True)
else:
await channel.set_permissions(jail_role, read_messages=False)
guild_id = str(ctx.guild.id)
data = get_servers_data()
data[guild_id]['jail_role'] = jail_role.id
data[guild_id]['jail_channel'] = jail_channel.id
set_servers_data(data)
await ctx.send(responses['success'].format(
jail_role=jail_role.mention, jail_channel=jail_channel.mention))
async def server_config(self, ctx):
self.update_response()
responses = self.responses['settings']['server_config']
guild_exists(str(ctx.guild.id))
guild_id = str(ctx.guild.id)
guild_data = get_servers_data()[guild_id]
prefix = ctx.prefix
number_of_profiles = len(guild_data["profiles"])
permission_type = guild_data["permission_type"]
jail_role = discord.utils.get(ctx.guild.roles,
id=guild_data["jail_role"])
jail_role = jail_role.mention if jail_role is not None else jail_role
jail_channel = discord.utils.get(ctx.guild.text_channels,
id=guild_data["jail_channel"])
jail_channel = jail_channel.mention if jail_channel is not None else jail_channel
embed = embed_template(
title=responses["embed_data"]["title"].format(
server=ctx.guild.name),
description=responses["embed_data"]["description"])
embed.add_field(name="Bot prefix", value=f'`{prefix}`', inline=True)
embed.add_field(name="Number of profiles",
value=number_of_profiles,
inline=True)
embed.add_field(name="Permission type",
value=permission_type,
inline=True)
if permission_type == "custom":
user_ids = guild_data['custom_has_permission']
users = []
for user_id in user_ids:
user_obj = discord.utils.get(ctx.guild.members, id=user_id)
if user_obj is not None:
users.append(f"{user_obj.name}#{user_obj.discriminator}")
else:
users.append(str(user_id))
users.append(
f"{ctx.guild.owner.name}#{ctx.guild.owner.discriminator} (server owner)"
)
embed.add_field(name="Custom permission access",
value=', '.join(users))
embed.add_field(name="Jail role", value=jail_role)
embed.add_field(name="Jail channel", value=jail_channel)
await ctx.send(content=None, embed=embed)
async def list_profiles(self, ctx):
# self.update_responses()
responses = self.responses['profile']['list_profiles']
guild_id = str(ctx.guild.id)
profiles = get_servers_data()[guild_id]['profiles']
fields = []
for profile_name, profile_roles in profiles.items():
fields.append({'name': profile_name, 'value': len(profile_roles)})
fields.sort(key=lambda f: f['name'])
num_profiles = len(fields)
num_embeds = num_profiles // 25 # 25 is the max num fields per embed
slices = []
if num_embeds != 0:
leftover = len(fields) - (num_embeds * 25)
for i in range(num_embeds):
start = i * 25
stop = (i + 1) * 25
slices.append(slice(start, stop))
if leftover:
slices.append(slice(stop, stop + leftover))
else:
slices.append(slice(0, len(fields)))
for slice_ in slices:
embed = embed_template(
title=responses['embed_data']['title'].format(
name=ctx.guild.name),
description=responses['embed_data']['description'].format(
name=ctx.guild.name,
number=format(num_profiles, "bold"),
prefix=ctx.prefix))
embed_fields = fields[slice_]
if embed_fields:
for field in embed_fields:
embed.add_field(
name=field['name'],
value=f"{format(field['value'], 'bold')} total roles.",
inline=True)
else:
embed.add_field(name="\a", value='There are no responders')
await ctx.send(embed=embed)
# BUG: if there's more than 25, than it isn't shown, loop through yk the drill plsz
'''
async def delete_profile(self, ctx, profile: str):
# self.update_responses()
responses = self.responses['profile']['delete_profile']
guild_id = str(ctx.guild.id)
if guild_exists(guild_id):
data = get_servers_data()
if profile in data[guild_id]['profiles']:
del data[guild_id]['profiles'][profile]
set_servers_data(data)
await ctx.send(responses["success"].format(
name=format(profile, "single_code")))
else:
raise commands.BadArgument(profile, "invalid_profile")
else:
raise commands.BadArgument(profile, "invalid_profile")
async def delete_jail(self, ctx):
self.update_response()
responses = self.responses['jail']['delete_jail']
guild_id = str(ctx.guild.id)
data = get_servers_data()
jail_role = discord.utils.get(ctx.guild.roles,
id=data[guild_id]["jail_role"])
await ctx.send(responses["starting"].format(jail_role=jail_role.name))
channels = ctx.guild.channels
for channel in channels:
await channel.set_permissions(jail_role, overwrite=None)
data[guild_id]["jail_role"] = None
data[guild_id]["jail_channel"] = None
set_servers_data(data)
await ctx.send(responses["success"].format(jail_role=jail_role.mention)
)
async def predicate(ctx):
guild_id = str(ctx.guild.id)
guild_data = get_servers_data()[guild_id]
if ("jail_role" in guild_data and guild_data["jail_role"]
is not None) and ("jail_channel" in guild_data and
guild_data["jail_channel"] is not None):
return True
# if the check has gone this far and returned nothing, then the check has failed
with open("info/responses.json", "r") as f:
responses = json.load(f)['fail_check']['jail_exists']
embed = embed_template(
title=responses['embed_data']['title'].format(
command=ctx.invoked_with),
description=responses['embed_data']['description'].format(
command=ctx.invoked_with, prefix=ctx.prefix))
embed.color = 15138816
await ctx.send(content=responses['content'], embed=embed)
async def predicate(ctx):
guild_id = str(ctx.guild.id)
guild_data = get_servers_data()[guild_id]
permission_type = guild_data["permission_type"]
if guild_data["permission_type"] == "custom":
return True
# if the check has gone this far and returned nothing, then the check has failed
with open("info/responses.json", "r") as f:
responses = json.load(f)['fail_check']['custom_perms_enabled']
embed = embed_template(
title=responses['embed_data']['title'].format(
command=ctx.invoked_with),
description=responses['embed_data']['description'].format(
command=ctx.invoked_with,
permission_type=permission_type,
prefix=ctx.prefix))
embed.color = 15138816
await ctx.send(content=responses['content'], embed=embed)
def help_embed(self, ctx, embed):
response = self.responses["help"]["help"]
prefix = get_servers_data()[str(ctx.guild.id)]['prefix']
embed.title = response["embed_data"]["title"].format(name=ctx.me.name)
embed.description = response["embed_data"]["description"].format(prefix=prefix)
for cog in self.client.cogs.values(): # maybe change into .items() depending on needs
name = cog.qualified_name.lower()
if name in self.info_commands: # if the value exists -> add a field
if self.info_commands[name]: # if the value is not an empty string -> add string as description field
embed.add_field(name=cog.qualified_name, value=self.info_commands[name]['_description'])
else: # else add default _unknown string as description field
embed.add_field(name=cog.qualified_name, value=self.info_commands["_unknown"].format(item=cog.qualified_name))
else: # print an error
print(f"error: could not find cog {cog.qualified_name} in commands.json")
return response.get("content")
async def create_profile(
self, ctx, name: str,
*role_sources: commands.Greedy[typing.Union[discord.Member,
discord.Role]]):
# self.update_responses()
responses = self.responses['profile']['create_profile']
# get a list of the roles the user wants to add to this newly created profile
add_roles = []
for source in role_sources:
if hasattr(source, 'roles'): # if it is a member
for role in source.roles:
add_roles.append(role)
else:
add_roles.append(source)
# filter out any duplicates
add_roles = set(add_roles)
# filter out the '@everyone' role you may get from members
add_roles = self.filter_everyone_role(add_roles)
role_names = [role.name for role in add_roles]
role_ids = [role.id for role in add_roles]
guild_id = str(ctx.guild.id)
message = ""
if role_names and role_ids:
guild_exists(guild_id)
# read server configs
data = get_servers_data()
if name in data[guild_id]['profiles']:
message += f"{responses['replace'].format(name=format(name, 'single_code'))}\n"
data[guild_id]['profiles'][name] = role_ids
set_servers_data(data)
message += responses['success'].format(roles=', '.join([
format(role_name, "single_code") for role_name in role_names
]),
name=format(
name, "single_code"))
await ctx.send(message)
else:
raise commands.BadArgument("invalid_role_sources")
async def allow_permission(self, ctx, *users: discord.Member):
self.update_response()
responses = self.responses['permissions']['allow_permission']
if not users:
return await ctx.send(responses['no_users'])
data = get_servers_data()
guild_id = str(ctx.guild.id)
message = ""
user_names = []
for user in users:
user_id = int(user.id)
if user_id not in data[guild_id]['custom_has_permission']:
data[guild_id]['custom_has_permission'].append(user_id)
user_names.append(user.name)
else:
message += f"{responses['fail'].format(user=user.name)}\n"
set_servers_data(data)
if user_names:
user_names = ', '.join(user_names)
message += responses['success'].format(users=user_names)
await ctx.send(message)
def module_help_embed(self, ctx, cog, embed):
response = self.responses["help"]["modules"]
prefix = get_servers_data()[str(ctx.guild.id)]['prefix']
embed.title = response["embed_data"]["title"].format(module=cog.qualified_name)
if cog.qualified_name.lower() in self.info_commands: # check if cog exists in info commands (this is not checking if command exists)
info_command = self.info_commands[cog.qualified_name.lower()]
embed.description = response["embed_data"]["description"].format(module=cog.qualified_name, prefix=prefix)
for command in cog.get_commands():
# similar to what happens in function help_embed above
name = command.name.lower()
if name in info_command:
if info_command[name]:
# give description a max length of 150 characters while viewing it in module help
description = info_command[name]['description'][0:150]+"..." if len(info_command[name]['description']) >= 150 else info_command[name]['description']
embed.add_field(name=command.name, value=description)
else:
embed.add_field(name=command.name, value=self.info_commands["_unknown"].format(item=cog.qualified_name))
else:
print(f"error: could not find command {command.name} in commands.json")
else:
embed.description = self.info_commands["_unknown"].format(item=cog.qualified_name)
return response.get("content")
async def set_permission_type(self, ctx, new_permission_type: str):
self.update_response()
responses = self.responses['permissions']['set_permission_type']
data = get_servers_data()
guild_id = str(ctx.guild.id)
guild_exists(guild_id)
permission_type = data[guild_id]["permission_type"]
if new_permission_type.lower() in ["administrator", "admin"]:
new_permission_type = "administrator"
elif new_permission_type.lower() in [
"manage_server", "server", "manage"
]:
new_permission_type = "manage_server"
elif new_permission_type.lower() in ["everyone", "every"]:
new_permission_type = "everyone"
elif new_permission_type.lower() in ["custom"]:
new_permission_type = "custom"
else:
print(
f"error to be implemented: {new_permission_type} is not a permission type"
)
return False
if permission_type != new_permission_type:
if permission_type == 'custom':
update_setting(guild_id, 'custom_has_permission', [])
update_setting(guild_id, 'permission_type', new_permission_type)
await ctx.send(responses['success'].format(
permission_type=format(permission_type, "single_code"),
new_permission_type=format(new_permission_type,
"single_code")))
else:
raise commands.BadArgument(permission_type,
"invalid_permission_type")
def __init__(self):
self.servers = get_servers_data()
self.client = Client(self.prefix)
def remove_profile_role(self, guild_id: str, role_id: int, profile: str):
data = get_servers_data()
data[guild_id]['profiles'][profile].remove(role_id)
set_servers_data(data)
