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)