async def warn(ctx, client): # TODO: Add support for ids if ctx.author.guild_permissions.administrator != True: return content = shlex.split(ctx.content) db = await database_connection(ctx.guild.id) if len(content) <= 2: embed = create_embed("!warn", "!warn {user} {reason here}", "orange") add_field(embed, "user", "@ the user you'd like to warn", True) add_field(embed, "reason", "The reason you're warning the user.", True) await ctx.channel.send(embed=embed) return user_id = content[1][3:-1] reason = "".join(content[2::]) db["db"].execute( "INSERT INTO infractions (datetime, type, user_id, moderator_id, reason) VALUES (?, ?, ?, ?, ?)", ( str(datetime.datetime.now()), "warn", int(user_id), int(ctx.author.id), reason, ), ) db["con"].commit() warned_user = client.get_user(int(user_id)) embed = create_embed(f"{warned_user} has been warned for: {reason}", "", "light_green") await ctx.channel.send(embed=embed)
async def welcome_toggle(ctx, client): if ctx.author.guild_permissions.administrator != True: return db = await database_connection(ctx.guild.id) content = shlex.split(ctx.content) if len(content) != 1: embed = create_embed("Welcome Toggle", "Toggles the Welcome message on and off.", "orange") await ctx.channel.send(embed=embed) return welcome_info = list(db["db"].execute("SELECT * FROM WELCOME").fetchone()) if welcome_info[2] == 0: welcome_info[2] = 1 embed = create_embed("Welcome Message Enabled", "", "light_green") else: welcome_info[2] = 0 embed = create_embed("Welcome Message Disabled", "", "red") db["db"].execute( "UPDATE welcome SET channel = ?, message = ?, enabled = ?", (welcome_info[0], welcome_info[1], welcome_info[2]), ) db["con"].commit() await ctx.channel.send(embed=embed)
async def commands(ctx, client): # TODO db = await database_connection(ctx.guild.id) command_list = [ i[0] for i in db["db"].execute( "SELECT command FROM custom_commands").fetchall() ] if len(command_list) >= 1: final = """```""" for command in command_list: final += command + "\n" final += "```" embed = create_embed("Commands", final, "orange") await ctx.channel.send(embed=embed) else: embed = create_embed( "Error", "There are currently no commands! Ask an admin to use !create_command", "red", ) await ctx.channel.send(embed=embed)
async def remove_command(ctx, client): if ctx.author.guild_permissions.administrator != True: return content = shlex.split(ctx.content) db = await database_connection(ctx.guild.id) if len(content) != 2: embed = create_embed("Remove_command", "!remove_command {command}", "orange") add_field( embed, "command", "The command you would like to remove (ie. !info or !hello)", True, ) await ctx.channel.send(embed=embed) return command = content[1] if command[0] != "!": command = "!" + command command_list = [ i for i in db["db"].execute("SELECT * FROM custom_commands").fetchall() ] for c in command_list: if c[0] == command: db["db"].execute("DELETE FROM custom_commands WHERE command = (?)", (command, )) db["con"].commit() embed = create_embed("Command Removed Successfully.", "", "dark_blue") add_field(embed, "command", c[0], True) add_field(embed, "description", c[1], True) add_field(embed, "image", c[2], True) await ctx.channel.send(embed=embed) return embed = create_embed( "Error", "Invalid Command to Remove. Try checking all of the commands with !commands", "red", ) await ctx.channel.send(embed=embed)
async def remove_role(ctx, client): db = await database_connection(ctx.guild.id) content = shlex.split(ctx.content) if len(content) != 2: embed = create_embed("Remove_role", "!remove_role {role}", "orange") add_field( embed, "role", "The actual role to remove from !roles (ie. Member or @Member)", True, ) await ctx.channel.send(embed=embed) return role = content[1] if role[0:2] == "<@": # Actual Role @ provided role_id = role[3:-1] else: role_id = [i.id for i in ctx.guild.roles if i.name == role] if len(role_id) == 1: role_id = role_id[0] else: #! Error Message embed = create_embed( "Error", "The 'role' provided is invalid. Make sure it's spelled correctly with proper capitalization (case sensitive) and consider trying to use the actual @ for the role.", "red", ) await ctx.channel.send(embed=embed) return removal_role = (db["db"].execute( "SELECT * FROM normal_roles WHERE role_id = (?)", (int(role_id), )).fetchall()[0]) db["db"].execute("DELETE FROM normal_roles WHERE role_id = (?)", (int(removal_role[0]), )) db["con"].commit() embed = create_embed("Role Removed", "", "dark_blue") add_field(embed, "Role", f"{ctx.guild.get_role(int(removal_role[0])).mention}", True) add_field(embed, "Command", f"!role {removal_role[1]}", True) await ctx.channel.send(embed=embed)
async def programs_setup(ctx, client): if ctx.author.guild_permissions.administrator != True: return content = shlex.split(ctx.content) db = await database_connection(ctx.guild.id) if len(content) != 2: embed = create_embed("Programs_setup", "!programs_setup {channel}", "orange") add_field( embed, "channel", "The channel (ie. #mod-queue) or the name of the channel (ie. mod-queue). When a user uses !programs_add, a moderator will have to 'accept' the submission for it to be useable with !programs.", True, ) await ctx.channel.send(embed=embed) return channel = content[1] if channel[0:2] == "<#": # Real channel channel_id = channel[2:-1] else: # Name of a channel channel_id = [i.id for i in ctx.guild.channels if i.name == channel] if len(channel_id) == 1: channel_id = channel_id[0] else: #! Error Message embed = create_embed( "Error", "The channel provided is invalid. Make sure it's spelled correctly with proper capitlization (case sensitive). Consider trying to use the actual # for the channel (ie. #channel)", "red", ) await ctx.channel.send(embed=embed) return db["db"].execute("UPDATE settings SET programs_channel = (?)", (channel_id, )) db["con"].commit() embed = create_embed("Programs Setup Successfully", "", "light_green") add_field(embed, "channel", f"{ctx.guild.get_channel(int(channel_id)).mention}", True) await ctx.channel.send(embed=embed)
async def custom_command_handling(ctx: discord.ext.commands.Context, command: str): """Handling for custom commands Args: ctx (discord.ext.commands.Context): Context command (str): The command that was called """ db = await Commands_DB(ctx.guild.id) # List of commands command_list = await db.grab_commands() if command_list is None: return # Checks for c in command_list: if command.lower() == c[0]: embed = create_embed(f"{command.capitalize()}", f"{c[1]}", "orange") if c[2] is not None: embed.set_image(url=c[2]) await ctx.channel.send(embed=embed)
async def broadcast(ctx): if ctx.author.id != 178543252637483009: return msg = ctx.message.content.split("!broadcast")[1] embed = create_embed("Message from JZ", msg, "orange") for server in bot.guilds: channel_names = [channel.name for channel in server.channels] if "general" in channel_names or "chat" in channel_names: for channel in server.channels: if channel.name == "chat" or channel.name == "general": try: await channel.send(embed=embed) except Exception: print("Didn't work.") else: break else: for channel in server.channels: print(channel) try: await channel.send(embed=embed) except Exception: continue else: break
async def programs(ctx, bot, user: str) -> Tuple[bool, discord.Embed]: """Display's a user's programs Args: ctx (discord.ext.commands.Context): Context bot (discord.ClientUser.bot): Bot user (str): User's programs to display Returns: Tuple[bool, discord.Embed]: [Status: bool, Embed: discord.Embed] """ # Check if user is None: return ( False, create_embed_template("Invalid Arguments", "User was Null.", "error"), ) # Gets the user's id user = parse_id(user) db = await Programs_DB(ctx.guild.id) # Grabs all of the programs programs_list = await db.grab_programs(user) # Empty list if programs_list is None: return ( False, create_embed_template( "Invalid User", "That user doesn't have any programs, have them use /programs add.", "error", ), ) programs_list = programs_list.split("\n") # Creates the message message = "" space_amount = (len(programs_list) // 10) + 1 for i in range(len(programs_list)): if programs_list[i] != "" and programs_list[i] is not None: # Ensure the numbers line up number = f"{i + 1}".rjust(space_amount, " ") # Only add a newline if it's required message += f"{number}. {programs_list[i]}" + ( "\n" if i != (len(programs_list) - 1) else "") user = bot.get_user(user) return ( True, create_embed(f"{user.name}#{user.discriminator}'s Programs", message, "orange"), )
async def welcome_setup(ctx, client): if ctx.author.guild_permissions.administrator != True: return db = await database_connection(ctx.guild.id) content = shlex.split(ctx.content) if len(content) != 3: embed = create_embed("Welcome_setup", "!welcome_setup {@channel} {description}", "orange") add_field( embed, "@channel", "Provide the @ for the channel you want the welcome message to be in.", True, ) add_field( embed, "description", 'Create a welcome message for your server. Example: "Welcome {{USER}} to the server!".', True, ) add_field( embed, "Hint", "The {{USER}} charchter will be repleaced with the User's @ when they join the server.", True, ) await ctx.channel.send(embed=embed) return channel = content[1][2:-1] message = content[2] db["db"].execute( "UPDATE welcome SET channel = ?, message = ?, enabled = ?", (channel, message, True), ) db["con"].commit() embed = create_embed("Welcome Message Created Successfully", "", "light_green") add_field(embed, "Message", message, True) add_field(embed, "Channel", channel, True) await ctx.channel.send(embed=embed)
async def page_command(ctx, bot, items: list, title: str): """Creates a paged dialog for printing out large quantities of items Args: ctx (discord.Context): Context for the command call bot (discord.Bot): The actual bot instance items (list): A list of items to display title (str): Title of the page list """ if type(items) != list: items = list(items) # Sort the items list items.sort() # Creates lists splitting every 20 values pages_lists = [] for i in range(0, len(items), 20): pages_lists.append(items[i:i + 20]) # If there is only one list, we can just print out the first page and then end if len(pages_lists) == 1: l1, l2 = pages_lists[0][0:10], pages_lists[0][10::] embed = create_embed(title, "", "orange") add_field(embed, "List 1:", "\n".join(l1), True) if l2: add_field(embed, "List 2:", "\n".join(l2), True) await ctx.send(embed=embed) return # Creates the different embeds for each of the pages in a dictionary # ie. messages[1], messages[2]... will be embeds messages = {} i = 1 for m in pages_lists: embed = create_embed(title, "", "orange") add_field(embed, "List 1:", "\n".join(m[0:10]), True) if m[10::]: add_field(embed, "List 2:", "\n".join(m[10::]), True) messages[i] = embed i += 1 # Send the original message w/ reactions await send_page_command(ctx, bot, messages)
async def welcome_toggle(ctx): if ctx.author.guild_permissions.administrator is False: return db = await Guild_DB(ctx.guild.id) welcome_info = await db.grab_welcome() if welcome_info['enabled'] is False: embed = create_embed("Welcome Message Enabled", "", "light_green") welcome_info['enabled'] = True else: embed = create_embed("Welcome Message Disabled", "", "red") welcome_info['enabled'] = False await db.update_welcome(welcome_info) await ctx.channel.send(embed=embed, hidden=True)
async def programs(ctx, client): content = shlex.split(ctx.content) db = await database_connection(ctx.guild.id) if len(content) != 2: embed = create_embed("Programs", "!programs {user}", "orange") add_field(embed, "user", "The user's programs you'd like to see. (ie. @JZ)", True) add_field(embed, "Example", "!programs <@749359897405161522>") await ctx.channel.send(embed=embed) return # user_id = content[1][3:-1] # Finding the user_id to use user_id = find_user(content[1]) db["db"].execute("SELECT * FROM programs WHERE user_id = (?)", (user_id, )) user_data = db["db"].fetchone() if user_data is None: embed = create_embed( "No Programs.", "That user hasn't created a !programs. Create one with !programs_add.", "red", ) await ctx.channel.send(embed=embed) return programs = user_data[1].split("\n") message = "```" space_amount = (len(programs) // 10) + 1 for program in range(len(programs)): if programs[program] != "": number = f"{program + 1}".rjust(space_amount, " ") message += f"{number}. {programs[program]}\n" message += "```" embed = create_embed(f"Programs", "", "orange") add_field(embed, "User", f"{client.get_user(int(user_id)).mention}", False) add_field(embed, "Programs", message, True) await ctx.channel.send(embed=embed)
async def add_role(ctx: discord.ext.commands.Context, name: str, role_id: int): """Adds a role to the database Args: ctx (discord.ext.commands.Context): Context name (str): Name of the role (denominator) role_id (int): The role's ID """ if ctx.author.guild_permissions.administrator is False: return ( False, create_embed_template( "No Permission", "You do not have permission to add a role. Contact an administrator.", "error", ), ) db = await Roles_DB(ctx.guild.id) if await db.check_role(role_id, name): for role in ctx.guild.roles: if role.name == "Borg" or role.name == "Borg Test": borg_role = {"id": role.id, "position": role.position} actual_role = ctx.guild.get_role(role_id) if borg_role["position"] > actual_role.position: await db.add_role(role_id, name) embed = create_embed("Role Added", "", "light_green") add_field(embed, "Role", actual_role.mention, True) add_field(embed, "Command", f"!role {name}", True) return True, embed else: return ( False, create_embed_template( "Bot Doesn't have Permission.", "The bot does not have permission to give that role to users. Ensure the bot's role (@Borg) is **ABOVE** the role in the 'Roles' part of your server's dashboard.", "error", ), ) else: return ( False, create_embed_template( "Already Created", "There is already a command associated with **either** that role or command name. Check with !roles.", "error", ), )
async def roles(ctx, client): db = await database_connection(ctx.guild.id) full_roles = [i for i in db["db"].execute("SELECT * FROM normal_roles")] embed = create_embed("Roles", "", "orange") for role in full_roles: add_field(embed, f"!role {role[1]}", f"{ctx.guild.get_role(role[0]).mention}", True) await ctx.channel.send(embed=embed)
async def help_command(ctx, client: discord.Client): """!help""" embed = create_embed("Help", "", "orange") add_field(embed, "!help", "Provides a list of all commands.", True) add_field(embed, "!roles", "Provides a list of the roles a user can add with !add.", True) add_field( embed, "!role", "Allows the user to add a role. Example: !add Member.", True, ) add_field( embed, "!create_role", "Allows an administrator to add a new role to be used with !role.", True, ) add_field( embed, "!remove_role", "Allows an administrator to remove a role used with !role.", True, ) add_field( embed, "!create_command", "Allows an administrator to create a custom command", True, ) add_field( embed, "!remove_command", "Allows an administrator to remove a custom command", True, ) add_field(embed, "!commands", "Provides a list of all of the custom commands", True) add_field( embed, "!programs_setup {channel}", "Allows an administrator to setup the !programs.", True, ) add_field(embed, "!programs", "Allows someone to look up a user's commands.", True) add_field(embed, "!programs_add", "Allows a user to add their !programs.", True) add_field(embed, "!programs_remove", "Allows you to remove your programs.", True) await ctx.channel.send(embed=embed)
async def role(ctx, client): users_roles = [i.id for i in ctx.author.roles] db = await database_connection(ctx.guild.id) content = shlex.split(ctx.content) if len(content) == 2: # Role role_name = content[1] role_id = 10 role_id = (db["db"].execute( "SELECT role_id FROM normal_roles WHERE command = (?)", (role_name, )).fetchall()[0][0]) print(role_id) if role_id in users_roles: # Remove the role await ctx.author.remove_roles(ctx.guild.get_role(role_id)) embed = create_embed( "Removed Role", f"{ctx.author.mention} removed role {ctx.guild.get_role(role_id).mention}.", "orange", ) await ctx.channel.send(embed=embed) else: # Add the role await ctx.author.add_roles(ctx.guild.get_role(role_id)) embed = create_embed( "Added Role", f"{ctx.author.mention} added role {ctx.guild.get_role(role_id).mention}.", "orange", ) await ctx.channel.send(embed=embed) else: await roles(ctx, client)
async def userinfo(ctx, client): # TODO: User ID support content = shlex.split(ctx.content) if len(content) != 2: embed = create_embed("!user_info", "!user_info {user}", "orange") add_field(embed, "user", "@ the user you'd like to display furthur information.", True) await ctx.channel.send(embed=embed) return user_id = content[1][3:-1] user_targeted = client.get_user(int(user_id)) user_targeted_member = ctx.guild.get_member(int(user_id)) embed = create_embed(str(user_targeted), user_targeted.mention, "magenta") embed.set_thumbnail(url=user_targeted.avatar_url) add_field( embed, "Joined", f"{user_targeted_member.joined_at.strftime('%a, %b %d, %Y %I:%M %p')}", True, ) add_field( embed, "Account Created", user_targeted_member.created_at.strftime("%a, %b %d, %Y %I:%M %p"), True, ) roles = user_targeted_member.roles role_amount = len(roles) roles_string = ", ".join([i.mention for i in roles]) add_field(embed, f"Roles [{role_amount}]", roles_string, False) await ctx.channel.send(embed=embed)
async def check_custom_command(ctx, client, command): db = await database_connection(ctx.guild.id) command_list = [ i for i in db["db"].execute("SELECT * FROM custom_commands").fetchall() ] for c in command_list: if f"!{command.lower()}" == c[0]: embed = create_embed(f"{command.capitalize()}", f"{c[1]}", "orange") if c[2] != None: embed.set_image(url=c[2]) await ctx.channel.send(embed=embed)
async def course_embed(course): requirements, academic_level, units, campus = False, False, False, False if course["school"] == "queens": requirements, academic_level, units = True, True, True elif course["school"] == "waterloo": requirements = True elif course["school"] == "uoft": requirements, units, campus = True, True, True embed = create_embed( f"{course['code']} - {course['name']}", course["description"], "cyan", thumbnail=COURSE_IMAGES[course["school"]], ) if requirements: if course["school"] == "queens": requirements = course["requirements"] if requirements is None or requirements == "": requirements = "Unknown/No Requirements. Check the website." else: requirements = requirements.replace(". ", ".\n") elif course["school"] == "waterloo": requirements = course["requirements"] if requirements is None: requirements = "Unknown/No Requirements. Check the university website." else: requirements = course["requirements"] add_field(embed, "Requirements", requirements, False) if academic_level: add_field(embed, "Academic Level", course["academic_level"], True) if units: add_field(embed, "Units", course["units"], True) if campus: add_field(embed, "Campus", course["campus"], True) return embed
async def welcome_setup(ctx, channel: int, description: str): """Sets up the welcome messages.""" if ctx.author.guild_permissions.administrator is False: return db = await Guild_DB(ctx.guild.id) # Updates the DB await db.update_welcome({ 'channel': channel, 'message': description, 'enabled': True }) # Send status message embed = create_embed("Welcome Message Created Successfully", "", "light_green") add_field(embed, "Message", description, True) add_field(embed, "Channel", channel, True) await ctx.channel.send(embed=embed, hidden=True)
async def remove_role(ctx, role_id: int): """Removes a role from the database Args: ctx (discord.ext.commands.Context): Context role_id (int): The ID of the role """ if ctx.author.guild_permissions.administrator is False: return ( False, create_embed_template( "No Permission.", "You do not have permission to remove a role. Ask an administrator.", "error", ), ) db = await Roles_DB(ctx.guild.id) removal_role = await db.grab_role(role_id=role_id) if removal_role is None: return ( False, create_embed_template( "No Command.", "There is no command associated with that role in this server.", "error", ), ) await db.remove_role(role_id) embed = create_embed("Role Removed", "", "dark_blue") add_field(embed, "Role", f"{ctx.guild.get_role(removal_role['role_id']).mention}", True) add_field(embed, "Command", f"!role {removal_role['command']}", True) return [True, embed]
async def stress(ctx, client): eng_round = datetime.datetime(2021, 3, 31, 12, 0, 0, 0) eng_round = eng_round.astimezone(pytz.timezone("US/Eastern")) now = datetime.datetime.utcnow() now = now.replace(tzinfo=pytz.UTC) now = now.astimezone(pytz.timezone("US/Eastern")) difference = eng_round - now seconds = difference.seconds hours = seconds // 60 // 60 seconds -= hours * 60 * 60 mins = seconds // 60 seconds -= mins * 60 embed = create_embed( "Engineering Round", f"There is {difference.days} days {hours} hours and {mins} minutes until the Engineering Round. Time to cope :)", "orange", ) await ctx.channel.send(embed=embed)
async def programs_setup(ctx: discord.ext.commands.Context, channel: int) -> Tuple[bool, discord.Embed]: """Allows an administrator to setup a programs channel Args: ctx (discord.ext.commands.Context): Context channel (int): The channel for programs verification commands Returns: Tuple[bool, discord.Embed]: [Status: bool, Embed: discord.Embed] """ if ctx.author.guild_permissions.administrator is False: return if not channel: return False, "Invalid channel." db = await Guild_DB(ctx.guild.id) await db.update_settings("programs_channel", channel) return True, create_embed(f"Programs Setup Successfully.", f"Channel: <#{channel}>", "light_green")
async def create_command(ctx, client): # Todo: !create_command !commandname 'text here' if ctx.author.guild_permissions.administrator != True: return db = await database_connection(ctx.guild.id) content = shlex.split(ctx.content, posix=False) # x = 3, 4 if len(content) != 3 and len(content) != 4: embed = create_embed( "Create_command", "!create_command {'!command name'} {'description'} {'image (optional)'}", "orange", ) add_field( embed, "command name", "The 'name' of the command (ie. !info or !welcome).", True, ) add_field( embed, "description", 'The actual text provided by the command (ie. "Information can be found here: https://wikipedia.com")', True, ) add_field( embed, "image (optional)", "An optional image to display with the command.", True, ) example_list = """``` - item 1 - item 2 - item 3 - etc...```""" add_field( embed, "Hint", f'If you want to add multiple lines OR use a space (for example, as Code or as a list. You\'ll need to use qutoation marks (""). Example: !create_command !list "Here is a list: {example_list}', True, ) await ctx.channel.send(embed=embed) return command = content[1] if command[0] == '"' and command[-1] == '"': command = command[1:-1] description = content[2] if len(content) == 3: image = None else: if content[3][0] == '"' and content[3][-1] == '"': image = content[3][1:-1] else: image = content[3] #! settings_location # with open(await settings_location(ctx.guild.id)) as f: # l = yaml.safe_load(f) # command_list = [] # for group in l["default_commands"]: # for c in l["default_commands"][group]: # if type(c) == str: # command_list.append(c) command_list = [ i[0][1::] for i in db["db"].execute( "SELECT command FROM custom_commands").fetchall() ] if command[1::] in command_list: embed = create_embed( "Error", "That command is already a registerd command for this server.", "red", ) await ctx.channel.send(embed=embed) return if description[0] == '"' and description[-1] == '"': description = description[1:-1] db["db"].execute( "INSERT INTO custom_commands VALUES (?, ?, ?)", (command, description, image), ) db["con"].commit() embed = create_embed("Command Created Successfully.", "", "light_green") add_field(embed, "Command", command, True) add_field(embed, "Description", description, True) add_field(embed, "Image", image, True) await ctx.channel.send(embed=embed)
async def _programs(self, ctx): """!programs command""" content = ctx.message.content.split(" ") if len(content) == 1: embed = create_embed( "Command: !programs", "**Description**: Allows you to interact with programs commands.\n**Sub Commands**:\n!programs {user} - Allows you to see a user's programs. (ex: !programs <@749359897405161522>)\n!programs add - Allows you to add programs to your list.\n!programs remove - Allows you to remove programs from your list.\n!programs edit - Allows you to edit one of your programs.\n!commands setup - Allows an admin to setup a programs confirmation channel.", "orange", ) await ctx.send(embed=embed) return subcommand = content[1] def grab_user(content): user = re.search(r"<@(?:&|!|)[0-9]{18}>", " ".join(content)) if not user: return None, content else: content = " ".join(content).replace(user, "").split(" ") user = parse_id(user.group()) return user, content if subcommand == "add" or subcommand == "a": #: !programs add Queens CS if len(content) == 2: embed = create_embed( "Command: !programs add", "**Description**: Allows you to add programs to your list.\n**Usage**:\n!programs add Queens CS, Mcgill CS, UW CS\n!programs add Queens CS, UW CS <@749359897405161522>", "orange", ) await ctx.send(embed=embed) else: content = content[2::] user, content = grab_user(content) if user is None: user = ctx.author.id potential_programs = " ".join(content).split("\n") if len(potential_programs) == 1: potential_programs = [ i.strip() for i in potential_programs[0].split(",") ] else: p = [] for i in potential_programs: additions = [g.strip() for g in i.split(",")] p.extend(additions) potential_programs = p result = await programs_add(ctx, self.bot, potential_programs, user) await ctx.send(embed=result[1]) elif subcommand == "remove" or subcommand == "r": if len(content) == 2: embed = create_embed( "Command: !programs remove", "**Description**: Allows you to remove programs from your list. Provide a comma seperated list of numbers, or * to remove all of your programs.\n**Usage**:\n!programs remove 1, 2, 3\n!programs remove * <@749359897405161522>", "orange", ) await ctx.send(embed=embed) return content = content[2::] user, content = grab_user(content) if user is None: user = ctx.author.id result = await programs_remove(ctx, " ".join(content), user) await ctx.send(embed=result[1]) elif subcommand == "edit" or subcommand == "e": #: !command edit 1 New Program if len(content) < 4: embed = create_embed( "Command: !programs edit", "**Description**: Allows you to edit a program in your list. Provide the number for the program, and the new text.\n**Usage**:\n!programs edit 1 Queens CS\n!programs edit 1 Queens CS <@749359897405161522>", "orange", ) await ctx.send(embed=embed) return content = content[2::] user, content = grab_user(content) if user is None: user = ctx.author.id before = content[0] after = " ".join(content[1::]) result = await programs_edit(ctx, self.bot, user, before, after) await ctx.send(embed=result[1]) elif subcommand == "setup" or subcommand == "s": #: !command setup <#846962522065993768> if len(content) == 2 or len(content) > 3: embed = create_embed( "Command: !programs setup", "**Description**: Allows an administrator to setup a programs verification channel.\n**Usage**:\n!programs setup <@799848795050606607>", "orange", ) await ctx.send(embed=embed) return channel_id = parse_id(content[2]) if not channel_id: embed = create_embed_template("Invalid Setup Channel", "", "error") await ctx.send(embed=embed) return result = await programs_setup(ctx, channel_id) await ctx.send(embed=result[1]) else: attempt_user = parse_id(subcommand) if attempt_user: user_id = attempt_user else: user_id = ctx.guild.get_member_named(subcommand).id p = await programs(ctx, self.bot, user_id) await ctx.send(embed=p[1])
async def custom_command_remove(ctx: discord.ext.commands.Context, command: str) -> Tuple[bool, discord.Embed]: """Removes a custom command from the server's database Args: ctx (discord.ext.commands.Context): Context command (str): The name of the command to remove Returns: Tuple[bool, discord.Embed]: [Status: bool, Embed: discord.Embed] """ # Permissions check if ctx.author.guild_permissions.administrator is False: return ( False, create_embed_template( "No Permission", "You do not have permission to create commands.", "error", ), ) db = await Commands_DB(ctx.guild.id) # Removes the ! from the command -> !hello turns into hello if command[0] == "!": command = command[1::] # Grabs all of the commands grab_commands = await db.grab_commands() if grab_commands is None: return ( False, create_embed_template( "Invalid Command", "This server has no commands therefore you cannot remove one.", "error", ), ) command_list = [i[0] for i in grab_commands] if command in command_list: # Grabs the info for the command to be deleted command_delete = await db.fetch_command(command) # Deletes await db.remove_command(command) return ( True, create_embed( "Command Successfully Deleted", f"Command Deleted: !{command_delete[0]}", "light_green", ), ) else: return ( False, create_embed_template("Invalid Command", "Check the commands with !commands.", "error"), )
async def custom_command_add(ctx: discord.ext.commands.Context, name: str, description: str, image: str or None) -> Tuple[bool, discord.Embed]: """Adds a command to the database Args: ctx (discord.ext.commands.Context): Context name (str): Name of the command to add description (str): Description of the command image (str or None): Image link for the command Returns: Tuple[bool, discord.Embed]: [Status: bool, Embed: discord.Embed] """ name = name.lower() name = name[1::] if name[0] == "!" else name # Permissions check if ctx.author.guild_permissions.administrator is False: return ( False, create_embed_template( "No Permission", "You do not have permission to create a command.", "error", ), ) urls = [] if image: # Checks for an actual photo in "image" photo_indicators = ( "tenor", "jpeg", "jpg", "png", "gif", "webp", "giphy", "tiff", "nef", "cr2", "arw", ) # Extracts the urls from the "image" variable urls = URLExtract().find_urls(image) if len(urls) == 1: # Check to ensure the single URL is actually an image image = urls[0] if not (image.startswith("http") and set(image.split(".")).intersection(set(photo_indicators))): return ( False, create_embed_template("Invalid Image", "Make sure your link is to an image.", "error"), ) elif len(urls) == 2: # Too many URLs return ( False, create_embed_template( "Too many Links", "Borg can only support 1 image per command.", "error"), ) else: urls = None db = await Commands_DB(ctx.guild.id) # Find all of the current commands grab_commands = await db.grab_commands() if grab_commands is not None: command_list = [i[0] for i in grab_commands] # Ensure the current command is unique if name in command_list: return ( False, create_embed_template( "Invalid Command Name", "There is already a command with that denominator.", "error", ), ) # Add it to the database await db.add_command(name, description, image) return ( True, create_embed( "Success", f"Command successfully created, run it with !{name}", "light_green", ), )
async def role_toggle(ctx: discord.ext.commands.Context, role: str) -> Tuple[bool, discord.Embed]: """Handling for the !role command Args: ctx (discord.ext.commands.Context): Context role (str): The role's denominator Returns: Tuple[bool, discord.Embed]: [Status: bool, Embed: discord.Embed] """ # Grab the user's roles user_roles = [i.id for i in ctx.author.roles] db = await Roles_DB(ctx.guild.id) # Grab this server's role commands role_id = await db.grab_role(command=role) if role_id is None: return ( False, create_embed_template("Invalid Role", "Use !roles to see all of the roles.", "error"), ) role_id = role_id[1] actual_role = ctx.guild.get_role(role_id) if role_id in user_roles: # Add the role try: await ctx.author.remove_roles(actual_role) except: return ( False, create_embed_template( "No Permission.", "Borg doesn't have permission to add/remove that role. Ensure Borg's role is **above** the role you're trying to toggle in the server settings (Contact an administrator)", "error", ), ) embed = create_embed("Removed Role", f"You removed the {actual_role.mention} role.", "dark_blue") return True, embed else: # Remove the role try: await ctx.author.add_roles(actual_role) except: return ( False, create_embed_template( "No Permission.", "Borg doesn't have permission to add/remove that role. Ensure Borg's role is **above** the role you're trying to toggle in the server settings (Contact an administrator).", "error", ), ) embed = create_embed("Added Role", f"You added the {actual_role.mention} role.", "light_green") return True, embed
async def create_role(ctx, client): content = shlex.split(ctx.content) if ctx.author.guild_permissions.administrator != True: # Does not have permission return if len(content) != 3: # Provided no commandline arguments, print out a help message embed = create_embed("Create_role", "!create_role {role} {name}", "orange") add_field( embed, "role", "Provide the @ for the role (ie. @Member) or the name of the role (ie. Member)", True, ) add_field( embed, "name", "Provide the name for the user to add the role (ie. member or 'cool guy')", True, ) await ctx.channel.send(embed=embed) return # Role as an @ <@&749382234829750392> # Otherwise: Member role = content[1] name = content[2] db = await database_connection(ctx.guild.id) if role[0:2] == "<@": # Actual Role @ provided role_id = role[3:-1] else: role_id = [i.id for i in ctx.guild.roles if i.name == role] if len(role_id) == 1: role_id = role_id[0] else: #! Error Message embed = create_embed( "Error", "The 'role' provided is invalid. Make sure it's spelled correctly with proper capitalization (case sensitive) and consider trying to use the actual @ for the role.", "red", ) await ctx.channel.send(embed=embed) return if int(role_id) not in [ i[0] for i in db["db"].execute( "SELECT role_id FROM normal_roles").fetchall() ] and name not in [ i[0] for i in db["db"].execute( "SELECT command FROM normal_roles").fetchall() ]: for role in ctx.guild.roles: if role.name == "Borg Test" or role.name == "Borg": BORG_ROLE = {"id": role.id, "position": role.position} if BORG_ROLE["position"] > ctx.guild.get_role(int(role_id)).position: db["db"].execute("INSERT INTO normal_roles VALUES (?, ?)", (role_id, name)) db["con"].commit() embed = create_embed("Role Added", "", "light_green") add_field(embed, "Role", ctx.guild.get_role(int(role_id)).mention, True) add_field(embed, "Command", f"!role {name}", True) await ctx.channel.send(embed=embed) else: embed = create_embed( "Error", "The bot does not have permission to give that role to users. Ensure that the 'Borg' role is ABOVE the role in the 'Roles' part of your settings.", "red", ) await ctx.channel.send(embed=embed) else: # Error Message embed = create_embed( "Error", "The 'role' or 'name' already has a command associated. Check the list of roles with !roles.", "red", ) await ctx.channel.send(embed=embed)