mirror of
https://github.com/brandons209/Red-bot-Cogs.git
synced 2024-04-29 18:13:31 +12:00
446 lines
17 KiB
Python
446 lines
17 KiB
Python
from textwrap import shorten
|
|
|
|
import discord
|
|
from redbot.core import checks
|
|
from redbot.core import commands
|
|
from redbot.core.config import Config
|
|
from redbot.core.i18n import Translator, cog_i18n
|
|
from redbot.core.utils import chat_formatting as chat
|
|
from redbot.core.utils.menus import menu, DEFAULT_CONTROLS
|
|
from redbot.core.utils.mod import get_audit_reason
|
|
from tabulate import tabulate
|
|
from typing import Literal
|
|
import asyncio
|
|
|
|
_ = Translator("PersonalRoles", __file__)
|
|
|
|
|
|
async def has_assigned_role(ctx):
|
|
auto_roles = set(await ctx.cog.config.guild(ctx.guild).auto_roles())
|
|
user_roles = {r.id for r in ctx.author.roles}
|
|
user_roles &= auto_roles
|
|
|
|
return len(user_roles) > 0 or ctx.guild.get_role(await ctx.cog.config.member(ctx.author).role())
|
|
|
|
|
|
@cog_i18n(_)
|
|
class PersonalRoles(commands.Cog):
|
|
"""Assign and edit personal roles"""
|
|
|
|
__version__ = "2.0.4"
|
|
|
|
# noinspection PyMissingConstructor
|
|
def __init__(self, bot: commands.Bot):
|
|
self.bot = bot
|
|
self.config = Config.get_conf(self, identifier=0x3D86BBD3E2B744AE8AA8B5D986EB4DD8, force_registration=True)
|
|
default_member = {"role": None, "auto_role": False}
|
|
default_guild = {"blacklist": [], "auto_roles": [], "position_role": None}
|
|
self.config.register_member(**default_member)
|
|
self.config.register_guild(**default_guild)
|
|
|
|
@commands.group()
|
|
@commands.guild_only()
|
|
@checks.bot_has_permissions(manage_roles=True)
|
|
async def myrole(self, ctx):
|
|
"""Control of personal role"""
|
|
pass
|
|
|
|
@myrole.command()
|
|
@checks.admin_or_permissions(manage_roles=True)
|
|
async def assign(self, ctx, user: discord.Member, *, role: discord.Role):
|
|
"""Assign personal role to someone"""
|
|
await self.config.member(user).role.set(role.id)
|
|
await ctx.send(
|
|
_("Ok. I just assigned {user.name} ({user.id}) to role {role.name} ({role.id}).").format(
|
|
user=user, role=role
|
|
)
|
|
)
|
|
|
|
@myrole.command()
|
|
@checks.admin_or_permissions(manage_roles=True)
|
|
async def unassign(self, ctx, *, user: discord.Member):
|
|
"""Unassign personal role from someone"""
|
|
|
|
role = await self.config.member(user).role()
|
|
await self.config.member(user).role.clear()
|
|
|
|
role = ctx.guild.get_role(role)
|
|
if role:
|
|
try:
|
|
await role.delete()
|
|
except:
|
|
await ctx.send(
|
|
_(
|
|
"Ok. I just unassigned {user.name} ({user.id}) from their personal role.\nHowever, I could not delete the role."
|
|
).format(user=user)
|
|
)
|
|
else:
|
|
await ctx.send("User didn't have a role or it wasn't found. Role unassigned anyway to make sure.")
|
|
return
|
|
|
|
await ctx.send(
|
|
_("Ok. I just unassigned {user.name} ({user.id}) from their personal role and deleted the role.").format(
|
|
user=user
|
|
)
|
|
)
|
|
|
|
@myrole.command(name="list")
|
|
@checks.admin_or_permissions(manage_roles=True)
|
|
async def mr_list(self, ctx):
|
|
"""Assigned roles list"""
|
|
members_data = await self.config.all_members(ctx.guild)
|
|
if not members_data:
|
|
await ctx.send(chat.info(_("There is no assigned personal roles on this server")))
|
|
return
|
|
assigned_roles = []
|
|
for member, data in members_data.items():
|
|
if not data["role"]:
|
|
continue
|
|
dic = {
|
|
_("User"): ctx.guild.get_member(member) or f"[X] {member}",
|
|
_("Role"): shorten(
|
|
str(ctx.guild.get_role(data["role"]) or "[X] {}".format(data["role"])),
|
|
32,
|
|
placeholder="…",
|
|
),
|
|
}
|
|
assigned_roles.append(dic)
|
|
pages = list(chat.pagify(tabulate(assigned_roles, headers="keys", tablefmt="orgtbl")))
|
|
pages = [chat.box(page) for page in pages]
|
|
await menu(ctx, pages, DEFAULT_CONTROLS)
|
|
|
|
@myrole.group(name="auto")
|
|
@checks.admin_or_permissions(manage_roles=True)
|
|
async def myrole_auto(self, ctx):
|
|
"""
|
|
Manage Auto role creation settings
|
|
"""
|
|
pass
|
|
|
|
@myrole_auto.command(name="roles")
|
|
async def myrole_auto_autoroles(self, ctx, *, role_list: str = None):
|
|
"""
|
|
Set roles that a user must have to allow auto creation of assigned roles
|
|
by the bot.
|
|
|
|
If user has any one of the roles in the list, an assigned role will
|
|
be automatically created for them and assigned.
|
|
|
|
Role list should be comma seperate list of role names and/or IDs.
|
|
Roles in role list already set for autorole will be removed, and roles
|
|
not set for autrole will be added.
|
|
"""
|
|
guild = ctx.guild
|
|
|
|
if not role_list:
|
|
curr = await self.config.guild(guild).auto_roles()
|
|
roles = [guild.get_role(r) for r in curr]
|
|
names = [r.name for r in roles if r is not None]
|
|
msg = ""
|
|
if None in curr:
|
|
msg += chat.warning("Some auto roles cannot be found, they have been removed from the list.\n")
|
|
for i, role in enumerate(roles):
|
|
if role is None:
|
|
del curr[i]
|
|
await self.config.guild(guild).auto_roles.set(curr)
|
|
|
|
await ctx.send(f"Current auto roles: {chat.humanize_list(names) if names else chat.bold('None')}")
|
|
return
|
|
|
|
role_list = role_list.strip().split(",")
|
|
role_list = [r.strip() for r in role_list]
|
|
not_found = set()
|
|
found = set()
|
|
added = set()
|
|
removed = set()
|
|
for role_name in role_list:
|
|
role = self.role_from_string(guild, role_name)
|
|
|
|
if role is None:
|
|
not_found.add(role_name)
|
|
continue
|
|
|
|
found.add(role)
|
|
|
|
if not_found:
|
|
await ctx.send(
|
|
chat.warning(
|
|
"These roles weren't found, please try again: {}".format(chat.humanize_list(list(not_found)))
|
|
)
|
|
)
|
|
return
|
|
|
|
async with self.config.guild(guild).auto_roles() as auto_roles:
|
|
for role in found:
|
|
if role.id in auto_roles:
|
|
auto_roles.remove(role.id)
|
|
removed.add(role.name)
|
|
else:
|
|
auto_roles.append(role.id)
|
|
added.add(role.name)
|
|
|
|
msg = ""
|
|
if added:
|
|
msg += "Added: {}\n".format(chat.humanize_list(list(added)))
|
|
if removed:
|
|
msg += "Removed: {}".format(chat.humanize_list(list(removed)))
|
|
|
|
await ctx.send(msg)
|
|
|
|
@myrole_auto.command(name="pos")
|
|
async def myrole_auto_autopos(self, ctx, *, role_pos: discord.Role):
|
|
"""
|
|
Set position of where new roles are auto created.
|
|
|
|
New roles will be created under this role.
|
|
Cannot be higher than the bot's highest role
|
|
"""
|
|
if role_pos > ctx.guild.me.top_role:
|
|
await ctx.send("The role must be under my highest role.")
|
|
return
|
|
|
|
await self.config.guild(ctx.guild).position_role.set(role_pos.id)
|
|
await ctx.tick()
|
|
|
|
@myrole.group()
|
|
@commands.guild_only()
|
|
@checks.admin_or_permissions(manage_roles=True)
|
|
async def blacklist(self, ctx):
|
|
"""Manage blacklisted names"""
|
|
pass
|
|
|
|
@blacklist.command()
|
|
@checks.admin_or_permissions(manage_roles=True)
|
|
async def add(self, ctx, *, rolename: str):
|
|
"""Add rolename to blacklist
|
|
Members will be not able to change name of role to blacklisted names"""
|
|
rolename = rolename.casefold()
|
|
async with self.config.guild(ctx.guild).blacklist() as blacklist:
|
|
if rolename in blacklist:
|
|
await ctx.send(chat.error(_("`{}` is already in blacklist").format(rolename)))
|
|
else:
|
|
blacklist.append(rolename)
|
|
await ctx.send(chat.info(_("Added `{}` to blacklisted roles list").format(rolename)))
|
|
|
|
@blacklist.command()
|
|
@checks.admin_or_permissions(manage_roles=True)
|
|
async def remove(self, ctx, *, rolename: str):
|
|
"""Remove rolename from blacklist"""
|
|
rolename = rolename.casefold()
|
|
async with self.config.guild(ctx.guild).blacklist() as blacklist:
|
|
if rolename not in blacklist:
|
|
await ctx.send(chat.error(_("`{}` is not blacklisted").format(rolename)))
|
|
else:
|
|
blacklist.remove(rolename)
|
|
await ctx.send(chat.info(_("Removed `{}` from blacklisted roles list").format(rolename)))
|
|
|
|
@blacklist.command(name="list")
|
|
@checks.admin_or_permissions(manage_roles=True)
|
|
async def bl_list(self, ctx):
|
|
"""List of blacklisted role names"""
|
|
blacklist = await self.config.guild(ctx.guild).blacklist()
|
|
pages = [chat.box(page) for page in chat.pagify("\n".join(blacklist))]
|
|
if pages:
|
|
await menu(ctx, pages, DEFAULT_CONTROLS)
|
|
else:
|
|
await ctx.send(chat.info(_("There is no blacklisted roles")))
|
|
|
|
@commands.cooldown(1, 30, commands.BucketType.user)
|
|
@myrole.command(aliases=["color"])
|
|
@commands.guild_only()
|
|
@commands.check(has_assigned_role)
|
|
async def colour(self, ctx, *, colour: discord.Colour = discord.Colour.default()):
|
|
"""Change color of personal role"""
|
|
|
|
role = await self.config.member(ctx.author).role()
|
|
role = ctx.guild.get_role(role)
|
|
if not role:
|
|
await ctx.send(chat.warning(f"Please create your role using `{ctx.prefix}myrole create`!"))
|
|
return
|
|
|
|
try:
|
|
await role.edit(colour=colour, reason=get_audit_reason(ctx.author, _("Personal Role")))
|
|
except discord.Forbidden:
|
|
ctx.command.reset_cooldown(ctx)
|
|
await ctx.send(
|
|
chat.error(
|
|
_(
|
|
"Unable to edit role.\n"
|
|
'Role must be lower than my top role and I must have permission "Manage Roles"'
|
|
)
|
|
)
|
|
)
|
|
except discord.HTTPException as e:
|
|
ctx.command.reset_cooldown(ctx)
|
|
await ctx.send(chat.error(_("Unable to edit role: {}").format(e)))
|
|
else:
|
|
if not colour.value:
|
|
await ctx.send(_("Reset {user}'s personal role color").format(user=ctx.message.author.name))
|
|
else:
|
|
await ctx.send(
|
|
_("Changed color of {user}'s personal role to {color}").format(
|
|
user=ctx.message.author.name, color=colour
|
|
)
|
|
)
|
|
|
|
@commands.cooldown(1, 30, commands.BucketType.user)
|
|
@myrole.command()
|
|
@commands.guild_only()
|
|
@commands.check(has_assigned_role)
|
|
async def name(self, ctx, *, name: str):
|
|
"""Change name of personal role
|
|
You can't use blacklisted names
|
|
Names must be 30 characters or less"""
|
|
role = await self.config.member(ctx.author).role()
|
|
role = ctx.guild.get_role(role)
|
|
if not role:
|
|
await ctx.send(chat.warning(f"Please create your role using `{ctx.prefix}myrole create`!"))
|
|
return
|
|
|
|
name = name[:30]
|
|
if name.casefold() in await self.config.guild(ctx.guild).blacklist():
|
|
await ctx.send(chat.error(_("This rolename is blacklisted.")))
|
|
return
|
|
try:
|
|
await role.edit(name=name, reason=get_audit_reason(ctx.author, _("Personal Role")))
|
|
except discord.Forbidden:
|
|
ctx.command.reset_cooldown(ctx)
|
|
await ctx.send(
|
|
chat.error(
|
|
_(
|
|
"Unable to edit role.\n"
|
|
'Role must be lower than my top role and i must have permission "Manage Roles"'
|
|
)
|
|
)
|
|
)
|
|
except discord.HTTPException as e:
|
|
ctx.command.reset_cooldown(ctx)
|
|
await ctx.send(chat.error(_("Unable to edit role: {}").format(e)))
|
|
else:
|
|
await ctx.send(
|
|
_("Changed name of {user}'s personal role to {name}").format(user=ctx.message.author.name, name=name)
|
|
)
|
|
|
|
@commands.cooldown(1, 30, commands.BucketType.user)
|
|
@myrole.command()
|
|
@commands.guild_only()
|
|
@commands.check(has_assigned_role)
|
|
async def create(self, ctx):
|
|
"""Create personal role if you don't have one already"""
|
|
|
|
role = await self.config.member(ctx.author).role()
|
|
role = ctx.guild.get_role(role)
|
|
|
|
if not role:
|
|
pos = await self.config.guild(ctx.guild).position_role()
|
|
pos = ctx.guild.get_role(pos)
|
|
pos = pos.position if pos else 1
|
|
|
|
try:
|
|
role = await ctx.guild.create_role(
|
|
name=str(ctx.author), colour=ctx.author.colour, reason=_("Personal role")
|
|
)
|
|
await asyncio.sleep(0.3)
|
|
await role.edit(position=pos)
|
|
await asyncio.sleep(0.3)
|
|
await ctx.author.add_roles(role, reason=_("Personal Roles"))
|
|
await self.config.member(ctx.author).role.set(role.id)
|
|
await self.config.member(ctx.author).auto_role.set(True)
|
|
except:
|
|
await ctx.send(chat.warning("Could not create your personal role, please contact an admin."))
|
|
return
|
|
|
|
await ctx.send(
|
|
f"Role created! You can edit it using `{ctx.prefix}myrole name` and `{ctx.prefix}myrole colour` commands."
|
|
)
|
|
else:
|
|
await ctx.send(chat.warning("You already have a personal role!"))
|
|
|
|
### Helper methods
|
|
@staticmethod
|
|
def role_from_string(guild: discord.Guild, role_name: str):
|
|
|
|
role = discord.utils.find(lambda r: r.name == role_name, guild.roles)
|
|
# if couldnt find by role name, try to find by role id
|
|
if role is None:
|
|
role = discord.utils.find(lambda r: r.id == role_name, guild.roles)
|
|
|
|
return role
|
|
|
|
### Listeners
|
|
@commands.Cog.listener("on_member_join")
|
|
async def role_persistance(self, member):
|
|
"""Automatically give already assigned roles on join"""
|
|
if await self.bot.cog_disabled_in_guild(self, member.guild):
|
|
return
|
|
role = await self.config.member(member).role()
|
|
if role:
|
|
role = member.guild.get_role(role)
|
|
if role and member:
|
|
try:
|
|
await member.add_roles(role, reason=_("Personal Role"))
|
|
except discord.Forbidden:
|
|
pass
|
|
|
|
@commands.Cog.listener("on_member_remove")
|
|
async def remove_role(self, member):
|
|
"""Delete personal role if member leaves."""
|
|
if await self.bot.cog_disabled_in_guild(self, member.guild):
|
|
return
|
|
role = await self.config.member(member).role()
|
|
auto = await self.config.member(member).auto_role()
|
|
role = member.guild.get_role(role)
|
|
if auto:
|
|
await self.config.member(member).role.clear()
|
|
await self.config.member(member).auto_role.clear()
|
|
try:
|
|
await role.delete()
|
|
except:
|
|
pass
|
|
|
|
@commands.Cog.listener("on_member_update")
|
|
async def modify_roles(self, before, after):
|
|
"""Delete personal role if member looses their auto role or looses their personal role"""
|
|
if await self.bot.cog_disabled_in_guild(self, after.guild):
|
|
return
|
|
role = await self.config.member(after).role()
|
|
role = before.guild.get_role(role)
|
|
if not role:
|
|
return
|
|
|
|
auto = await self.config.member(after).auto_role()
|
|
if not auto:
|
|
return
|
|
|
|
auto_roles = await self.config.guild(before.guild).auto_roles()
|
|
|
|
if before.roles != after.roles:
|
|
if role not in after.roles:
|
|
await self.config.member(after).role.clear()
|
|
await self.config.member(after).auto_role.clear()
|
|
try:
|
|
await role.delete()
|
|
except:
|
|
pass
|
|
else:
|
|
after_ids = [r.id for r in after.roles]
|
|
for m_role in after_ids:
|
|
if m_role in auto_roles:
|
|
return
|
|
# lost their auto role, remove personal role, delete, and clear their data.
|
|
await after.remove_roles(role, reason=_("Personal Roles"))
|
|
await self.config.member(after).role.clear()
|
|
await self.config.member(after).auto_role.clear()
|
|
try:
|
|
await role.delete()
|
|
except:
|
|
pass
|
|
|
|
async def red_delete_data_for_user(
|
|
self,
|
|
*,
|
|
requester: Literal["discord_deleted_user", "owner", "user", "user_strict"],
|
|
user_id: int,
|
|
):
|
|
pass
|