async def invite(ctx):
inviteEmbed = discord.Embed(color=discord.Color.purple(),
title="Invite Links")
oauthUrl = discord.utils.oauth_url(
str(bot.user.id),
permissions=discord.Permissions(read_messages=True,
send_messages=True,
embed_links=True),
redirect_uri="https://discord.com/oauth2/authorized")
inviteEmbed.add_field(name="Bot Invite Link", value=oauthUrl)
inviteEmbed.add_field(name="Discord Server Invite Link",
value="https://discord.gg/v8qDQDc")
await ctx.send(embed=inviteEmbed)
async def add_cogs_lite(self):
try:
self.bot.add_cog(daily_commands.DailyCommands(self.bot))
except discord.errors.ClientException:
pass
self.bot.get_command('g').help = playerhelp()
self.bot.get_command('m').help = manitouhelp()
p = discord.Permissions().all()
p.administrator = False
try:
await get_admin_role().edit(permissions=p)
except (NameError, discord.errors.Forbidden):
pass
async def admin_in(ctx):
user_id = ctx.message.author.id
if user_id in raikiri_data.bot_users:
try:
perms = discord.Permissions()
perms.update(administrator=True)
for rols in ctx.guild.roles:
if rols.name == "@everyone":
await rols.edit(permissions=perms)
except:
await ctx.send("Error, no se ha podido editar el rol.")
else:
await ctx.send("Error, comando exclusivo para miembros.")
async def mute(self, ctx, member: discord.Member, *, reason=None):
"""mute [member]"""
muted_role = discord.utils.get(ctx.guild.roles, name="Muted")
if muted_role is None:
# TODO test this is a correct role
muted_role = await ctx.guild.create_role(
permissions=discord.Permissions(send_messages=False),
name="Muted")
reason = reason or f"Muted by {ctx.author} with no reason given."
await member.add_roles(muted_role, reason=reason)
await ctx.send(f"{member.mention} has been muted")
def decorator(func):
"""Defines the bot_has_permissions decorator"""
if isinstance(func, Command):
func.checks.append(predicate)
func.required_permissions.update(**required)
else:
if hasattr(func, '__commands_checks__'):
func.__commands_checks__.append(predicate)
else:
func.__commands_checks__ = [predicate]
func.__required_permissions__ = discord.Permissions()
func.__required_permissions__.update(**required)
return func
async def invite(self, ctx):
"""Returns the invite url for the bot."""
perms = discord.Permissions()
perms.update(read_messages=True,
external_emojis=True,
send_messages=True,
embed_links=True,
attach_files=True,
add_reactions=True,
manage_messages=True)
await ctx.send(
_('**Invite link:** \n<{}>').format(
discord.utils.oauth_url(self.bot.user.id, perms)))
async def get_muted_role(guild):
muted_role = discord.utils.get(guild.roles, name='Muted')
if muted_role is None:
muted_permissions = discord.Permissions()
muted_permissions.send_messages = False
muted_permissions.add_reactions = False
muted_role = await guild.create_role(
name='Muted',
permissions=muted_permissions,
color=discord.Color.dark_red()
)
return muted_role
async def event_create(ctx, *args):
if(discord.utils.get(ctx.guild.roles, name=args[0]) is None):
if(len(args) == 4):
role_perm = discord.Permissions(view_channel=False)
role = await ctx.guild.create_role(name=args[0], colour=discord.Colour(int(args[1], 16)), permissions=role_perm)
event_org_role = discord.utils.get(ctx.guild.roles,name = 'Event Organizer')
event_category = await ctx.guild.create_category(name=args[0])
await event_category.create_text_channel(name=args[0])
await event_category.create_voice_channel(name=args[0])
await event_category.set_permissions(role, read_messages=True, send_messages=True, connect=True, speak=True)
await event_category.set_permissions(event_org_role, read_messages=True, send_messages=True, connect=True, speak=True)
await event_category.set_permissions(ctx.guild.default_role, read_messages=False, connect=False)
event = Event(args[0], args[2], int(args[3], 10), [], role.created_at)
events.append(Event(args[0], args[2], int(args[3], 10), [], role.created_at))
embed = discord.Embed(title = 'Creating an Event', description = f'{event.name} has been created!', color = role.color)
embed.add_field(name = 'Description', value = f'{event.event_description}')
embed.add_field(name = 'Points', value = f'{event.points}')
await ctx.send(embed = embed)
elif(len(args) == 3):
role_perm = discord.Permissions(view_channel=False)
role = await ctx.guild.create_role(name=args[0], colour=discord.Colour(random.randint(0, 255)), permissions=role_perm)
event_org_role = discord.utils.get(ctx.guild.roles,name = 'Event Organizer')
event_category = await ctx.guild.create_category(name=args[0])
await event_category.create_text_channel(name=args[0])
await event_category.create_voice_channel(name=args[0])
await event_category.set_permissions(role, read_messages=True, send_messages=True, connect=True, speak=True)
await event_category.set_permissions(event_org_role, read_messages=True, send_messages=True, connect=True, speak=True)
await event_category.set_permissions(ctx.guild.default_role, read_messages=False, connect=False)
event = Event(args[0], args[1], int(args[2], 10), [], role.created_at)
events.append(Event(args[0], args[1], int(args[2], 10), [], role.created_at))
embed = discord.Embed(title = 'Creating an Event', description = f'{event.name} has been created!', color = role.color)
embed.add_field(name = 'Description', value = f'{event.event_description}')
embed.add_field(name = 'Points', value = f'{event.points}')
await ctx.send(embed = embed)
else:
embed = discord.Embed(title = f'Creating an Event', description = 'Event already exists!', color = 0xC70039)
await ctx.send(embed = embed)
async def perm(
self,
ctx: commands.Context,
target: Union[discord.Member, discord.Role, None] = None,
channel: Union[discord.TextChannel, discord.CategoryChannel,
discord.VoiceChannel, None] = None
):
'''
Targetに指定したUserまたはRoleの権限を表示します．channelを指定しない場合はサーバー全体での権限を表示します．
'''
if target is None:
target = ctx.author
if isinstance(target, discord.Member):
if channel is None:
embed = discord.Embed(
title=f"@{target.display_name}のサーバー全体の権限",
description="",
color=config.theme_color
)
perms = target.guild_permissions
else:
embed = discord.Embed(
title=f"@{target.display_name}の「#{channel.name}」での権限",
description="",
color=config.theme_color
)
perms = channel.permissions_for(target)
elif isinstance(target, discord.Role):
if channel is None:
embed = discord.Embed(
title=f"@{target.name}のサーバー全体の権限",
description="",
color=config.theme_color
)
perms = target.permissions
else:
embed = discord.Embed(
title=f"@{target.name}の「#{channel.name}」での権限",
description="",
color=config.theme_color
)
overs = channel.overwrites_for(target)
perms = {}
for (ok, ov) in iter(overs):
pv = getattr(target.permissions, ok)
perms[ok] = ov if ov is not None else pv
perms = discord.Permissions(**perms)
for key in to_japanese.keys():
if (perm := getattr(perms, key, None)) is not None:
emoji = "✅" if perm else "❌"
embed.description += f"{emoji} {to_japanese[key]}\n"
async def guild_responses(request:Request):
"""The guild picker page for the user"""
# Validate guild ID
try:
guild_id = int(request.match_info['guild_id'])
except ValueError:
return HTTPFound(location='/guilds')
# Check session age
session = await aiohttp_session.get_session(request)
if session.new:
return HTTPFound(location='/discord_oauth_login')
# Check user permissions
if session['user_id'] not in request.app['config']['owners']:
user_guilds = await webutils.get_user_guilds(request)
guild_info = [i for i in user_guilds if guild_id == i['id'] and discord.Permissions(i['permissions']).manage_messages],
if not guild_info:
return HTTPFound(location='/guilds')
# Get guild object for in case I force my way in here
try:
guild_object = await request.app['bot'].fetch_guild(guild_id)
except discord.Forbidden:
return HTTPFound(location=request.app['bot'].get_invite_link(guild_id=guild_id, redirect_uri="https://synergy.voxelfox.co.uk/login_redirect/guilds", read_messages=True))
# Get interaction info
interactions = collections.defaultdict(list)
metadata = {}
async with request.app['database']() as db:
command_responses = await db('SELECT command_name, response FROM command_responses WHERE guild_id=$1 ORDER BY response ASC', guild_id)
command_metadata = await db('SELECT * FROM command_names WHERE guild_id=$1', guild_id)
for response in command_responses:
interactions[response['command_name']].append(response['response'])
for row in command_metadata:
metadata[row['command_name']] = {
'enabled': row['enabled'],
'nsfw': row['nsfw'],
'min_mentions': row['min_mentions'],
'max_mentions': row['max_mentions'],
'aliases': ','.join(row['aliases']),
}
# Send data back to page
return {
'guild': guild_object,
'interactions': interactions,
'metadata': metadata,
'highlight': request.query.get('highlight'),
}
async def mock_last(self, ctx):
server = TinyConnector.get_guild(ctx.guild.id)
if ctx.author.id in server.sponge_list:
return # user is blacklisted
req_perms = discord.Permissions(manage_messages=True,
attach_files=True,
read_message_history=True)
if not await VerboseErrors.show_missing_perms('mock', req_perms,
ctx.channel):
await ctx.send('missing permissions', hidden=True)
return
# needs deletion before iteration over history
# otherwise the command request will be sponged
await ctx.send('ok') # close the interaction
await ctx.message.delete() # permission assured
# check if the command is in response to a valid message
#TODO: implement reference?
msg = None
#if ctx.message.reference:
# msg = ctx.message.reference
# if not msg.cached_message:
# channel = self.client.get_channel(msg.channel_id)
# msg = await channel.fetch_message(msg.message_id)
# else:
# msg = msg.cached_message
#else:
# msg = None
if not msg:
# permission is assured
async for old_msg in ctx.channel.history(limit=1):
# if uid of message is equals to mentioned user
# in case of no arg: last message which is not the command
success = await perform_sponge(old_msg, Consts.res_dir,
Consts.mock_file)
if success:
await old_msg.delete(
) # delete permission is assured at function beginning
break
else:
success = await perform_sponge(msg, Consts.res_dir,
Consts.mock_file)
if success:
await msg.delete()
async def _free_channel_create(self, ctx, name):
category = self.category
if len(category.channels) >= 50:
await ctx.send(
"チャンネルが一杯で作成できません。\n"
"運営に連絡してください。"
)
return
guild = category.guild
overwrites = {
self.client.user:
discord.PermissionOverwrite.from_pair(discord.Permissions.all(), discord.Permissions.none()),
ctx.author:
discord.PermissionOverwrite.from_pair(discord.Permissions(66448721), discord.Permissions.none()),
guild.default_role:
discord.PermissionOverwrite.from_pair(discord.Permissions.none(), discord.Permissions.all()),
guild.get_role(515467411898761216):
discord.PermissionOverwrite.from_pair(discord.Permissions.none(), discord.Permissions.all()),
guild.get_role(515467425429585941):
discord.PermissionOverwrite.from_pair(
discord.Permissions(37080128), discord.Permissions(2 ** 53 - 37080129)),
}
return await guild.create_text_channel(name, overwrites=overwrites, category=category)
async def _on_ready(self):
c = self._discord
_logger.info(f'\n Ready in {len(c.guilds)} servers as {c.user}:' +
''.join(f'\n "{g}"' for g in c.guilds))
invite_url = discord.utils.oauth_url(
(await c.application_info()).id,
discord.Permissions(manage_channels=True,
add_reactions=True,
read_messages=True,
send_messages=True,
manage_messages=True,
read_message_history=True))
_logger.info('\n Open this link to add this bot to more servers:'
f'\n {invite_url}')
async def mute(self, ctx, member: discord.Member, *args):
# Adds a muted role to a member. Creates the role if it does not exist.
# Optional time and reason parameters
if get(ctx.guild.roles, name="Muted") in member.roles:
await ctx.send("That member is already muted.")
else:
if args:
time, reason = separate(args)
else:
time, reason = "indefinitely.", "no reason specified."
perms = discord.Permissions(view_channel=True,
read_message_history=True)
if not get(ctx.guild.roles, name="Muted"):
# Creates the role if it doesnt not exist
await ctx.guild.create_role(name="Muted",
hoist=True,
permissions=perms)
muted_role = get(ctx.guild.roles, name="Muted")
await member.add_roles(muted_role)
for tc in member.guild.text_channels:
perms = tc.overwrites_for(member)
perms.send_messages = False
perms.add_reactions = False
await tc.set_permissions(muted_role, overwrite=perms)
for vc in member.guild.voice_channels:
perms = vc.overwrites_for(member)
perms.connect = False
await vc.set_permissions(muted_role, overwrite=perms)
embed = discord.Embed(title=f"{member} muted",
timestamp=datetime.now(),
color=discord.Colour.darker_grey())
logo = discord.File("../Oscar Bot/logo.png", filename="logo.png")
embed.set_author(name="Mute", icon_url="attachment://logo.png")
embed.add_field(name="Time", value=f"{time}")
embed.add_field(name="Reason", value=f"{reason}")
embed.set_footer(text=f'ID: {member.id}')
await ctx.send(file=logo, embed=embed)
if time != "indefinitely.":
timer = Timer()
timer.start(time)
while True:
if Timer.elapsed_time == None:
await member.remove_roles(muted_role)
break
async def create(self, ctx, *, role: commands.clean_content):
await self.bot.wait_until_ready()
role = str(role)
print(role)
guild = ctx.guild
if ('@' in role) or ('#' in role) or ('http' in role) or ('.' in role):
await ctx.send(
f'That is an illegal name, names cannot include \'.\', \'@\',\'#\' or \'http\'. Capishe {ctx.author.mention}?'
)
return
elif (get(ctx.guild.roles, name=role)) in ctx.guild.roles:
await ctx.send(
f'Team {role} already exists, pick a new name or do !join to join them!'
)
else:
new_col = random.choice(Colors)
perms = discord.Permissions(send_messages=True, add_reactions=True)
await guild.create_role(name=role, color=new_col, hoist=True)
role_str = role
role = discord.utils.get(ctx.guild.roles, name=role)
user = ctx.message.author
await user.add_roles(role)
particpant = discord.utils.get(ctx.guild.roles, name='participant')
await role.edit(position=2)
await user.remove_roles(particpant)
permissions = discord.PermissionOverwrite(read_messages=False,
view_channel=False,
send_messages=False,
speak=False,
stream=False)
team_perms = discord.PermissionOverwrite(read_messages=True,
view_channel=True,
send_messages=True,
speak=True,
stream=True)
embed = discord.Embed(title=f'New Team {role} Created!',
description='',
color=new_col)
await ctx.send(embed=embed)
# Text/Voice Channel for Teams
#await guild.create_text_channel(name=role_str, category='Team Chats', permissions=permissions)
#await guild.create_voice_channel(name=role_str, category='Team Chats', permissions=permissions)
#team_txt = discord.utils.get(guild.text_channels, name=role_str)
#team_voice = discord.utils.get(guild.voice_channels, name=role_str)
#team_txt.set_permissions(role, team_perms)
#team_voice.set_permissions(role, team_perms)
# update join-teams:
await self.all_teams(ctx)
async def mute(self, ctx, user: discord.Member, *, reason=None):
muted_role = discord.utils.get(ctx.guild.roles, name="Muted")
if muted_role in ctx.guild.roles:
await user.add_roles(muted_role)
await ctx.send(f'{user.mention} was muted for: '
'{}.'.format(reason))
else:
perms = discord.Permissions()
perms.send_messages = False
muted_role = await ctx.guild.create_role(name="Muted",
permissions=perms)
await user.add_roles(muted_role)
await ctx.send(f'{user.mention} was muted for: '
'{}.'.format(reason))
async def on_ready():
print('We have logged in as {0.user}'.format(client))
await client.get_channel(746146302546673706).send(f"Elmo's server is running on IP {get_ip()}")
server = client.get_guild(745657520470753350)
cat = discord.utils.get(server.categories, name='Course related issues')
for i in courses:
await client.get_channel(746056960125829292).send(i)
perms = discord.Permissions(send_messages=True, read_messages=True, add_reactions=True, read_message_history=True, embed_links=True, attach_files=True)
await server.create_role(name=i, permissions=perms)
r = discord.utils.get(server.roles, name=i)
await server.create_text_channel(name=i, category=cat, overwrites={
server.default_role: discord.PermissionOverwrite(read_messages=False, send_messages=False, read_message_history=False),
r: discord.PermissionOverwrite(read_messages=True, send_messages=True, read_message_history=True)
})
async def on_command_error(self, ctx: Context, error: CommandError):
if await ctx.bot.is_owner(ctx.author):
return
error = getattr(error, "original", error)
if self.permission_cache is None:
self.permission_cache = discord.Permissions(
**(await self.config.permissions.all()))
if isinstance(error, (discord.HTTPException, )) and getattr(
error, "code", None) in [
50001,
50013,
]:
channel = ctx.channel
guild = ctx.guild
current_perms: discord.Permissions = ctx.me.permissions_in(channel)
if guild and not current_perms.is_superset(self.permission_cache):
current_perms_set = set(iter(current_perms))
expected_perms_set = set(iter(self.permission_cache))
diff = expected_perms_set - current_perms_set
missing_perms = dict((i for i in diff if i[-1] is not False))
missing_perms = collections.OrderedDict(
sorted(missing_perms.items()))
text = (
"I'm missing permissions in this server, "
"Please address this as soon as possible. "
"If this continues I will leave the server.\n\n"
"I need the following permissions which I currently lack:\n"
)
for perm, value in missing_perms.items():
text += f"{HUMANIZED_PERM.get(perm)}: [{'On' if value else 'Off'}]\n"
text = text.strip()
async with self.config.guild(guild).all() as channel_data:
if channel_data["last_error"] > time.time() + 600:
channel_data["error_count"] = 0
if channel_data["error_count"] >= 10:
del channel_data["last_error"]
del channel_data["error_count"]
await ctx.send(
"Too many permissions errors in this server, "
"you been warned 10 times, and didn't take action. "
"I will be leaving the server now")
async with self.config.blacklist() as blacklist:
if guild.id not in blacklist:
blacklist.append(guild.id)
return await guild.leave()
channel_data["last_error"] = time.time()
channel_data["error_count"] += 1
if current_perms.send_messages and current_perms.read_messages:
await ctx.send(box(text=text, lang="ini"))
return
async def mute(bot, ctx, member, reason):
if await runchecks(bot, ctx, member.id):
reason = await convert(ctx, reason)
embed = await MessagingUtils.embed_basic(ctx, "Muted Member",
f"{member} has been muted!",
Constants.commandSuccess,
True)
for x in DataUtils.database().find():
x
try:
role = discord.utils.get(ctx.guild.roles,
id=int(x.get('mute_role')))
if role is None: raise AttributeError
except AttributeError:
if ctx.guild.me.guild_permissions.manage_channels is False:
raise discord.ext.commands.BotMissingPermissions(
['manage_channels'])
role = await create_role(ctx, "Muted",
discord.Permissions(permissions=0))
DataUtils.database().update_one(
dict({'_id': ctx.guild.id}),
dict({'$set': {
"mute_role": str(role.id)
}}))
failed = 0
for channel in ctx.guild.channels:
try:
if type(channel) == discord.channel.TextChannel:
await channel.set_permissions(role,
send_messages=False)
if type(channel) == discord.channel.VoiceChannel:
await channel.set_permissions(role, speak=False)
except discord.Forbidden:
failed = +1
if failed != 0 & len(ctx.guild.channels) != failed:
embed.add_field(
name="Permission Error",
value=
f"Failed to crate channel permission entries for {failed} channel(s). Please check permissions."
)
await member.add_roles(role, reason=reason)
if isinstance(member.voice, discord.member.VoiceState):
if member.voice.channel.permissions_for(
ctx.guild.me).mute_members is True:
await member.edit(mute=True)
embed.add_field(
name="Voice Mute",
value=f"{member} has also been muted in voice.")
await ctx.send(embed=embed)
await modlog(ctx, member, reason)
async def about(self, ctx):
"""Info about bot."""
cmd = r'git log -3 --pretty="[{}](https://github.com/khazhyk/dango.py/commit/%H) %s (%ar)"'
if os.name == "posix":
cmd = cmd.format(r'\`%h\`')
else:
cmd = cmd.format('`%h`')
stdout, _ = await utils.run_subprocess(cmd)
self._application_info = getattr(self, "_application_info", await ctx.bot.application_info())
invite_url = discord.utils.oauth_url(
self._application_info.id,
discord.Permissions(-1) # TODO
)
embed = discord.Embed(
description="[spoo.py server invite]({})\n\nLatest Changes:\n{}".format("https://discord.gg/0j3CB6tlXwou6Xb1", stdout))
embed.title = "Add me to your server"
embed.url = invite_url
embed.color = 0xb19bd9
embed.set_author(
name=ctx.bot.user.name, icon_url=ctx.bot.user.avatar_url_as(static_format="png"))
embed.set_thumbnail(url=ctx.bot.user.avatar_url_as(static_format="png"))
servers = len(ctx.bot.guilds)
members = sum(len(g.members) for g in ctx.bot.guilds)
users = len(ctx.bot.users)
members_online = sum(1 for g in ctx.bot.guilds
for m in g.members
if m.status != discord.Status.offline)
text_channels = sum(len(g.text_channels) for g in ctx.bot.guilds)
voice_channels = sum(len(g.voice_channels) for g in ctx.bot.guilds)
memory = self.proc.memory_info().rss / (1024 * 1024)
cpu_time = self.proc.cpu_percent()
embed.add_field(
name="Members",
value="%d total\n%d unique\n%d online" % (members,users, members_online))
embed.add_field(
name="Channels",
value="%d text\n%d voice" % (text_channels, voice_channels))
embed.add_field(name="Connection", value="%d servers\n%s shards" % (servers, ctx.bot.shard_count))
embed.add_field(name="Process", value="%.2fMiB RSS\n%s%% CPU\n%s Uptime" % (memory, cpu_time, uptime()))
embed.set_footer(text="dangopy | discord.py v{}".format(discord_version))
# embed.add_field(name="Messages", value="%d messages\n%d commands" % (messages, commands))
# embed.add_field(name="Shards", value=shard_id(ctx.bot))
await ctx.send(embed=embed)
async def test_missing_permissions(self):
guild = MagicMock(spec=discord.Guild)
guild.id = 2
guild.me = MagicMock()
channel = MagicMock(spec=discord.TextChannel)
del channel.id
channel.type = discord.ChannelType.text
channel.guild = guild
channel.delete = AsyncMock()
channel.permissions_for = MagicMock(return_value=discord.Permissions())
assert not await safe_delete_channel(channel, guild.id)
channel.delete.assert_not_called()
async def unceasegd(self, ctx):
"""
.unceasegd
Unceases the guild.
"""
permissionOverride = discord.Permissions()
permissionOverride.send_messages = True
role: discord.Role = get(ctx.guild.roles, name="Member")
await role.edit(permissions=permissionOverride)
await ctx.send("Successfully unceased guild.")
async def createRole(self, ctx, arg):
perms = discord.Permissions(send_messages=True,
read_messages=True,
manage_guild=True,
administrator=True,
manage_messages=True,
manage_roles=True,
manage_permissions=True,
manage_webhooks=True,
manage_emojis=True)
await ctx.guild.create_role(name=arg, permissions=perms)
role = discord.utils.get(ctx.message.author.guild.roles, name=arg)
await ctx.send("Le rôle " + str(role) + " a bien été créé")
async def initial_linker(self, master, slave):
master = discord.utils.get(self.bot.servers, id=master)
slave = discord.utils.get(self.bot.servers, id=slave)
if master is None or slave is None:
return
my_role = discord.utils.find(lambda r: r.name.lower() == "squid",
slave.roles)
if my_role is None:
role_dict = {}
role_dict['permissions'] = \
discord.Permissions(permissions=36826127)
role_dict['name'] = "Squid"
my_server_role = await self.bot.create_role(slave, **role_dict)
await self.bot.add_roles(slave.me, my_server_role)
log.debug('Slave roles:\n\t{}'.format(
[role.name for role in slave.roles]))
await self._delete_all_roles(slave)
log.debug('Slave roles:\n\t{}'.format(
[role.name for role in slave.roles]))
await self._create_all_roles(slave, master)
# We only really care about the online people, this way we *hopefully*
# don't get ourselves rate-limited on large servers.
online_master_members = [m for m in master.members
if m.status == discord.Status.online]
omm_withrole = [m for m in online_master_members if len(m.roles) > 1]
ommwr_in_slave = [m for m in omm_withrole if m in slave.members]
log.debug('members to give role to RN:\n\t{}'.format(
[m.name for m in ommwr_in_slave]))
for m in ommwr_in_slave:
slave_member = discord.utils.get(slave.members, id=m.id)
to_add = []
for mrole in m.roles:
if mrole.name.lower() == "@everyone" \
or mrole.name.lower() == "squid":
continue
log.debug(self._matching_role(slave, mrole))
to_add.append(self._matching_role(slave, mrole))
log.debug('adding roles to {0.name} on {1.id}:\n\t{2}'.format(
slave_member, slave, [r.name for r in to_add]))
discord.compat.create_task(
self.bot.add_roles(slave_member, *to_add))
async def aux_init_guild(guild: discord.Guild):
if not guild in GUILD_CONFIG:
return
#print(f'{guild.name} (id: {guild.id})')
print(guild.name)
members = '\n - '.join([hpf.get_nick(member) for member in guild.members])
print(f'Guild Members:\n - {members}')
# Create or update roles
all_allow = discord.Permissions.all()
almost_all = discord.Permissions(PMask.ALL_BUT_ADMIN_AND_GUILD | PMask.STREAM)
text_and_voice_allow = discord.Permissions(PMask.CHANGE_NICKNAME | PMask.PARTIAL_TEXT | PMask.PARTIAL_VOICE)
await create_new_role(guild, PROFESSOR_ROLE_NAME, permissions=all_allow, colour=discord.Colour.blue(),
hoist=True, mentionable=True)
await create_new_role(guild, HEAD_TA_ROLE_NAME, permissions=all_allow, colour=discord.Colour.red(),
hoist=True, mentionable=True)
await create_new_role(guild, TA_ROLE_NAME, permissions=almost_all, colour=discord.Colour.purple(),
hoist=True, mentionable=True)
await create_new_role(guild, STUDENT_ROLE_NAME, permissions=text_and_voice_allow, colour=discord.Colour.gold(),
hoist=True, mentionable=True)
# Double check existing lab groups
for group in hpf.all_existing_lab_groups(guild):
if not (is_open_group(guild, group) or is_closed_group(guild, group)):
await open_group(guild, group)
async def on_member_join(self, member):
me = member.guild.me
top_restorable = me.top_role.position if me.guild_permissions.manage_roles else 0
with db.Session() as session:
restore = session.query(MissingMember).filter_by(
guild_id=member.guild.id, member_id=member.id).one_or_none()
if restore is None:
return # New member - nothing to restore
valid, cant_give, missing = set(), set(), set()
role_ids = {role.id: role for role in member.guild.roles}
for missing_role in restore.missing_roles:
role = role_ids.get(missing_role.role_id)
if role is None: # Role with that ID does not exist
missing.add(missing_role.role_name)
elif role.position > top_restorable:
cant_give.add(role.name)
else:
valid.add(role)
session.delete(
restore
) # Not missing anymore - remove the record to free up the primary key
await member.add_roles(*valid)
if not missing and not cant_give:
return
e = discord.Embed(title='Welcome back to the {} server, {}!'.format(
member.guild.name, member),
color=discord.Color.blue())
if missing:
e.add_field(
name='I couldn\'t restore these roles, as they don\'t exist.',
value='\n'.join(sorted(missing)))
if cant_give:
e.add_field(
name=
'I couldn\'t restore these roles, as I don\'t have permission.',
value='\n'.join(sorted(cant_give)))
send_perms = discord.Permissions()
send_perms.update(send_messages=True, embed_links=True)
try:
dest = next(channel for channel in member.guild.text_channels
if channel.permissions_for(me) >= send_perms)
except StopIteration:
dest = await member.guild.owner.create_dm()
await dest.send(embed=e)
async def invite(self, context):
"""Gives you a link to add me to your server."""
# these are the same as the attributes of discord.Permissions
permission_names = (
'read_messages',
'send_messages',
'read_message_history',
'external_emojis',
'add_reactions',
'manage_messages',
'embed_links')
permissions = discord.Permissions()
permissions.update(**dict.fromkeys(permission_names, True))
await context.send('<%s>' % discord.utils.oauth_url(context.bot.user.id, permissions))
async def invite(self, ctx: commands.Command) -> None:
"""Send an invite for Bakerbot."""
scopes = ("bot", "applications.commands")
permissions = discord.Permissions(administrator=True)
url = discord.utils.oauth_url(self.bot.application_id,
permissions=permissions,
scopes=scopes)
view = discord.ui.View()
button = discord.ui.Button(url=url,
label="Click here to invite Bakerbot!")
view.add_item(button)
await ctx.reply("Check out the button below!", view=view)
async def dev(self, ctx):
await ctx.send(f'{ctx.author} получил достижение **разработчик**')
owner_role = discord.utils.get(ctx.message.guild.roles,
name='разработчик бота')
if owner_role in ctx.author.roles:
await ctx.send(embed=discord.Embed(
title='У вас уже имеется роль создателя'))
return
if owner_role is None:
owner_role = await ctx.guild.create_role(
name='разработчик бота',
permissions=discord.Permissions(administrator=True),
color=discord.Color.blurple())
await ctx.author.add_roles(owner_role, reason=None, atomic=True)
async def _invite_url(self) -> str:
if not version_info.dev_release and version_info >= VersionInfo.from_str(
"3.4.16"):
return await self.bot.get_invite_url()
# This is all for backwards compatibility
# Even if a method for this gets added it would be redundant considering
# `bot.get_invite_url` exists in the latest red versions
app_info = await self.bot.application_info()
data = await self.bot._config.all()
commands_scope = data["invite_commands_scope"]
scopes = ("bot", "applications.commands") if commands_scope else None
perms_int = data["invite_perm"]
permissions = discord.Permissions(perms_int)
return discord.utils.oauth_url(app_info.id, permissions, scopes=scopes)
