async def check_role_status(self, ctx, role_name):
role = discord.utils.get(ctx.guild.roles, name=role_name)
if not role:
try:
if role_name == 'Jailed':
# Creates the role for Jailed system
perms = Permissions(send_messages=False, read_messages=True, view_channel=True,
read_message_history=True)
await ctx.guild.create_role(name='Jailed', permissions=perms, hoist=True, colour=Colour.red(),
mentionable=True)
elif role_name == 'Visitor':
# Creates the role for verified users
perms = Permissions(send_messages=False, read_messages=True, view_channel=True,
read_message_history=True)
await ctx.guild.create_role(name='Visitor', permissions=perms, colour=Colour.green(),
mentionable=True)
elif role_name == 'Unverified':
# Creates role for un-verified users
perms = Permissions(send_messages=False, read_messages=True, view_channel=True, add_reactions=True)
await ctx.guild.create_role(name='Unverified', permissions=perms, colour=Colour.magenta(),
mentionable=True)
return True
except discord.errors.Forbidden:
await ctx.channel.send(content='Bot does not have permission to create roles')
return False
else:
return True
async def roles_clone(self, ctx: Context, *, role: Role):
if not ctx.me.guild_permissions.manage_roles:
raise CommandError(t.clone_no_permission)
cloned_permissions = role.permissions.value & ctx.me.guild_permissions.value
missing_permissions = "\n".join(
f":small_blue_diamond: `{permission}`"
for permission, value in Permissions(
role.permissions.value & ~ctx.me.guild_permissions.value)
if value)
await ctx.guild.create_role(
name=role.name,
color=role.color,
permissions=Permissions(cloned_permissions),
hoist=role.hoist,
mentionable=role.mentionable,
)
if missing_permissions:
await send_long_embed(
ctx,
Embed(
title=t.failed_to_clone_role_permissions,
description=missing_permissions,
color=Colors.MissingPermissions,
),
paginate=True,
)
await ctx.message.add_reaction(name_to_emoji["white_check_mark"])
class RoleCollectionClass(AbstractRoleCollection):
"""Enum of roles in the correct order (last ones have a lower position)"""
# Bot role
BOT = RoleDescription(
name="Bot",
permissions=Permissions(8), # admin right
colour=Colour.green(),
mentionable=True,
)
# Developer
DEV = RoleDescription(
name="Admin",
permissions=Permissions.all(), # all rights
colour=Colour.dark_red(),
)
# Game master
MASTER = RoleDescription(
name="Game master",
permissions=Permissions(2147483127), # all rights except admin
colour=Colour.dark_red(),
mentionable=True,
)
# Visitor, base role
VISITOR = RoleDescription(
name="Player",
permissions=Permissions(68224000), # change nickname, view channels, read message history, connect
colour=Colour.red(),
)
DEFAULT = DefaultRoleDescription(permissions=Permissions(use_voice_activation=True))
def get_box_member_roles(guild: discord.Guild, box_id: int) -> dict:
with c:
cursor = c.execute('''
SELECT * FROM box_member_roles WHERE box_id = ?
''', (box_id,))
previous_member_roles = dict()
for row in cursor.fetchall():
folder_id, channel_id, allow_int, deny_int = row
channel = guild.get_channel(channel_id)
if channel is not None:
previous_member_roles[channel] = (Permissions(allow_int), Permissions(deny_int))
return previous_member_roles
async def initialize_roles(self, ctx: commands.Context, *argv):
# if not await self.canUseCommand(ctx):
# return
msg = await ctx.channel.send('初始化身分組: KFP 預設...')
for data in ROLE_DATA:
for role_dic in data:
role_matcher = role_dic['matcher']
role_name = role_dic['name']
roles: Role = self.findRole(ctx.guild.roles, role_matcher)
if len(roles) > 0:
await msg.edit(content=str(msg.content) +
"\n{}已經存在... 合併現有資料".format(roles[0].name))
else:
await msg.edit(content=str(msg.content) +
"\n創建身分組{}... ".format(role_name))
role = await ctx.guild.create_role(
name=role_name,
permissions=Permissions(permissions=0),
colour=Color(role_dic['color']),
mentionable=False,
hoist=False)
await msg.edit(content=str(msg.content) +
"完成".format(role_name))
if len(roles) > 0:
role = roles[0]
kfpRole: KfpRole = RoleUtil.updateRole(ctx.guild.id, role.id,
role.name, role.color,
role_dic["category"])
RoleUtil.updateKfpRoleLevel(kfpRole, role_dic['level'])
await ctx.channel.send("身分組初始化完成.")
async def on_ready():
app_info = await bot.application_info()
bot.owner_id = app_info.owner.id
prefix = bot.guilds_.default['prefix']
await bot.change_presence(activity=Game(name=f'{prefix}help'))
ccp.ready(f'Logged in as {bot.user.name}')
ccp.ready(f'ID: {bot.user.id}')
bot.url = oauth_url(client_id=bot.user.id,
permissions=Permissions(permissions=8))
ccp.ready(f'URL: \u001b[1m\u001b[34m{bot.url}\u001b[0m')
for guild in bot.guilds:
if guild.id not in bot.guilds_.keys():
await bot.guilds_.insert(guild.id)
if guild.system_channel:
await bot.guilds_.update(guild.id, 'system_channel',
guild.system_channel.id)
if guild.me.guild_permissions.manage_guild:
bot.invites_[guild.id] = await guild.invites()
if 'VANITY_URL' in guild.features:
vanity = await guild.vanity_invite()
bot.invites_[guild.id].append(vanity)
async def invite(self, ctx: Context) -> None:
"""Gives the invite link of this bot."""
url = oauth_url(self.bot.user.id, Permissions(3525696))
embed = DefaultEmbed(ctx,
description=markdown_link("invite_link", url))
await ctx.send(embed=embed)
async def invite(self, ctx):
# This tells the user that the command they are trying to use isn't translated yet.
user_language = {
"lang":
self.bot.user_data["UserData"][str(
ctx.author.id)]["Settings"]["Language"]
}
if ctx.command.qualified_name not in localization[
user_language["lang"]]:
class Continue(ui.View):
def __init__(self):
super().__init__(timeout=15)
self.value = None
@ui.button(label=localization[user_language["lang"]]
["language_not_available"]["button"],
style=ButtonStyle.primary,
emoji="▶️",
custom_id="continue")
async def continue_button(self, button, interaction):
if interaction.user.id == ctx.author.id:
user_language["lang"] = "eng"
await self.message.delete()
self.value = True
self.stop()
async def on_timeout():
await self.message.delete()
self.stop()
emb = Embed(description=localization[user_language["lang"]]
["language_not_available"]["description"]).set_footer(
text=localization[user_language["lang"]]
["language_not_available"]["footer"])
view = Continue()
view.message = await ctx.send(embed=emb, view=view)
await view.wait()
if not view.value:
return
user_language = user_language["lang"]
app_info: AppInfo = await self.bot.application_info()
permissions = Permissions()
permissions.update(send_messages=True,
embed_links=True,
add_reactions=True,
manage_messages=True,
manage_roles=True,
manage_channels=True,
use_application_commands=True)
emb = Embed(
title=localization[user_language]["invite"]["title"],
description=localization[user_language]["invite"]["description"].
format(url=oauth_url(app_info.id, permissions=permissions)),
).set_author(name=self.bot.user.name,
icon_url=self.bot.user.avatar.url).set_footer(
text=localization[user_language]["invite"]["footer"])
await ctx.send(embed=emb)
async def rmpermission(self, ctx, role: discord.Role, single_permission):
if single_permission in self.config_permissions:
perms = Permissions()
eval("perms.update(" + str(single_permission) + " = False)")
await role.edit(permissions=perms)
await ctx.send("Permission table altered.")
else:
await ctx.send("Permission not exists.")
async def create_guild_member_role(self, name: str, reason: str) -> Role:
return await self.guild.create_role(
name=name,
permissions=Permissions(
int(os.environ['DEFAULT_MEMBER_PERMISSIONS'])),
hoist=True,
mentionable=True,
reason=reason)
async def invite(ctx: Interaction):
"""Give an invite link for this bot"""
await ctx.response.send_message(
oauth_url(
app.id,
permissions=Permissions(manage_roles=True),
scopes=["bot", "applications.commands"]),
ephemeral=True)
def test_role_info_command(cog, ctx):
dummy_role = MagicMock(spec=Role)
dummy_role.name = "Dummy"
dummy_role.colour = Colour.blurple()
dummy_role.id = 112233445566778899
dummy_role.position = 10
dummy_role.permissions = Permissions(0)
dummy_role.members = [ctx.author]
admin_role = MagicMock(spec=Role)
admin_role.name = "Admin"
admin_role.colour = Colour.red()
admin_role.id = 998877665544332211
admin_role.position = 3
admin_role.permissions = Permissions(0)
admin_role.members = [ctx.author]
ctx.guild.roles = [dummy_role, admin_role]
cog.role_info.can_run = AsyncMock()
cog.role_info.can_run.return_value = True
coroutine = cog.role_info.callback(cog, ctx, dummy_role, admin_role)
assert asyncio.run(coroutine) is None
assert ctx.send.call_count == 2
(_, dummy_kwargs), (_, admin_kwargs) = ctx.send.call_args_list
dummy_embed = dummy_kwargs["embed"]
admin_embed = admin_kwargs["embed"]
assert dummy_embed.title == "Dummy info"
assert dummy_embed.colour == Colour.blurple()
assert dummy_embed.fields[0].value == str(dummy_role.id)
assert dummy_embed.fields[1].value == f"#{dummy_role.colour.value:0>6x}"
assert dummy_embed.fields[2].value == "0.63 0.48 218"
assert dummy_embed.fields[3].value == "1"
assert dummy_embed.fields[4].value == "10"
assert dummy_embed.fields[5].value == "0"
assert admin_embed.title == "Admin info"
assert admin_embed.colour == Colour.red()
async def invite(self, ctx):
""" Get a URL to invite the bot to your own server! """
oauth_url = discord.utils.oauth_url(
client_id=self.client.client_id,
permissions=Permissions(permissions=1074130006),
scopes=('bot', 'applications.commands'))
await ctx.send(
"Click the link below to add me to your server! {}".format(
oauth_url))
async def addpermission(self, ctx, role: discord.Role, single_permission):
if single_permission in self.config_permissions:
perms = Permissions()
eval("perms.update(" + str(single_permission) + " = True)")
await role.edit(permissions=perms)
#print(getattr(role.permissions,"send_messages"))
await ctx.send("Permission table altered.")
else:
await ctx.send("Permission not exists.")
async def invite(self, ctx, *args):
"""
Return an OAuth link to add this bot to a server
`-invite`
"""
await ctx.channel.send(
embed=await Macro.send("Add me to your server [here]({})".format(
oauth_url(self.bot.user.id,
permissions=Permissions(permissions=268443702)))))
def invite_url(self, p: int = 335932480, guildid: int = None) -> str:
"""Generate an invite URL for the bot
using the permsisions provided"""
url = utils.oauth_url(
self.user.id,
permissions=Permissions(p),
redirect_uri=self.guild_invite_url,
)
return f"{url}&guild_id={guildid}" if guildid else url
async def invite(self):
"""Gives out an invite for the bot"""
permissions = Permissions()
for i in self.requiredPerms:
setattr(permissions, i, True)
await self.say(
f"<{utils.oauth_url('410926210017656852', permissions=permissions)}>"
)
def __init__(self,
name="new_role",
permissions=None,
colour=None,
hoist=False,
mentionable=False,
reason=None,
position=1,
**kwargs):
super().__init__(**kwargs)
self.name: str = name
if isinstance(permissions, PermissionDescription):
permissions = Permissions(**permissions.to_dict())
self.permissions: Permissions = permissions or Permissions()
self.colour: Colour = colour or Colour.default()
self.hoist: bool = hoist
self.mentionable: bool = mentionable
self.reason: str = reason
self.position: int = position # only when editing
def __init__(self, data: dict):
self.data = data
self.id = data.get('id')
self.name = data.get('name')
self.icon_hash = data.get('icon')
self.owner = data.get('owner')
self.permissions = Permissions(data.get('permissions'))
self.features = data.get('features')
self.fetch_time = self.data.get('fetch_time') or time.time()
async def on_connect(self):
permissions = Permissions(
add_reactions=True,
manage_messages=True,
read_message_history=True,
read_messages=True,
send_messages=True,
)
url = oauth_url(self.bot.user.id, permissions)
logger.info('Invite URL: %s', url)
async def invite(message, client, color):
"""Return the bot's invite url."""
async with message.channel.typing():
await sleep(1)
await message.channel.send(
embed=Embed(title="**C O N V I T E**!",
url=oauth_url(client.user.id, Permissions(10860)),
color=color).set_thumbnail(url=client.user.avatar_url).
add_field(name=f"👤 **DE**: *{client.user.name}*",
value="🗓️ **Dia**: *HOJE*\n"
"🕛 **Horário**: *Ja ja*\n"
f"🏠 **Local**: *No seu servidor*").set_footer(
text="Conto com você!"))
async def on_message(message):
if not message.content.startswith('!'):
return
args = message.content.split(' ')
cmd = args.pop(0).lower().strip('!')
cmds = await bot.db.fetchall(
'''
SELECT cmd, response, enabled, roles, permissions
FROM discord_commands
WHERE server_id=%s AND cmd=%s AND enabled=1
''', (message.guild.id, cmd))
if not cmds:
return
for cmd in cmds:
try:
roles = utils.json_loads(cmd['roles']) if cmd['roles'] else []
if roles:
for r in message.author.roles:
if r.id in roles:
break
else:
return
if cmd['permissions']:
if not message.author.guild_permissions.is_superset(
Permissions(int(cmd['permissions'], 16))):
return
msg = await var_filler.fill_message(
cmd['response'],
message=message,
args=args,
bot=bot,
cmd=cmd['cmd'],
)
await message.channel.send(msg)
except var_filler.Send_error as e:
await message.channel.send('{}, {}'.format(message.author.mention,
str(e)))
except var_filler.Send as e:
await message.channel.send('{}, {}'.format(message.author.mention,
str(e)))
except var_filler.Send_break:
pass
except Forbidden as e:
await message.channel.send('{}, {}'.format(message.author.mention,
e.text))
except:
logging.exception('command on_message')
def invite_link(self):
# https://discordapp.com/oauth2/authorize?client_id=468281173072805889&scope=bot&permissions=35840&guild_id=208895639164026880
if self._invite_link: return self._invite_link
permissions = Permissions()
permissions.read_messages = True
permissions.send_messages = True
permissions.embed_links = True
permissions.attach_files = True
self._invite_link = 'https://discordapp.com/oauth2/authorize?' + urlencode({
'client_id': self.user.id,
'scope': 'bot',
'permissions': permissions.value
})
return self.invite_link
def permissions(perms) -> str:
def append(perm):
return f'\n\t- `{perm}`'
value = ''
permission = Permissions(perms)
if permission.administrator:
value += append('administrator')
return value
if permission.manage_server:
value += append('manage_server')
if permission.manage_channels:
value += append('manage_channels')
if permission.manage_messages:
value += append('manage_messages')
if permission.manage_roles:
value += append('manage_roles')
if permission.manage_emojis:
value += append('manage_emotes')
if permission.manage_webhooks:
value += append('manage_webhooks')
if permission.view_audit_logs:
value += append('view_audit_logs')
if permission.ban_members:
value += append('ban_members')
if permission.kick_members:
value += append('kick_members')
if permission.create_instant_invite:
value += append('create_instant_invite')
if permission.change_nickname:
value += append('change_nickname')
if permission.manage_nicknames:
value += append('manage_nicknames')
if permission.read_messages:
value += append('read_messages')
if permission.read_message_history:
value += append('read_message_history')
if permission.send_messages:
value += append('send_messages')
if permission.mention_everyone:
value += append('mention_everyone')
if permission.add_reactions:
value += append('add_reactions')
if permission.embed_links:
value += append('embed_links')
if permission.attach_files:
value += append('attach_files')
if permission.external_emojis:
value += append('external_emotes')
return value
def process_guilds(self, guilds_payload: dict) -> None:
"""
Processes the user's guilds on initiation.
"""
self.guilds_mapping = {}
for guild_info in guilds_payload:
# Only store guilds where the user has Manage Guild permissions. (this is also the permission required to change settings)
perms = Permissions(permissions=guild_info["permissions"])
if perms.manage_guild:
self.guilds_mapping[int(guild_info["id"])] = Guild(guild_info)
self.guilds = sorted(self.guilds_mapping.values(),
key=lambda g: g.bot_guild,
reverse=True)
async def convert(self, ctx, argument):
if self.humanize:
argument = argument.replace('server', 'guild')
permissions = Permissions()
for key in argument.split(','):
if not hasattr(permissions, key):
# TODO: clean key
raise BadArgument(f'invalid permission key: {key}')
# set permission
setattr(permissions, key.strip(), True)
return permissions
def get_guild_list(self,headers,base_url):
guild_response = requests.get(url = (base_url+"/guilds"),headers = headers)
guild_json = guild_response.json()
owned_guild_list = []
'''
iterate through all the guilds
if admin, manage guild or owner, add to list
'''
for guild in guild_json:
permission = Permissions(guild['permissions'])#create permission object
if((guild["owner"] == True)or(permission.manage_guild)or(permission.administrator)):
guild_object = Guild(guild)
owned_guild_list.append(guild_object)
return owned_guild_list
def __init__(self) -> None:
self.permissions = Permissions(
view_channel=True,
send_messages=True,
manage_messages=True,
embed_links=True,
read_message_history=True,
manage_webhooks=True,
add_reactions=True,
)
super().__init__(command_prefix=when_mentioned_or("?"))
for cog in INITIAL_COGS:
try:
self.load_extension(cog)
except:
traceback.print_exc()
def invite_link(self):
'''The invite link for the bot'''
if self._invite_link: return self._invite_link
permissions = Permissions()
permissions.read_messages = True
permissions.send_messages = True
permissions.embed_links = True
permissions.attach_files = True
self._invite_link = 'https://discordapp.com/oauth2/authorize?' + urlencode(
{
'client_id': self.config['oauth']['client_id'],
'scope': 'bot',
'permissions': permissions.value
})
return self._invite_link
async def links(self, ctx):
permission_names = ("read_messages", "send_messages",
"manage_messages", "embed_links", "attach_files",
"read_message_history", "add_reactions",
"use_external_emojis"
"mute_members", "deafen_members", "move_members")
perms = Permissions()
perms.update(**dict.fromkeys(permission_names, True))
embed = Embed(
description=
f"""[**Bot Invite Link**]({oauth_url(self.bot.user.id, perms)})
[**Home Server**](https://discord.gg/dWX6fpGUK9)
[**Github Repo**](https://github.com/Sirspam/Coordy-McCoordFace)\n
I hope you're having a good day :)""",
color=0x00A9E0)
embed.set_thumbnail(
url="https://cdn.discordapp.com/emojis/787809230639202354.png?v=1")
await ctx.reply(embed=embed)