async def snapshot_role(ctx, role: discord.Role, group: RoleGroup = None): """Adds role to the internal database""" if role.is_bot_managed() or role.is_integration() or role.is_premium_subscriber(): logger.info(f"Skipping role '{role}' as it's system role") raise commands.BadArgument(f"Role '{role}' is a system role") if not utils.can_manage_role(ctx.guild.me, role): logger.info(f"Skipping role '{role}' as bot cannot manage it") raise commands.BadArgument(f"Bot cannot manage role '{role}'") if await Role.exists(name=role.name): logger.info(f"Skipping role '{role}' as it already exists") raise commands.BadArgument(f"Role '{role}' already exists in DB") group = group or (await RoleGroup.get_or_create(name=utils.snapshot_role_group))[0] number = await db_utils.get_max_number(Role) await db_utils.reshuffle(Role, number) db_role = Role(name=role.name, color=role.color.value, number=number, archived=False, assignable=False, mentionable=role.mentionable, group=group) await db_role.save()
async def deauthorise(self, ctx, authorised_role: discord.Role, giveable_role: discord.Role): """Deauthorise one role to give another role In order to deauthorise, your highest role must be strictly above the `authorised_role` (except for the owner). """ gld = ctx.guild server_dict = await self.config.guild(gld).roles() author_max_role = max(r for r in ctx.author.roles) authorised_id = authorised_role.id giveable_id = giveable_role.id if authorised_role.is_default(): # Role to be de-authorised should not be @everyone. notice = self.AUTHORISE_NO_EVERYONE elif giveable_role.is_default(): # Same goes for role to be given. notice = self.AUTHORISE_NOT_DEFAULT elif authorised_role >= author_max_role and ctx.author != gld.owner: # Hierarchical role order check. notice = self.AUTHORISE_NO_HIGHER elif giveable_id not in server_dict: notice = self.AUTHORISE_EMPTY.format(giveable_role.name) elif authorised_id not in server_dict[giveable_id]: notice = self.AUTHORISE_MISMATCH.format(authorised_role.name, giveable_role.name) else: # Role de-authorisation is valid. server_dict[giveable_id].remove(authorised_id) await self.config.guild(gld).roles.set(server_dict) notice = self.DEAUTHORISE_SUCCESS.format(authorised_role.name, giveable_role.name) await ctx.send(notice)
def get_overwrites(arg: discord.Role, arg2: discord.PermissionOverwrite): return { "role_name": arg.name, "is_default": arg.is_default(), "is_bot": arg.is_bot_managed(), "is_boost": arg.is_premium_subscriber(), }
async def authorise(self, ctx, authorised_role: discord.Role, giveable_role: discord.Role): """Authorise one role to give another role Allows all members with the role `authorised_role` to give the role `giveable_role` to everyone. In order to authorise, your highest role must be strictly above the `authorised_role` (except for the owner). """ gld = ctx.guild server_dict = await self.config.guild(gld).roles() author_max_role = max(r for r in ctx.author.roles) authorised_id = authorised_role.id giveable_id = giveable_role.id if authorised_role.is_default(): # Role to be authorised should not be @everyone. notice = self.AUTHORISE_NO_EVERYONE elif giveable_role.is_default(): # Same goes for role to be given. notice = self.AUTHORISE_NOT_DEFAULT elif authorised_role >= author_max_role and ctx.author != gld.owner: # Hierarchical role order check. notice = self.AUTHORISE_NO_HIGHER # Check if "pair" already exists. elif giveable_id in server_dict and authorised_id in server_dict[giveable_id]: notice = self.AUTHORISE_EXISTS else: # Role authorisation is valid. server_dict.setdefault(giveable_id, []).append(authorised_id) await self.config.guild(gld).roles.set(server_dict) notice = self.AUTHORISE_SUCCESS.format(authorised_role.name, giveable_role.name) await ctx.send(notice)
async def srecolor(self, ctx, *, roleName: discord.Role, hexColor): """Edit Event Role color/colour""" try: roleName.edit(colour=discord.Colour(int(f"0x{hexColor}", 16))) except: ctx.send("Oops, that didn't work... Maybe something was typed weird?") else: await ctx.message.add_reaction("✅")
async def srename(self, ctx, roleName: discord.Role, *, newName): """Edit Event Role name""" try: roleName.edit(name=newName) except: ctx.send("Oops, that didn't work... Maybe something was typed weird?") else: await ctx.message.add_reaction("✅")
async def manage_roles_check( self, ctx: commands.Context, action: str, role: discord.Role = None, verbosity=Verbosity.ALL, error_title="default" ) -> int: # verbose toggle e.g. in multi-role changes """ Error checking to see if whatever action can be performed. Verbosity: 0: Nothing 1: Manage Roles barf embed 2: Everything Returns: 0: Humanity is fine Anything else: Alien invasion """ error_title = f"Couldn't {action} the role!" if error_title == "default" else error_title if not ctx.me.guild_permissions.manage_roles: # was originally gonna separate this all out but given discord rate-limits are stupid you can't work on the assumption that you"ve retained permissions if verbosity > Verbosity.SILENT: await self.bot.DefaultEmbedResponses.error_embed( self.bot, ctx, error_title, desc="Please give me **Manage Roles** permissions") return 3 if role: if role.managed or role.is_bot_managed( ) or role.is_premium_subscriber() or role.is_integration( ) or role.is_default(): """ Basically checks if the role is a nitro booster role, or is an integration-managed role. """ if verbosity == Verbosity.ALL: await self.bot.DefaultEmbedResponses.error_embed( self.bot, ctx, error_title, desc=f"A user cannot {action} this role") return 2 if ctx.me.top_role < role: if verbosity == Verbosity.ALL: await self.bot.DefaultEmbedResponses.error_embed( self.bot, ctx, error_title, desc=f"I can't add roles higher than me to members :sob:" if action == "add" else "I can't remove roles higher than me from members :sob:" ) return 1 return 0
async def roleinfo(self, ctx, role: discord.Role): embed = (discord.Embed(color=discord.Color.blurple()).set_author( name=f'Role Information: {str(role)}', icon_url=ctx.author.avatar_url)) embed.add_field(name='Creation Date:', value=role.created_at).add_field( name='Mentionable', value=role.mentionable) embed.add_field(name='Managed By Integration', value=role.is_integration()).add_field( name='Managed By Bot', value=role.is_bot_managed()) embed.add_field(name='Role Position', value=role.position).add_field(name='Role ID', value=f'`{role.id}`') await ctx.send(embed=embed)
async def role(self, ctx, *, role: discord.Role): query = f"""http://www.colourlovers.com/img/{hex(role.colour.value).replace("0x", "")}/100/100/""" embed = discord.Embed( colour=0x202225, title=f"Information about {role.name} (ID {role.id}!)") embed.set_thumbnail( url=query.replace("/img/0/100/100/", "/img/8B99A4/100/100/")) embed.add_field( name="Permissions", value= f"[{role.permissions.value}](https://discordapi.com/permissions.html#{role.permissions.value})", inline=True) embed.add_field(name="Hoisted", value=role.hoist, inline=True) embed.add_field(name="Position", value=f"{role.position}/{len(ctx.guild.roles)}", inline=True) embed.add_field(name="Mentionable", value=role.mentionable, inline=True) embed.add_field(name="Managed by 3rd party", value=role.managed, inline=True) embed.add_field(name="Is Managed", value=role.is_bot_managed(), inline=True) embed.add_field(name="Is the Boost Role", value=role.is_premium_subscriber(), inline=True) embed.add_field(name="Is an Integration", value=role.is_integration(), inline=True) embed.set_footer(text=f"Role created at {role.created_at}.") member_count = 0 members = "" for member in role.members: if member_count == 0: members += f"<@{member.id}>" else: members += f", <@{member.id}>" member_count += 1 try: embed.add_field(name=f"Role Members ({len(role.members)})", value=members, inline=False) except discord.errors.HTTPException: embed.add_field(name=f"Role Members ({len(role.members)})", value="There was too much to put here.", inline=False) await ctx.send(embed=embed)
async def role(self, ctx, *, role: discord.Role): '''Display info on a role.\n **Example:```yml\n♤role Tau\n♤role 657766595321528349```** ''' buffer = utils.display_color(role.color) perms = sorted((perm, value) for perm, value in iter(role.permissions)) plen = len(max(perms, key=lambda p: len(p[0]))[0]) half = len(perms) // 2 fields = [''] * 2 for i, tup in enumerate(perms): perm, value = tup tog = utils.Emoji.on if value else utils.Emoji.off align = ' ' * (plen - len(perm)) fields[i > half] += f'**`{perm}{align}`** {tog}\n' plural = 's' if len(role.members) != 1 else '' mention = role.mention if not role.is_default() else '@everyone' embed = Embed( description=f'**{mention}\n`{len(role.members)} member{plural}`**', color=role.color) embed.add_field(name='Permissions', value=fields[0]) embed.add_field(name='\u200b', value=fields[1]) embed.set_image(url='attachment://unknown.png') embed.set_footer(text=f'ID: {role.id}') await ctx.reply(file=File(buffer, 'unknown.png'), embed=embed, mention_author=False)
async def reactionrole_add(self, ctx: Context, msg: Message, emoji: EmojiConverter, role: Role, auto_remove: bool): """ add a new reactionrole link """ emoji: PartialEmoji if await db_thread(ReactionRole.get, msg.channel.id, msg.id, str(emoji)) is not None: raise CommandError(translations.rr_link_already_exists) if not msg.channel.permissions_for(msg.guild.me).add_reactions: raise CommandError(translations.rr_link_not_created_no_permissions) if role >= ctx.me.top_role: raise CommandError(translations.f_link_not_created_too_high(role, ctx.me.top_role)) if role.managed or role.is_default(): raise CommandError(translations.f_link_not_created_managed_role(role)) await db_thread(ReactionRole.create, msg.channel.id, msg.id, str(emoji), role.id, auto_remove) await msg.add_reaction(emoji) embed = Embed( title=translations.reactionrole, colour=Colours.ReactionRole, description=translations.rr_link_created ) await ctx.send(embed=embed) await send_to_changelog( ctx.guild, translations.f_log_rr_link_created(emoji, role.id, msg.jump_url, msg.channel.mention) )
async def selfroles(self, ctx, func: str, name: str, *, role: discord.Role = None): """Manage the guild self roles for the `iam` command. Valid functions: `add`, `new`, `remove`, `rm`, `rem`, `delete`, `del`""" if func in ['add', 'new']: if role: if role.is_default(): return await ctx.send(resolve_emoji('ERROR', ctx) + ' You cannot set the default everyone role as a self role.') if role.position >= ctx.author.top_role.position: return await ctx.send( resolve_emoji('ERROR', ctx) + ' You cannot manage a role higher than your own.') results = self.bot.query_db(f'''SELECT self_roles FROM settings WHERE guildid={ctx.guild.id};''') selfroles = json.loads(results[0][0].replace("'", '"')) if results and results[0][0] else json.loads('{}') selfroles[name] = role.id self.bot.query_db(f'''UPDATE settings SET self_roles="{str(selfroles)}" WHERE guildid={ctx.guild.id};''') await ctx.send(resolve_emoji('SUCCESS', ctx) + f' Successfully added self role **{name}** which gives role **{role}**. This can be applied with `{ctx.prefix}iam {name}`') else: await ctx.send(resolve_emoji('ERROR', ctx) + f' Missing required argument `role`, check `{ctx.prefix}help {ctx.command}`') elif func in ['rm', 'rem', 'remove', 'delete', 'del']: results = self.bot.query_db(f'''SELECT self_roles FROM settings WHERE guildid={ctx.guild.id};''') selfroles = json.loads(results[0][0].replace("'", '"')) if results and results[0][0] else json.loads('{}') try: del selfroles[name] except KeyError: return await ctx.send(resolve_emoji('ERROR', ctx) + f' There is no self role with the name `{name}`') self.bot.query_db(f'''UPDATE settings SET self_roles="{str(selfroles)}" WHERE guildid={ctx.guild.id};''') await ctx.send(resolve_emoji('SUCCESS', ctx) + f' Successfully removed self role **{name}**.') else: await ctx.send(resolve_emoji('ERROR', ctx) + f' Invalid function, check `{ctx.prefix}help {ctx.command}`')
async def add(self, ctx: Context, message: Message, emoji: FixedEmojiConverter, role: Role): """ add a new reactionrole link """ emoji: PartialEmoji if await run_in_thread(ReactionRole.get, message.channel.id, message.id, str(emoji)) is not None: raise CommandError(translations.rr_link_already_exists) if role > ctx.me.top_role: raise CommandError( translations.f_link_not_created_too_high( role, ctx.me.top_role)) if role.managed or role.is_default(): raise CommandError( translations.f_link_not_created_managed_role(role)) await run_in_thread(ReactionRole.create, message.channel.id, message.id, str(emoji), role.id) await message.add_reaction(emoji) await ctx.send(translations.rr_link_created) await send_to_changelog( ctx.guild, translations.f_log_rr_link_created(emoji, role, message.jump_url))
async def _add_remove(self, ctx: commands.Context, role: discord.Role, *, rm: bool = False): if role.is_default(): raise commands.BadArgument( "cannot make a server's default role mentionable") async with self.config.guild(ctx.guild).roles() as roles: if rm is False: if role.id in roles: await ctx.send( warning(_("That role is already mentionable"))) return roles.append(role.id) else: if role.id not in roles: await ctx.send( warning(_("That role is not currently mentionable"))) return roles.remove(role.id) await ctx.send( escape( tick( _("`{}` is now allowed to be mentioned").format(role. name)), mass_mentions=True, ) if rm is False else escape( tick( _("`{}` is no longer allowed to be mentioned"). format(role.name)), mass_mentions=True, ))
async def take(ctx, member: discord.Member, *, role: discord.Role): await ctx.message.delete() if role != None: if role > ctx.author.top_role and ctx.message.author.id != 338714886001524737: await ctx.send( 'Вы не можете забрать эту роль, так как она имеет более высокий ранг, чем ваша высшая роль.' ) elif role == ctx.author.top_role and ctx.message.author.id != 338714886001524737: await ctx.send( 'Вы не можете забрать эту роль у кого-либо, так как она равна вашей высшей роли.' ) elif role.is_default(): await ctx.send('Забирать everyone? Всё с башкой хорошо?') else: await member.remove_roles(role) channel = client.get_channel(714175791033876490) emb = discord.Embed(colour=member.color, timestamp=ctx.message.created_at) emb.add_field(name='Была забрана роль', value=f'{role.mention} | {role.name} | ID {role.id}') emb.add_field(name='Забрана:', value=member.mention) emb.set_author(name=ctx.author, icon_url=ctx.author.avatar_url) emb.set_footer( text='Обратите внимание, что это Бета версия основного бота.') await channel.send(embed=emb) else: emb = discord.Embed( description= f'{ctx.author.mention}, я не могу найти {role.mention} в списке ролей.', colour=member.color, timestamp=ctx.message.created_at) await ctx.send(embed=emb)
async def move_role_position_below(role:discord.Role, below:discord.Role, reason:typing.Optional[str]) -> None: """|coro| Moves the current role beneath the given role, cascading down and fixing the order of all lower roles """ if below.is_default() or role.is_default(): raise discord.errors.InvalidArgument("Cannot move default role") if below == role: return # Save discord the extra request. http = role._state.http # Fetch the roles from the API, ordered by the order of the cache all_guild_roles = sorted(await role.guild.fetch_roles()) # Get the order of the roles we want to append roles = [] encounters = 0 for r in all_guild_roles[1:]: if r.id == role.id: encounters += 1 continue if r.id == below.id: encounters += 1 roles.append(role) roles.append(r) else: roles.append(r) if encounters == 2: break # For up positions for the roles # I do it like this so there's less of a chance of me having to move the top role of the listing # or any roles above it, so that there's less of a chance of me having to move roles that # I don't have permission to deal with position = 1 new_roles = [{"id": roles[0].id, "position": 1}] for r in roles[1:]: if r.id > new_roles[-1]["id"]: position += 1 new_roles.append({"id": r.id, "position": position}) # Make and send the payload await http.move_role_position(role.guild.id, new_roles, reason=reason)
def test_set_point_leader_role_replaces_old_role_if_one_exists( discord_role: DiscordRole, guild: Guild, leader_role: PointLeaderRole): discord_role.id = ROLE_ID + 1 set_point_leader_role(discord_role) assert PointLeaderRole.select().count() == 1 role = PointLeaderRole.get(PointLeaderRole.guild_id == guild.id) assert role.role_id == discord_role.id
async def roleinfo(self, ctx, *, role: discord.Role): "See a role info" if role.hoist: hoist = f"📲 | Is Hoist" else: hoist = f"~~📲 | Isn't Hoist~~" if role.managed: managed = f"⌨️ | Is Managed" else: managed = f"~~⌨️ | Isn't Managed~~" if role.mentionable: mentionable = f"🏓 | Is Mentionable" else: mentionable = f"~~🏓 | Isn't Mentionable~~" if role.is_default(): default = f"📐 | By Default" else: default = "~~📐 | Not By Default~~" emb = discord.Embed(title=role.name, description=f""" 😀 | {role.name} 🆔 | {role.id} 📢 | {role.mention} 🍰 | Created at {role.created_at.strftime("%m / %d / %Y (%H:%M)")} 🙅 | {len(role.members)} users 📑 | {role.position}° position 🎨 | {role.colour} 🛑 | {role.permissions.value} Perms Value {hoist} {managed} {mentionable} {default} """, colour=role.colour, timestamp=ctx.message.created_at) emb.set_footer(text=ctx.guild.name, icon_url=ctx.guild.icon_url) await ctx.send(embed=emb)
def discord_role(discord_connection, discord_guild): from discord import Role return Role(data={ "id": 1, "name": "FakeRole" }, guild=discord_guild, state=discord_connection)
async def role_info(self, ctx, role: discord.Role): e = Embed(color=discord.Color.dark_theme()) e.add_field(name="Name", value=role.mention) e.add_field(name="Color", value=role.color) e.add_field(name="Member count", value=len(role.members)) e.add_field(name="Bot Role?", value=role.is_bot_managed()) e.add_field(name="Nitro Role?", value=role.is_premium_subscriber()) e.add_field( name="Permissions", value= f"**Admin?** {role.permissions.administrator}\n**Manager?** {role.permissions.manage_guild}", ) e.add_field(name="Position", value=role.position) e.add_field(name="ID", value=role.id) e.add_field(name="Created at", value=role.created_at) try: await ctx.send(embed=e) except Exception as e: await ctx.send(e)
async def can_manage_role(bot: commands.Bot, role: discord.Role) -> bool: if role.is_default(): print(1) return False if role.managed: print(2) return False if role.position >= role.guild.me.top_role.position: print(3) return False return True
async def role_update(self, role: discord.Role): (await GuildRoles.update.values( id=role.id, name=role.name, colour=str(role.colour), hoist=role.hoist, position=role.position, managed=role.managed, mentionable=role.mentionable, is_default=role.is_default(), created_at=role.created_at).where(GuildRoles.id == role.id ).gino.status())
async def role(ctx, *, role: discord.Role): await ctx.message.delete() if ctx.guild.id not in guilds: emb = discord.Embed(description = f'Сервер `{ctx.guild}` не имеет активных подписок. Купить можно по [Ссылке](https://www.patreon.com/cephaloncy) Преимущества: пинг не более 25ms, больший аптайм, защита от несанкционированного добавления на сервера.', colour = discord.Color.red()) await ctx.send(embed = emb) else: if role.mentionable == False: role.mentionable = 'Нет' elif role.mentionable == True: role.mentionable = 'Да' if role.managed == False: role.managed = 'Нет' elif role.managed == True: role.managed = 'Да' if role.hoist == False: role.hoist = 'Нет' elif role.hoist == True: role.hoist = 'Да' emb = discord.Embed(title = role.name, colour = role.colour) emb.add_field(name = 'ID', value = role.id) emb.add_field(name = 'Цвет', value = role.color) emb.add_field(name = 'Упоминается?', value = role.mentionable) emb.add_field(name = 'Управляется интеграцией?', value = role.managed) emb.add_field(name = 'Позиция в списке', value = role.position) now = datetime.datetime.today() then = role.created_at delta = now - then d = role.created_at.strftime('%d/%m/%Y %H:%M:%S UTC') emb.add_field(name = 'Создана', value = f'{delta.days} дня(ей) назад. ({d})', inline = False) emb.add_field(name = 'Показывает участников отдельно?', value = role.hoist) await ctx.send(embed = emb)
async def role(ctx, *, role: discord.Role): await ctx.message.delete() if role.mentionable == False: role.mentionable = 'Нет' elif role.mentionable == True: role.mentionable = 'Да' if role.managed == False: role.managed = 'Нет' elif role.managed == True: role.managed = 'Да' if role.hoist == False: role.hoist = 'Нет' elif role.hoist == True: role.hoist = 'Да' emb = discord.Embed(title=role.name, colour=role.colour) emb.add_field(name='ID', value=role.id) emb.add_field(name='Цвет', value=role.color) emb.add_field(name='Упоминается?', value=role.mentionable) emb.add_field(name='Управляется интеграцией?', value=role.managed) emb.add_field(name='Позиция в списке', value=role.position) now = datetime.datetime.today() then = role.created_at delta = now - then d = role.created_at.strftime('%d/%m/%Y %H:%M:%S UTC') emb.add_field(name='Создана', value=f'{delta.days} дня(ей) назад. ({d})', inline=False) emb.add_field(name='Показывает участников отдельно?', value=role.hoist) emb.set_footer( text='Обратите внимание, что это Бета версия основного бота.') await ctx.send(embed=emb)
async def set_new_role(self, ctx: "IceTeaContext", target_role: discord.Role = None, when: int = 0): """ Automatically assigns a role to a user, upon joining the server. Can only be used by server managers it has an optimal param to allow the bot to give the role after x seconds, If not set, will give the user the role right away. If you wish to disable this function after it's been enabled simply run this command without giving it a role. """ if target_role < ctx.me.top_role and not target_role.is_default(): ctx.guild_data.role = target_role.id ctx.guild_data.delay = when await ctx.guild_data.save() await ctx.send(f"I will now give {target_role} to new members")
async def role(self, ctx: commands.Context, r: discord.Role): """Shows role info""" emb = discord.Embed(title=r.name, color=r.color) emb.set_author(name=f'Color: #{r.color.value:X}') if r.is_bot_managed(): emb.description = 'Bot role: ' + self.bot.get_user( r.tags.bot_id).mention elif r.is_default(): emb.description = 'Default role' elif r.is_integration(): emb.description = 'Integration role: ❄ID ' + str( r.tags.integration_id) elif r.is_premium_subscriber(): emb.description = 'Nitro Boost role' emb.add_field(name='❄ ID', value=r.id) # noinspection PyTypeChecker emb.add_field(name='Member count', value=len(r.members)) emb.add_field(name='Displays separately', value=r.hoist) emb.add_field(name='Created at', value=r.created_at) emb.add_field(name='Permissions', value=f'0x{r.permissions.value:X}') emb.add_field(name='Position', value=r.position) await ctx.reply(embed=emb)
async def rinfo(self, ctx, *, role: discord.Role): """Get info about role""" em = discord.Embed( title=chat.escape(role.name, formatting=True), color=role.color if role.color.value else discord.Embed.Empty, ) em.add_field(name=_("ID"), value=role.id) em.add_field( name=_("Permissions"), value= "[{0}](https://cogs.fixator10.ru/permissions-calculator/?v={0})". format(role.permissions.value), ) em.add_field( name=_("Exists since"), value=get_markdown_timestamp(role.created_at, TimestampStyle.datetime_long), ) em.add_field(name=_("Color"), value=role.colour) em.add_field(name=_("Members"), value=str(len(role.members))) em.add_field(name=_("Position"), value=role.position) em.add_field(name=_("Managed"), value=bool_emojify(role.managed)) em.add_field(name=_("Managed by bot"), value=bool_emojify(role.is_bot_managed())) em.add_field(name=_("Managed by boosts"), value=bool_emojify(role.is_premium_subscriber())) em.add_field(name=_("Managed by integration"), value=bool_emojify(role.is_integration())) em.add_field(name=_("Hoist"), value=bool_emojify(role.hoist)) em.add_field(name=_("Mentionable"), value=bool_emojify(role.mentionable)) em.add_field(name=_("Mention"), value=role.mention + "\n`" + role.mention + "`") em.set_thumbnail( url= f"https://xenforo.com/community/rgba.php?r={role.colour.r}&g={role.color.g}&b={role.color.b}&a=255" ) await ctx.send(embed=em)
async def remove(self, ctx: commands.Context, target: discord.Member, *roles: discord.Role): roles = list(roles) for role in roles[:]: if role.position >= ctx.author.top_role.position: await ctx.send( "You don't have the power to manage the `{}` role!".format( role.name)) roles.remove(role) if roles == []: return await target.remove_roles(*roles, reason="Requested by " + ctx.author.name) s_roles = "" for i in range(len(roles)): if i != len(roles) - 1 and i != len(roles) - 2: s_roles += "`{}`, ".format(roles[i].name) elif i == len(roles) - 2: s_roles += "`{}`, and ".format(roles[i].name) else: s_roles += "`{}`".format(roles[i].name) await ctx.send("Took the {1} role(s) from {0}".format( target.mention, s_roles))
async def role(self, ctx, role: discord.Role): if (role.is_default() or role.managed or role.position >= ctx.guild.me.top_role.position): await ctx.send( "Please choose a role that isn't the `everyone` role, " "and isn't managed by an integration such as a bot, that I have permission to give." ) return await self.bot.config.upsert({ "_id": ctx.guild.id, "quiz_role": role.id }) await ctx.send("Role added as a quiz role.")
async def delete_role(self, ctx, *, role: discord.Role = None): """This command can be used to delete one of the roles from the server EXAMPLE: !role delete StupidRole RESULT: No more role called StupidRole""" # No use in running through everything if the bot cannot manage roles if not ctx.message.guild.me.permissions_in( ctx.message.channel).manage_roles: await ctx.send( "I can't delete roles in this server, do you not trust me? :c" ) return # If no role was given, get the current roles on the server and ask which ones they'd like to remove if role is None: server_roles = [ role for role in ctx.message.guild.roles if not role.is_default() ] await ctx.send( "Which role would you like to remove from the server? Here is a list of this server's roles:" "```\n{}```".format("\n".join([r.name for r in server_roles]))) # For this method we're only going to delete one role at a time # This check attempts to find a role based on the content provided, if it can't find one it returns None # We can use that fact to simply use just that as our check def check(m): if m.author == ctx.message.author and m.channel == ctx.message.channel: return discord.utils.get(server_roles, name=m.content) is not None else: return False try: msg = await ctx.bot.wait_for('message', timeout=60, check=check) except asyncio.TimeoutError: await ctx.send( "You took too long. I'm impatient, don't make me wait") return # If we have gotten here, based on our previous check, we know that the content provided is a valid role. # Due to that, no need for any error checking here role = discord.utils.get(server_roles, name=msg.content) await role.delete() await ctx.send( "I have just removed the role {} from this server".format( role.name))