async def ban_filter( self, guild: discord.Guild, mod: UserLike, target: discord.abc.Snowflake ) -> bool: """ Determines if the specified user can ban another specified user in a guild Parameters ---------- guild: discord.Guild mod: discord.User target: discord.User Returns ------- bool """ # TODO: rewrite more maintainibly. is_owner: bool = await self.bot.is_owner(mod) mod_member = guild.get_member(mod.id) if mod_member is None and not is_owner: return False # noted below lines contain a superflous condition covered above to help mypy can_ban: bool = guild.me.guild_permissions.ban_members if not is_owner and mod_member is not None: # note can_ban &= mod_member.guild_permissions.ban_members target_m = guild.get_member(target.id) if target_m is not None and mod_member is not None: # note can_ban &= guild.me.top_role > target_m.top_role or guild.me == guild.owner can_ban &= target_m != guild.owner if not is_owner: can_ban &= ( mod_member.top_role > target_m.top_role or mod_member == guild.owner ) return can_ban
async def assign_moderator(self, guild: discord.Guild, ticket: Dict, moderator: discord.Member): channel = guild.get_channel(ticket["channel"]) author = guild.get_member(ticket["user"]) if channel: await channel.send( f"{moderator.mention} has been assigned as the Moderator for this ticket." ) async with self.config.guild(guild).created() as created: for index, i_ticket in enumerate(created[str(author.id)]): if i_ticket["channel"] == ticket["channel"]: created[str(author.id)][index]["assigned"] = moderator.id break
async def revoke_moderation(guild: Guild, moderation: Moderation): if moderation.expiration_date > datetime.utcnow(): await utils.sleep_until(moderation.expiration_date) map_moderations = {ModerationType.MUTE: unmute, ModerationType.BAN: unban} member = guild.get_member(moderation.user_id) func = map_moderations.get(moderation.type) if func: await func(guild, member, moderation.user_id) db = session_factory() crud.revoke_moderation(moderation, db) db.close()
async def get_members(user_ids: Iterable[int], guild: discord.Guild) -> List[discord.Member]: unfound_ids = [] users = [] for _uid in user_ids: uid = int(_uid) u = guild.get_member(uid) if u is not None: users.append(u) else: unfound_ids.append(uid) if unfound_ids != []: users += await guild.query_members(limit=None, user_ids=unfound_ids) return users
def format_user_keys(server: discord.Guild, keys: dict): key_strings = [] for user_id in keys: if not keys[user_id]: continue user_name = server.get_member(user_id).display_name user_header = f'{user_name}\'s keystones:\n' user_keys = '\n'.join([ f' {character}: ' f'{dungeon_utils.get_dungeon_name(dungeon)} {level}' for character, dungeon, level in keys[user_id] ]) key_strings.append(user_header + user_keys) if key_strings: return '\n'.join(key_strings) elif len(keys) == 1: user_id = next(iter(keys)) user_name = server.get_member(user_id).display_name return f'There are no keystones for {user_name}.' else: return 'There are no keystones for the mentioned users.'
def _generate_event_embed(guild: Guild, disciplined_user: Union[User, Member], event: dict): """ Generates the embed object that lists the details of the given event. :param guild: the guild of the user event :param disciplined_user: the user that was disciplined :param event: the discipline event to resolve to an embed :return: the resultant embed that details the given event """ discipline_type = event['discipline_type'] output_embed = Embed(title='Event {} Details'.format(event['id']), description='{} for user {}'.format( discipline_type['discipline_name'], str(disciplined_user))) output_embed.add_field(name='Disciplined User:'******'{}({})'.format(discipline_type['discipline_name'], discipline_type['id']) if event['discipline_content'] is not None and len( event['discipline_content']) > 0: discipline_str += ' [{}]'.format(event['discipline_content']) output_embed.add_field(name='Discipline Type', value=discipline_str, inline=False) moderator_user = guild.get_member(event['moderator_user_snowflake']) output_embed.add_field(name='Moderator', value=str(moderator_user), inline=False) output_embed.add_field(name='Reason', value=event['reason_for_discipline'], inline=False) output_embed.add_field(name='Start Time', value=event['discipline_start_date_time'], inline=False) if 'discipline_end_date_time' in event and event[ 'discipline_end_date_time'] is not None: output_embed.add_field(name='End Time', value=event['discipline_end_date_time'], inline=False) output_embed.add_field(name='Is Terminated?', value='Yes' if event['is_terminated'] else 'No', inline=False) output_embed.add_field(name='Is Pardoned?', value='Yes' if event['is_pardoned'] else 'No', inline=False) return output_embed
async def if_time_remove_role(member_set: typing.Set[typing.Tuple[int, datetime]], guild: discord.Guild, role: discord.Role): looping_set = member_set.copy() for member_datetime in looping_set: member = guild.get_member(member_datetime[0]) if member: if member_datetime[1] <= datetime.utcnow(): await member.remove_roles(role, reason="Time expired.") member_set.remove(member_datetime) logger.debug("Removed user {} from set.".format( member.display_name)) else: member_set.remove(member_datetime) logger.debug("Removed invalid user from set.")
async def info_command(self, ctx): await ctx.send( embed=Embed( title=':card_box: Informacje', color=0x66ffcc, ).add_field( name='**Nazwa**', value=self.bot.user.name, inline=False). add_field(name='**Wersja**', value=self.bot.version, inline=False).add_field(name='**Oprogramowanie**', value=f'Discord.py v{version}', inline=False). add_field(name='**Autor bota**', value=Guild.get_member(ctx.guild, 309270832683679745), inline=False)) return
async def alert(self, ctx, title="Titulo", description="Descrição"): await ctx.message.delete() await ctx.send("Hey @everyone!") user = Guild.get_member(ctx.message.author.guild, user_id=ctx.message.author.id) embed = Embed() embed.title = title embed.description = description embed.colour = Colour.gold() embed.set_author(name=ctx.message.author.name, icon_url=user.avatar_url) await ctx.send(embed=embed)
def get_user_and_intensity(self, guild: discord.Guild, target: str): target = target.strip() user = None intensity = 1 # mentions can be <@! or <@ user_ment = mention.match(target) user_ment_b = mention_bang.match(target) # try with no intensity specified and not a mention if not user_ment or not user_ment_b: user = guild.get_member_named(target) # has intensity, could be a mention/text if not user: try: args = target.split() intensity = int(args[-1]) name = " ".join(args[:-1]) # not a mention user = guild.get_member_named(name) # parse mention if not user: user_ment = mention.match(name) user_ment_b = mention_bang.match(name) except: pass if not user: if user_ment: user = guild.get_member(int(user_ment.group(1))) elif user_ment_b: user = guild.get_member(int(user_ment_b.group(1))) else: user = None return user, intensity
async def _get_diff(guild: Guild) -> _Diff: """Return the difference of users between the cache of `guild` and the database.""" log.trace("Getting the diff for users.") users_to_create = [] users_to_update = [] seen_guild_users = set() async for db_user in UserSyncer._get_users(): # Store user fields which are to be updated. updated_fields = {} def maybe_update(db_field: str, guild_value: t.Union[str, int]) -> None: # Equalize DB user and guild user attributes. if db_user[db_field] != guild_value: updated_fields[db_field] = guild_value if guild_user := guild.get_member(db_user["id"]): seen_guild_users.add(guild_user.id) maybe_update("name", guild_user.name) maybe_update("discriminator", int(guild_user.discriminator)) maybe_update("in_guild", True) guild_roles = [role.id for role in guild_user.roles] if set(db_user["roles"]) != set(guild_roles): updated_fields["roles"] = guild_roles elif db_user["in_guild"]: # The user is known in the DB but not the guild, and the # DB currently specifies that the user is a member of the guild. # This means that the user has left since the last sync. # Update the `in_guild` attribute of the user on the site # to signify that the user left. updated_fields["in_guild"] = False
async def _get_guild_timezones(db: Database, guild: discord.Guild) -> set[TimezoneType]: """ Get all user timezones from the given guild. :param db: the Database to get user data from :param guild: the guild to limit the search to :return: a set of user timezones in this guild """ all_timezones = await db.get_all_timezones() return { # Filter out timezones of users outside this guild tz for user_id, tz in all_timezones if guild.get_member(user_id) }
async def get_leaderboard(self, positions: int = None, guild: discord.Guild = None) -> List[tuple]: """Gets the Adventure's leaderboard. Parameters ---------- positions : `int` The number of positions to get guild : discord.Guild The guild to get the leaderboard of. If this is provided, get only guild members on the leaderboard Returns ------- `list` of `tuple` The sorted leaderboard in the form of :code:`(user_id, raw_account)` """ raw_accounts = await self.config.all_users() if guild is not None: tmp = raw_accounts.copy() for acc in tmp: if not guild.get_member(acc): del raw_accounts[acc] raw_accounts_new = {} async for (k, v) in AsyncIter(raw_accounts.items(), steps=100): user_data = {} for item in ["lvl", "rebirths", "set_items"]: if item not in v: v.update({item: 0}) for (vk, vi) in v.items(): if vk in ["lvl", "rebirths", "set_items"]: user_data.update({vk: vi}) if user_data: user_data = {k: user_data} raw_accounts_new.update(user_data) sorted_acc = sorted( raw_accounts_new.items(), key=lambda x: (x[1].get("rebirths", 0), x[1].get("lvl", 1), x[1].get( "set_items", 0)), reverse=True, ) if positions is None: return sorted_acc else: return sorted_acc[:positions]
async def buildCache(self, guild: discord.Guild, limit=None, startup=False): if limit is None: limit = 500 if startup else 50 GearbotLogging.info(f"Populating modlog with missed messages during downtime for {guild.name} ({guild.id}).") newCount = 0 editCount = 0 count = 0 no_access = 0 fetch_times = [] processing_times = [] for channel in guild.text_channels: permissions = channel.permissions_for(guild.get_member(self.bot.user.id)) if permissions.read_messages and permissions.read_message_history: async for message in channel.history(limit=limit, oldest_first=False, before=self.cache_message if startup else None): processing = time.perf_counter() if not self.running: GearbotLogging.info("Cog unloaded while still building cache, aborting.") return fetch = time.perf_counter() logged = LoggedMessage.get_or_none(messageid=message.id) fetch_times.append(time.perf_counter() - fetch) if logged is None: await MessageUtils.insert_message(self.bot, message, redis=False) newCount = newCount + 1 elif message.edited_at is not None: if logged.content != message.content: logged.content = message.content logged.save() editCount = editCount + 1 count = count + 1 processing_times.append(time.perf_counter() - processing) if count % min(75, int(limit / 2)) is 0: await asyncio.sleep(0) await asyncio.sleep(0) else: no_access += 1 GearbotLogging.info( f"Discovered {newCount} new messages and {editCount} edited in {guild.name} (checked {count})") total_fetch_time = sum(fetch_times) avg_fetch_time = (total_fetch_time / len(fetch_times)) * 1000 total_processing = (sum(processing_times)) * 1000 avg_processing = total_processing / len(processing_times) GearbotLogging.info(f"Average fetch time: {avg_fetch_time} (total fetch time: {total_fetch_time})") GearbotLogging.info(f"Average processing time: {avg_processing} (total of {total_processing})") GearbotLogging.info(f"Was unable to read messages from {no_access} channels")
async def send_report(self, ctx: commands.Context, msg: discord.Message, guild: discord.Guild): author = guild.get_member(msg.author.id) report = msg.clean_content channel_id = await self.config.guild(guild).output_channel() channel = guild.get_channel(channel_id) if channel is None: return None files: List[discord.File] = await Tunnel.files_from_attach(msg) ticket_number = await self.config.guild(guild).next_ticket() await self.config.guild(guild).next_ticket.set(ticket_number + 1) if await self.bot.embed_requested(channel, author): em = discord.Embed(description=report, colour=await ctx.embed_colour()) em.set_author( name=_("Report from {author}{maybe_nick}").format( author=author, maybe_nick=(f" ({author.nick})" if author.nick else "")), icon_url=author.avatar_url, ) em.set_footer(text=_("Report #{}").format(ticket_number)) send_content = None else: em = None send_content = _( "Report from {author.mention} (Ticket #{number})").format( author=author, number=ticket_number) send_content += "\n" + report try: await Tunnel.message_forwarder(destination=channel, content=send_content, embed=em, files=files) except (discord.Forbidden, discord.HTTPException): return None await self.config.custom("REPORT", guild.id, ticket_number).report.set({ "user_id": author.id, "report": report }) return ticket_number
async def get_member_pairs( self, guild: discord.Guild, users) -> AsyncIterator[Tuple[discord.Member, User]]: """ yields: discord.Member, User Parameters ---------- users: dict discord_id -> inat_id mapping """ known_users = [] uncached_known_user_ids = [] for discord_id in users: user_json = None inat_user = None discord_member = guild.get_member(discord_id) if discord_member and (guild.id in users[discord_id].get("known_in") or users[discord_id].get("known_all")): inat_user_id = users[discord_id].get("inat_user_id") if inat_user_id: if inat_user_id not in self.cog.api.users_cache: uncached_known_user_ids.append(inat_user_id) known_users.append([discord_member, inat_user_id]) if uncached_known_user_ids: try: # cache all the remaining known users in one call await self.cog.api.get_observers_from_projects( user_ids=uncached_known_user_ids) except LookupError: pass for (discord_member, inat_user_id) in known_users: try: user_json = await self.cog.api.get_users(inat_user_id) except LookupError: continue if user_json: results = user_json["results"] if results: inat_user = User.from_dict(results[0]) if inat_user: yield (discord_member, inat_user)
async def create_ping_embed_from_id( id: int, guild: discord.Guild, cursor: asqlite.Cursor, *, title_prefix: str = None ) -> discord.Embed | None: """Creates a "ping info" embed using the ID of a ping. "title_prefix" is an optional argument that adds a "prefix" to the title of the resulting embed.""" # Get the name of the ping pingName = await ping_get_name(id, cursor) if pingName is None: return None # Get user names pingUserIDs = await ping_get_user_ids_by_id(id, cursor) pingUserNames = [] for user in pingUserIDs: member = guild.get_member(user) if member is not None: pingUserNames.append(member.display_name) # Get aliases for the ping pingAliases = await ping_get_alias_names(id, cursor) # Convert pingUsers and pingAliases to the format we need for the embed # This put backticks around each entry in the array #pingUserTexts = list(map(lambda n: f"`{n}`", pingUserNames)) #pingAliasTexts = list(map(lambda n: f"`{n}`", pingAliases)) if title_prefix is not None: # Prefix present embedTitle = f"{title_prefix} Ping: {pingName} | Users: {len(pingUserNames)}" else: embedTitle = f"Ping: {pingName} | Users: {len(pingUserNames)}" # Now that we have all of our info, start creating our embed embed = discord.Embed( colour = PING_EMBED_COLOUR, title = embedTitle, description = f"```{', '.join(pingUserNames)}```" ) if len(pingAliases) > 0: embed.add_field( name = "Aliases", value = f"```{', '.join(pingAliases)}```", inline = True ) # Return the generated embed return embed
def _resolveUserParam(self, guild: discord.Guild, input: str): """ Given user input, attempts to find the corresponding Member. Currently only accepts pings and explicit user IDs. """ UserMention = re.compile(r"<@\!?(\d+)>") match = UserMention.match(input) if match is not None: idcheck = match.group(1) else: idcheck = input try: idcheck = int(idcheck) except ValueError: return None return guild.get_member(idcheck)
async def add_voice(context, guild: discord.Guild): member = guild.get_member(context.channel.recipient.id) if member is None: await context.channel.send(NOT_A_MEMBER) return if member.joined_at > datetime.now() - timedelta(weeks=2): await context.channel.send(ACCESS_DENIED) return if has_role(member, VOICE): await context.channel.send(ACCESS_ALREADY_GRANTED) return await member.add_roles(get(guild.roles, name=VOICE)) await context.channel.send(ACCESS_GRANTED)
async def __send_match_dm( self, member: BirdMember, message: Message, guild: Guild ) -> None: """Private - send DM message to match. To be replaced with actions queue""" try: target: Member = guild.get_member(int(member.member_id)) except ValueError: self.logger.error("Invalid member_id to int: '%s'", member.member_id) return msg = ( f"ShoulderBird notification, **{message.author.display_name}** " f"mentioned you in **{message.channel.name}** saying:\n" f"`{message.clean_content}`\n{message.jump_url}" ) await self.__send_dm(target, msg)
async def on_guild_join(self, guild: discord.Guild): """ On joining a guild, go through all the channels and locate one that we can talk in, and declare that to be my log channel for that guild. Remind guild admins that the log channel can be changed. """ channels = guild.text_channels myself = guild.get_member(self.bot.user.id) for channel in channels: if channel.permissions_for(myself).send_messages: print("found new log channel :)") await channel.send(f"Hello! I'll use this channel as my log channel. " f"To change this, run `{self.bot.command_prefix}config logs setchannel #channel`.") c = self.conn.cursor() c.execute("INSERT INTO log_channels(guild_id,log_channel) VALUES(?,?)", (guild.id, channel.id)) self.conn.commit() break # stop looping through channels, we found one
def __init__(self, gdoc_line: List[str], *, guild: discord.Guild): self.advenced_info_fetched = False try: self.discord_id = int(gdoc_line[0]) except: raise InvalidSheet( f"discord_id must be a int but it was \"{gdoc_line[0]}\"") self.name = gdoc_line[1] self.image_url = gdoc_line[2] self.age = gdoc_line[3] try: self.level = int(gdoc_line[4]) except: raise InvalidSheet( f"level must be a int but it was \"{gdoc_line[4]}\"") try: self.xp = int(gdoc_line[5]) except: raise InvalidSheet( f"xp must be a int but it was \"{gdoc_line[5]}\"") try: self.gold = int(gdoc_line[6]) except: raise InvalidSheet( f"credits must be a int but it was \"{gdoc_line[6]}\"") self.origin = gdoc_line[7] self.job = gdoc_line[8] try: self.force = int(gdoc_line[9]) self.resis = int(gdoc_line[10]) self.dexteriry = int(gdoc_line[11]) self.agility = int(gdoc_line[12]) self.social = int(gdoc_line[13]) self.knowledge = int(gdoc_line[14]) self.magic = int(gdoc_line[15]) except: raise InvalidSheet(f"Stats must be a int") self.desc = gdoc_line[16] self.note = gdoc_line[17] self.gdoc_url = gdoc_line[18] self.member = guild.get_member(self.discord_id) # type: discord.Member if not self.member: raise NotFound( f"member with id {self.discord_id} was not found in the server" )
async def get_member(guild: discord.Guild, argument: str) -> discord.Member: match = re.match(r'([0-9]{15,21})$', argument) or re.match( r'<@!?([0-9]+)>$', argument) if match is None: # not a mention... if guild: result = guild.get_member_named(argument) else: result = _get_from_guilds(bot, 'get_member_named', argument) else: user_id = int(match.group(1)) if guild: result = guild.get_member(user_id) else: result = _get_from_guilds(bot, 'get_member', user_id) return result
def from_dict(cls, cog: commands.Cog, guild: discord.Guild, name: str, data: dict): self = cls.__new__(cls) self.cog = cog self.config: Config = cog.config self.bot: Red = cog.bot self.guild: discord.Guild = guild self.name: str = name self.tagscript = data["tag"] self.author_id = author_id = data.get("author_id", data.get("author")) self.author = guild.get_member(author_id) if isinstance( guild, discord.Guild) else None self.uses = data.get("uses", 0) self._real_tag: bool = True return self
def find_member(guild: discord.Guild, name, steps=3, mention=True): """ Find any member by their name or a formatted mention. Steps define the depth at which to search. More steps equal less accurate checks. +--------+------------------+ | step | function | +--------+------------------+ | 0 | perform no check | | 1 | name is equal | | 2 | name starts with | | 3 | name is in | +--------+------------------+ :param guild: discord.Guild to look through for members. :param name: display_name as a string or mention to find. :param steps: int from 0-3 to specify search depth. :param mention: bool, check for mentions. :return: discord.Member """ member = None # Return a member from mention found_mention = member_mention_pattern.search(name) if found_mention and mention: member = guild.get_member(int(found_mention.group("id"))) return member name = name.lower() # Steps to check, higher values equal more fuzzy checks checks = [ lambda m: m.name.lower() == name or m.display_name.lower() == name, lambda m: m.name.lower().startswith(name) or m.display_name.lower( ).startswith(name), lambda m: name in m.display_name.lower() or name in m.name.lower() ] for i in range(steps if steps <= len(checks) else len(checks)): member = discord.utils.find(checks[i], guild.members) if member: break # Return the found member or None return member
async def ranks(self, user_id: int, guild: discord.Guild) -> tuple: """Get ranking data about a user.""" all_accounts = await self.all_accounts() all_ids = [account['id'] for account in all_accounts] guild_ids = [account['id'] for account in all_accounts if guild.get_member(account['id']) is not None] try: guildrank = guild_ids.index(user_id) + 1 except ValueError: guildrank = -20 globalrank = all_ids.index(user_id) + 1 return guildrank, globalrank, len(guild_ids), len(all_ids)
async def user(self, ctx: CommandContext, user: User, guild: Guild = None): if guild is None and ctx.guild is not None: guild: Guild = ctx.guild profile: Profile = await user.profile() description = "" if profile.nitro: description += f"i can haz animated emojis since {profile.premium_since}\n" if profile.hypesquad: description += f"they got some hype\n" if profile.partner: description += "insrt BLU INFINITY SYMBOL her\n" if profile.staff: description += "staff. if this is b1nzy, then F**K him for banning selfbots\n" mutual: List[Guild] = profile.mutual_guilds mutual_text = '\n'.join(guild.name for guild in mutual) if len(mutual_text) > 512: mutual_text = f"Together in {len(mutual)} guilds. [Truncated]" em = Embed( title=str(user), description=description, ) if guild: member: Member = guild.get_member(user.id) if member: if guild.owner_id == member.id: em.add_field(name="Owner", value="Yeah", inline=True) em.colour = member.color em.add_field(name="Joined Guild", value=member.joined_at, inline=True) em.add_field(name="Permissions", value=dump_perms(member.guild_permissions), inline=True) em.set_author(name=user.display_name, icon_url=user.avatar_url) em.add_field(name="Mutual guilds", value=mutual_text, inline=True) em.add_field(name="Joined Discord", value=user.created_at, inline=True) for connection in profile.connected_accounts: em.add_field(name=connection['type'], value=('☑' if connection['verified'] else '') + connection['name'], inline=True) em.set_thumbnail(url=user.avatar_url) await ctx.send(embed=em) await ctx.react('✅')
def return_member_or_role( guild: discord.Guild, id: int) -> typing.Union[discord.Member, discord.Role, None]: """メンバーか役職オブジェクトを返す関数 Args: guild (discord.guild): discordのguildオブジェクト id (int): 役職かメンバーのID Returns: typing.Union[discord.Member, discord.Role]: discord.Memberかdiscord.Role """ user_or_role = guild.get_role(id) if user_or_role is None: user_or_role = guild.get_member(id) return user_or_role
async def give_roles(self,invite:discord.Invite,guild:discord.Guild): """Give a role to admins of partners""" if isinstance(invite.guild,discord.Guild): if guild.id == 356067272730607628 and self.bot.beta: return roles = await self.bot.cogs['ServerCog'].find_staff(guild.id,'partner_role') roles = [x for x in [guild.get_role(int(x)) for x in roles.split(';') if len(x)>0 and x.isnumeric()] if x!=None] admins = [x for x in invite.guild.members if x.guild_permissions.administrator] for admin in admins: if admin in guild.members: member = guild.get_member(admin.id) for role in roles: if role not in member.roles: try: await member.add_roles(role) except: pass
async def buildCache(self, guild: discord.Guild, limit=None, startup=False): if limit is None: limit = 500 if startup else 50 GearbotLogging.info( f"Populating modlog with missed messages during downtime for {guild.name} ({guild.id})." ) newCount = 0 editCount = 0 count = 0 no_access = 0 for channel in guild.text_channels: permissions = channel.permissions_for( guild.get_member(self.bot.user.id)) if permissions.read_messages and permissions.read_message_history: async for message in channel.history( limit=limit, oldest_first=False, before=self.cache_message if startup else None): if not self.running: GearbotLogging.info( "Cog unloaded while still building cache, aborting." ) return logged = await LoggedMessage.get_or_none( messageid=message.id) if logged is None: await MessageUtils.insert_message(self.bot, message, redis=False) newCount = newCount + 1 elif message.edited_at is not None: if logged.content != message.content: logged.content = message.content await logged.save() editCount = editCount + 1 count = count + 1 else: no_access += 1 GearbotLogging.info( f"Discovered {newCount} new messages and {editCount} edited in {guild.name} (checked {count})" )
async def init_game_channels( self, guild: discord.Guild) -> discord.CategoryChannel: """ Create the game CategoryChannel and move players into it. Return the CategoryChannel.""" category = await guild.create_category('The Chameleon') await guild.create_text_channel('chameleon-game', category=category) gamevc = await guild.create_voice_channel('The Chameleon', category=category) for player in self.lobby: # player is a User. Get it as a member. member: discord.Member = guild.get_member(player.id) try: await member.move_to(gamevc) except discord.errors.HTTPException: # This means the user was not connected to voice. No worries, just continue. pass return category
async def send_report(self, msg: discord.Message, guild: discord.Guild): author = guild.get_member(msg.author.id) report = msg.clean_content channel_id = await self.config.guild(guild).output_channel() channel = guild.get_channel(channel_id) if channel is None: return None files: List[discord.File] = await Tunnel.files_from_attatch(msg) ticket_number = await self.config.guild(guild).next_ticket() await self.config.guild(guild).next_ticket.set(ticket_number + 1) if await self.bot.embed_requested(channel, author): em = discord.Embed(description=report) em.set_author( name=_("Report from {author}{maybe_nick}").format( author=author, maybe_nick=(f" ({author.nick})" if author.nick else "") ), icon_url=author.avatar_url, ) em.set_footer(text=_("Report #{}").format(ticket_number)) send_content = None else: em = None send_content = _("Report from {author.mention} (Ticket #{number})").format( author=author, number=ticket_number ) send_content += "\n" + report try: await Tunnel.message_forwarder( destination=channel, content=send_content, embed=em, files=files ) except (discord.Forbidden, discord.HTTPException): return None await self.config.custom("REPORT", guild.id, ticket_number).report.set( {"user_id": author.id, "report": report} ) return ticket_number