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]
