def from_dict(cls, time_callback: Callable[[], float], server: discord.Server, data: Dict): self = SprintData(time_callback) self.founder = server.get_member(data['founder']) member_uids = [] for u_id in data['members']: member = server.get_member(u_id) if member is not None: self.members.append(member) member_uids.append(member.id) else: logger.warning( "Can't restore member: ID {} not found on server".format( u_id)) self.start = { u_id: value for u_id, value in data['start'].items() if u_id in member_uids } self.end = { u_id: value for u_id, value in data['end'].items() if u_id in member_uids } self.finalized = set(data['finalized']) self.start_time = self._loop_time(data['start_time']) self.end_time = self._loop_time(data['end_time']) self.warn_times = deque(self._loop_time(t) for t in data['warn_times']) self.finalize_time = self._loop_time(data['finalize_time']) return self
async def _send_update_pm(self, server: discord.Server, subid: str): sub = self.submissions[server.id]["submissions"][subid] user = server.get_member(sub["submitter"]) if sub["status"] == "rejected": await self.bot.send_message( user, "Your emoji submission `{}` in {} has been rejected by {}.\n" "Here is the reason they gave:{}" "As a reminder, here is what your rejected emoji looks like:". format(sub["name"], server.name, server.get_member(sub["rejector"]).mention, cf.box(sub["reject_reason"]))) await self.bot.send_file(user, sub["image"]) await self.bot.send_message( user, "You may fix the problems with your emoji and resubmit it," " or contact the rejector with any questions.") elif sub["status"] == "approved": await self.bot.send_message( user, "Your emoji submission `{}` in {} has been approved by {}.". format(sub["name"], server.name, server.get_member(sub["approver"]).mention))
def parse_channel_mention(mention: str, server: discord.Server) -> discord.Channel: match = re.fullmatch("<#(\\d+)>", mention) if match: return server.get_channel(match.group(1)) try: return server.get_channel(str(int(mention))) except ValueError: return None
def get_notify_channels(server: discord.Server, data_type: str): """ Find the notifying channel or return the server. """ if server.id not in osu_config.data["server"]: return None if data_type + "-channels" not in osu_config.data["server"][server.id]: return None return [server.get_channel(s) for s in osu_config.data["server"][server.id][data_type + "-channels"] if server.get_channel(s)]
def get_notify_channels(server: discord.Server, data_type: str): """ Find the notifying channel or return the server. """ if server.id not in osu_config.data["server"]: return None if data_type + "-channels" not in osu_config.data["server"][server.id]: return None return [ server.get_channel(s) for s in osu_config.data["server"][server.id][data_type + "-channels"] if server.get_channel(s) ]
def query_user(server: discord.Server, id_: str): """ Find a user given an ID string passed by command, or create it if it does not exist. id_ can be passed to a command as a discord mention ``<@123456789012345678>`` or ``<@!123456789012345678>``, or as a Discord ID ``123456789012345678`` (various malformed inputs may also be accepted, e.g., ``@123456789012345678``). For Discord Mention or Discord ID, if the user is not found but exists on Discord, a new entry is created. In other cases, a :cls:`~.UserNotFound` error is raised. :raises UserNotFound: User was not found. Either the Discord user exists neither on Discord nor in the database, or a database ID was passed and could not be found. :raises discord.HTTPException: Discord API error occurred :raises db.exc.MultipleResultsFound: Should never happen - database is buggered. """ # Parse the passed ID try: discord_id = extract_user_id(id_) except discord.InvalidArgument: raise ValueError('Invalid Discord user ID format') logger.debug('query_user: passed Discord ID: {}'.format(discord_id)) # Check if user exists try: db_user = session.query(User).filter_by(discord_id=discord_id).one() except db.orm_exc.MultipleResultsFound: logger.exception("Er, mate, I think we've got a problem here. " "The database is buggered.") raise except db.orm_exc.NoResultFound: logger.debug('query_user: user not found, creating user') try: member = server.get_member(discord_id) # type: discord.Member except discord.NotFound as e: raise UserNotFound('Discord user not found') from e db_user = create_user(member) logger.debug('query_user: created user: {!r}'.format(db_user)) else: logger.debug('query_user: found user: {!r}'.format(db_user)) try: member = server.get_member(discord_id) # type: discord.Member except discord.NotFound: logger.warning("Can't find user {!r} on Discord, skipping update nicknames" .format(db_user)) else: update_nicknames(db_user, member) return db_user
def _get_welcome_channels(self, server: discord.Server): settings = self._get_settings(server) for channel_id in settings["CHANNELS"]: if settings["CHANNELS"][channel_id]["ENABLED"]: channel = server.get_channel(channel_id) if channel is not None: yield channel
def team_members(team: RWTeam, color=None, server: discord.Server = None, server_members: dict = None): if color is None: color = random_discord_color() em = discord.Embed(title=team.name, description='#{}'.format(team.tag), color=color) tag2id = {v: k for k, v in server_members.items()} o = [] for m in team.members: user_id = tag2id.get(m.tag) user = None if user_id is not None: user = server.get_member(user_id) o.append("{name} #{tag}, {role}, {trophies} {d_name}".format( name=remove_color_tags(m.name), tag=m.tag, role=m.role, trophies=m.stars, d_name=user if user else "----")) count = 10 pagified = grouper(o, count) for index, page in enumerate(pagified): v = [line for line in page if line is not None] em.add_field(name="Members {}-{}".format(index * 10 + 1, index * 10 + len(v)), value='\n'.join(v)) return em
def speak_permissions(self, server: discord.Server, channel: discord.Channel = None): if not channel: channel = self.get_welcome_channel(server) return server.get_member( self.bot.user.id).permissions_in(channel).send_messages
def get_birthday_count(self, server: discord.Server): count = 0 for user_bd in self.user_birthdays: if user_bd.server_id == server.id and server.get_member( user_bd.user_id) is not None: count += 1 return count
async def new_case(self, server: discord.Server, *, action, mod=None, user, reason=None, until=None, channel=None, force_create=False): actionsSet = self.get_server(server) action = action.upper() isEnabled = actionsSet[action] if not force_create and not isEnabled: return False mod_channel = server.get_channel( self._owner_settings[server.id]["mod-log"]) if mod_channel is None: return None case_n = len(self.cases[server.id]) + 1 case = { "case": case_n, "created": datetime.utcnow().timestamp(), "modified": None, "action": actionsSet[action]['Repr'] + actionsSet[action]['Deco'], "channel": channel.id if channel else None, "channel_mention": channel.mention if channel else None, "user": str(user) if user is not None else None, "user_id": user.id if user is not None else None, "reason": reason, "moderator": str(mod) if mod is not None else None, "moderator_id": mod.id if mod is not None else None, "amended_by": None, "amended_id": None, "message": None, "until": until.timestamp() if until else None, } case_msg = self.format_case_msg(case) try: msg = await self.bot.send_message(mod_channel, case_msg) case["message"] = msg.id except: pass self.cases[server.id][str(case_n)] = case if mod: self.last_case[server.id][mod.id] = case_n dataIO.save_json(self._cases_path, self.cases) return case_n
def convert_disc_channel(message, author, irc_client, discord_server: Server): try: return CHANNEL_RE.sub( lambda match: "#{}".format( discord_server.get_channel(match.group(1)).name), message) except: return message
async def send_welcome(self, server: discord.Server, member: discord.Member, invite: discord.Invite = discord.Invite()): message = self.config[server.id]['joinmessage'] channel = self.config[server.id]["Channel"] if self.config[server.id]["Embed"]: data = discord.Embed( title="ID: {}".format(member.id), description=message.format(member, invite, server), colour=discord.Colour(value=randint(0, 0xFFFFFF))) data.set_thumbnail(url=member.avatar_url) await self.bot.send_message(server.get_channel(channel), embed=data) else: await self.bot.send_message(server.get_channel(channel), message.format(member, invite, server))
def get_user_color(user: discord.User, server: discord.Server) -> discord.Colour: """Gets the user's color based on the highest role with a color""" # If it's a PM, server will be none if server is None: return discord.Colour.default() member = server.get_member(user.id) # type: discord.Member if member is not None: return member.colour return discord.Colour.default()
def on_ready(self, data): self.mind.svc_message('Connection to discord established.') self.gateway = data.get('_trace', ('unknown gateway',))[0] self.set_meta(data.get('user')) for guild in data.get('guilds', []): unavailable = guild.get('unavailable', None) if unavailable is None or unavailable is False: # it's available! server = Server(**guild) server.me = property(lambda s: s.get_member(self.user.id)) self.mind.add_guild(server) if self.server_id is None: self.server_id = server.id if self.server_id == server.id: def join_fail(err): print(err) def join_success(_, s, channel): self.mind.names(self.mind.nickname, '#' + channel.name.replace(' ', '_'), [member.name.replace(' ', '_') for member in channel.members]) self.mind.topic(self.mind.nickname, '#' + channel.name.replace(' ', '_'), channel.topic) for chan in server.channels: if str(chan.type) != 'text': continue if not chan.permissions_for(chan.server.get_member(self.id)).read_messages: continue d = self.realm.createGroup(chan.server, chan) d.addCallback(self.mind.userJoined, self.mind) d.addCallback(join_success, server, chan) d.addErrback(join_fail) pass else: self._lazy_guilds = self._lazy_guilds + 1 for pm in data.get('private_channels', []): self.mind.add_private_channel(PrivateChannel(id=pm['id'], user=DiscordUser(**pm['recipient'])))
async def update_user_roles(bot: discord.Client, server: discord.Server, users: Sequence[m.User]): # noinspection PyTypeChecker role_ids = [o.role_id for o in q.query_genres() + q.query_project_types()] project_roles = set(get_role(server, role_id) for role_id in role_ids if role_id is not None) for u in users: member = server.get_member(u.discord_id) desired_roles = set() for taxon in {u.genre, u.type} - {None}: if taxon.role_id is not None: desired_roles.add(get_role(server, taxon.role_id)) new_roles = (set(member.roles) - project_roles) | desired_roles await bot.replace_roles(member, *new_roles)
def get_member(bot: discord.Client, user_id, server: discord.Server = None, server_list=None) -> discord.Member: """Returns a member matching the id If no server_id is specified, the first member matching the id will be returned, meaning that the server he belongs to will be unknown, so member-only functions may be inaccurate. User functions remain the same, regardless of server""" if server_list is not None and len(server_list) > 0: members = [m for ml in [s.members for s in server_list] for m in ml] return discord.utils.find(lambda m: m.id == str(user_id), members) if server is not None: return server.get_member(str(user_id)) else: return discord.utils.get(bot.get_all_members(), id=str(user_id))
def find_member(server: discord.Server, 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 server: discord.Server 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 = server.get_member(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], server.members) if member: break # Return the found member or None return member
async def show_list(self, server: discord.Server): alive = [] fallen = [] for user in self.list: name = server.get_member(user) if not name: continue name = name.display_name if self.list[user]: alive.append(name) else: fallen.append(name) await self.bot.say( 'Those who still live:\n' + ', '.join(alive) + '\n\nThose who sacrificed everything for a better universe:\n' + ', '.join(fallen))
def find_channel(server: discord.Server, name, steps=3, mention=True): """ Find any channel by its 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 server: discord.Server to look through for channels. :param name: name as a string or mention to find. :param steps: int from 0-3 to specify search depth. :param mention: check for mentions. """ channel = None # Return a member from mention found_mention = re.search(r"<#([0-9]+)>", name) if found_mention and mention: channel = server.get_channel(found_mention.group(1)) if not channel: # Steps to check, higher values equal more fuzzy checks checks = [ lambda c: c.name.lower() == name.lower(), lambda c: c.name.lower().startswith(name.lower()), lambda c: name.lower() in c.name.lower() ] for i in range(steps if steps <= len(checks) else len(checks)): channel = discord.utils.find(checks[i], server.channels) if channel: break # Return the found channel or None return channel
def find_member(server: discord.Server, 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 server: discord.Server 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: check for mentions. """ member = None # Return a member from mention found_mention = member_mention_regex.search(name) if found_mention and mention: member = server.get_member(found_mention.group("id")) name = name.lower() if not member: # Steps to check, higher values equal more fuzzy checks checks = [lambda m: m.display_name.lower() == name, lambda m: m.display_name.lower().startswith(name), lambda m: name in m.display_name.lower()] for i in range(steps if steps <= len(checks) else len(checks)): member = discord.utils.find(checks[i], server.members) if member: break # Return the found member or None return member
def find_channel(server: discord.Server, name, steps=3, mention=True): """ Find any channel by its 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 server: discord.Server to look through for channels. :param name: name as a string or mention to find. :param steps: int from 0-3 to specify search depth. :param mention: check for mentions. """ channel = None # Return a member from mention found_mention = channel_mention_regex.search(name) if found_mention and mention: channel = server.get_channel(found_mention.group("id")) if not channel: # Steps to check, higher values equal more fuzzy checks checks = [lambda c: c.name.lower() == name.lower(), lambda c: c.name.lower().startswith(name.lower()), lambda c: name.lower() in c.name.lower()] for i in range(steps if steps <= len(checks) else len(checks)): channel = discord.utils.find(checks[i], server.channels) if channel: break # Return the found channel or None return channel
def check_claim_eligibility(self, author: discord.User, server: discord.Server, uuid: str) -> str: """Loop through `data/claimed.csv` to make sure a user isn't claiming a second or duplicate account. Args: author (discord.User): The user we're checking. server (discord.Server): The server the claim originated from. uuid (str): The UUID of the Minecraft account. Returns: str: Message describing any or lack of conflicts. """ with open(self.claimfile, 'r', newline='') as claimed_file: reader = csv.DictReader(claimed_file) for row in reader: # Respond whether we get a UUID match, Discord ID match, # or no match if (row['DISCORD_ID'] == author.id): msg = 'You already registered account {} [`{}`].' return msg.format(row['USERNAME'], row['UUID']) elif (row['UUID'] == uuid): if server.get_member(row['DISCORD_ID']): tag = row['DISCORD_MENTION'] else: tag = row['DISCORD_NICK'] msg = '{} already claimed account {} [`{}`].' return msg.format(tag, row['USERNAME'], row['UUID']) # The for loop doesn't execute if there are no rows in the file. # Thus, this part is outside to catch both 'not found' and # 'fresh file' cases. msg = 'OK for you to register this nick with this account.' return msg
def get_economy_ranks(self, server: discord.Server, time_id: str, top_max=5): """Return economy ranks by time id as a list.""" out = [] out.append("__Richest members__") economy = self.bot.get_cog("Economy") if economy is not None: bank = economy.bank if bank is not None: if server.id in bank.accounts: accounts = bank.accounts[server.id] accounts = dict( sorted(accounts.items(), key=lambda x: -x[1]["balance"])) for i, (k, v) in enumerate(accounts.items()): if i < top_max: member = server.get_member(k) if member: out.append("`{:>2}.` {} ({} credits)".format( str(i + 1), member.display_name, str(v["balance"]))) return out
def speak_permissions(self, server: discord.Server, channel: discord.Channel=None): return server.get_member( self.bot.user.id).permissions_in(channel).send_messages
def _get_tempbanned_members_db( server: discord.Server) -> List[model.Record]: records = c.query_unexpired_records(types=RecordType.temp) members_raw = (server.get_member(record.user.discord_id) for record in records) return [m for m in members_raw if m is not None]
def find_channel(server: discord.Server, name, steps=3, mention=True, channel_type="text"): """ Find any channel by its 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 server: discord.Server to look through for channels. :param name: name as a string or mention to find. :param steps: int from 0-3 to specify search depth. :param mention: check for mentions. :param channel_type: what type of channel we're looking for. Can be str or discord.ChannelType. :returns: discord.Channel """ channel = None # We want to allow both str and discord.ChannelType, so try converting str and handle exceptions if type(channel_type) is str: try: channel_type = getattr(discord.ChannelType, channel_type) except AttributeError: raise TypeError( "channel_type (str) must be an attribute of discord.ChannelType" ) elif type(channel_type) is not discord.ChannelType: raise TypeError( "channel_type must be discord.ChannelType or a str of a discord.ChannelType attribute" ) # Return a member from mention found_mention = channel_mention_regex.search(name) if found_mention and mention and channel_type is discord.ChannelType.text: channel = server.get_channel(found_mention.group("id")) if not channel: # Steps to check, higher values equal more fuzzy checks checks = [ lambda c: c.name.lower() == name.lower() and c.type is channel_type, lambda c: c.name.lower( ).startswith(name.lower()) and c.type is channel_type, lambda c: name.lower() in c.name.lower() and c.type is channel_type ] for i in range(steps if steps <= len(checks) else len(checks)): channel = discord.utils.find(checks[i], server.channels) if channel: break # Return the found channel or None return channel
async def run_racfaudit(self, server: discord.Server, clan_filters=None) -> AuditResult: """Run audit and return results.""" audit_results = { "elder_promotion_req": [], "coleader_promotion_req": [], "leader_promotion_req": [], "no_discord": [], "no_clan_role": [], "no_member_role": [], "not_in_our_clans": [], } error = False out = [] try: member_models = await self.family_member_models() except ClashRoyaleAPIError as e: # await self.bot.say(e.status_message) error = True else: out.append("**100T Family Audit**") # associate Discord user to member for member_model in member_models: tag = clean_tag(member_model.get('tag')) try: discord_id = self.players[tag]["user_id"] except KeyError: pass else: member_model['discord_member'] = server.get_member(discord_id) # find member_models mismatch discord_members = [] for member_model in member_models: has_discord = member_model.get('discord_member') if has_discord is None: audit_results["no_discord"].append(member_model) if has_discord: discord_member = member_model.get('discord_member') discord_members.append(discord_member) # promotions is_elder = False is_coleader = False is_leader = False for r in discord_member.roles: if r.name.lower() == 'elder': is_elder = True if r.name.lower() == 'coleader': is_coleader = True if r.name.lower() == 'leader': is_leader = True if is_elder: if member_model.get('role').lower() != 'elder': audit_results["elder_promotion_req"].append(member_model) if is_coleader: if member_model.get('role').lower() != 'coleader': audit_results["coleader_promotion_req"].append(member_model) if is_leader: if member_model.get('role').lower() != 'leader': audit_results["leader_promotion_req"].append(member_model) # no clan role clan_name = member_model['clan']['name'] clan_role_name = self.clan_roles[clan_name] if clan_role_name not in [r.name for r in discord_member.roles]: audit_results["no_clan_role"].append({ "discord_member": discord_member, "member_model": member_model }) # no member role discord_role_names = [r.name for r in discord_member.roles] if 'Member' not in discord_role_names: audit_results["no_member_role"].append(discord_member) # find discord member with roles for user in server.members: user_roles = [r.name for r in user.roles] if 'Member' in user_roles: if user not in discord_members: audit_results['not_in_our_clans'].append(user) # show results def list_member(member_model): """member row""" clan = member_model.get('clan') clan_name = None if clan is not None: clan_name = clan.get('name') row = "**{name}** #{tag}, {clan_name}, {role}, {trophies}".format( name=member_model.get('name'), tag=member_model.get('tag'), clan_name=clan_name, role=get_role_name(member_model.get('role')), trophies=member_model.get('trophies') ) return row for clan in self.config['clans']: # await self.bot.type() await asyncio.sleep(0) display_output = False if clan_filters: for c in clan_filters: if c.lower() in clan['name'].lower(): display_output = True else: display_output = True if not display_output: continue if clan['type'] == 'Member': out.append("-" * 40) out.append(inline(clan.get('name'))) # no discord out.append(underline("Members without discord")) for member_model in audit_results["no_discord"]: try: if member_model['clan']['name'] == clan.get('name'): out.append(list_member(member_model)) except KeyError: pass # elders out.append(underline("Elders need promotion")) for member_model in audit_results["elder_promotion_req"]: try: if member_model['clan']['name'] == clan.get('name'): out.append(list_member(member_model)) except KeyError: pass # coleaders out.append(underline("Co-Leaders need promotion")) for member_model in audit_results["coleader_promotion_req"]: try: if member_model['clan']['name'] == clan.get('name'): out.append(list_member(member_model)) except KeyError: pass # clan role out.append(underline("No clan role")) for result in audit_results["no_clan_role"]: try: if result["member_model"]['clan']['name'] == clan.get('name'): out.append(result['discord_member'].mention) except KeyError: pass # not in our clans out.append("-" * 40) out.append(underline("Discord users not in our clans but with member roles")) for result in audit_results['not_in_our_clans']: out.append('`{}` {}'.format(result, result.id)) return AuditResult( audit_results=audit_results, output=out, error=error )
def getServerChannel(self, s:Server) -> Channel: if s.id in self.serverChannels.keys(): return s.get_channel(self.serverChannels[s.id]) else: return s.default_channel
async def clear(ctx): if ctx.message.author == me: await bot.purge_from(Server.get_channel(ctx.message.server,'431806042377289739')) else: await bot.say("You are not permitted to do that")
async def run(self, server: discord.Server = None, exec=False, status_channel=None): """Run audit against server.""" results = dict() # Fetch club info clubs = await self.cog._get_clubs(server.id) for r, club_tag, in zip(clubs.results, clubs.club_tags): if isinstance(r, Exception): raise BrawlStarsAuditException() results[club_tag] = r tag2id = self.cog.tag_to_id(server_id=server.id) member_ids = [] # for each member, find discord user id for club_tag, club in results.items(): for member in club.get('members', []): member_tag = member.get('tag') if member_tag is not None: user_id = tag2id.get(member_tag) member_ids.append(user_id) member["discord_user_id"] = user_id # non members non_member_ids = [ m.id for m in server.members if m.id not in member_ids ] cfg = await self.cog._get_server_config(server_id=server.id) club_tag_to_club_roles = {} club_role_names = [] for club in cfg.get('clubs', []): club_tag_to_club_roles[club.get('tag')] = [ discord.utils.get(server.roles, name=name) for name in club.get('roles', []) ] club_role_names += club.get('roles') all_club_roles = [ discord.utils.get(server.roles, name=name) for name in club_role_names ] bs_member_role = discord.utils.get(server.roles, name="BS-Member") bs_member_roles = [bs_member_role] + all_club_roles if status_channel: for member_id in non_member_ids: user = server.get_member(member_id) if user is not None: if bs_member_role in user.roles: await self.cog.bot.send_message( status_channel, "{} is not in our clubs".format(user)) if exec: await self.exec_remove_roles( user, bs_member_roles, channel=status_channel) for member_id in member_ids: user = server.get_member(member_id) if user is not None: if bs_member_role not in user.roles: await self.cog.bot.send_message( status_channel, "{} is in our clubs".format(user)) if exec: await self.exec_add_roles(user, [bs_member_role], channel=status_channel) # clubs for club_tag, club in results.items(): club_member_ids = [] for member in club.get('members', []): user_id = member.get('discord_user_id') if user_id is not None: club_member_ids.append(user_id) non_club_member_ids = [ m.id for m in server.members if m.id not in club_member_ids ] club_roles = club_tag_to_club_roles[club_tag] club_role = club_roles[0] # members for user_id in club_member_ids: user = server.get_member(user_id) if user is not None: if club_role not in user.roles: await self.cog.bot.send_message( status_channel, "{} is in {}".format(user, club.get('name'))) if exec: await self.exec_add_roles(user, [club_role], channel=status_channel) for user_id in non_club_member_ids: user = server.get_member(user_id) if user is not None: if club_role in user.roles: await self.cog.bot.send_message( status_channel, "{} is not in {}".format(user, club.get('name'))) if exec: await self.exec_remove_roles( user, [club_role], channel=status_channel) # add visitor for those who don’t have normal roles # if exec: # visitor_role = discord.utils.get(server.roles, name='Visitor') # membership_role_names = ['Member', 'BS-Member', 'BOT', 'Guest', 'Visitor'] # for user in server.members: # try: # user_role_names = [r.name for r in user.roles] # if len(set(user_role_names) & set(membership_role_names)) == 0: # await self.exec_add_roles(user, [visitor_role], channel=status_channel) # except Exception as e: # await self.cog.bot.send_emssage(status_channel, "Error auditing {}".format(user)) # print_json(results) await self.cog.bot.send_message(status_channel, "Audit finished")
def convert_disc_channel(message, author, irc_client, discord_server: Server): try: return CHANNEL_RE.sub(lambda match: "#{}".format(discord_server.get_channel(match.group(1)).name), message) except: return message
def get_welcome_channel(self, server: discord.Server): return server.get_channel(self.settings[server.id]["channel"])
def as_member_of(self, server: discord.Server) -> discord.Member: return server.get_member(self.user.id)
def get_admin_count(self, server: discord.Server): count = 0 for admin in self.user_admins: if admin.server_id == server.id and server.get_member(admin.user_id) is not None: count += 1 return count
def _get_permabanned_members_db(server: discord.Server) -> List[Tuple[User, discord.Member]]: records = controller.query_unexpired_records(types=RecordType.perma) members_raw = ((r.user, server.get_member(r.user.discord_id)) for r in records) return [m for m in members_raw if m[1] is not None]