async def __get_channel(self, guild: discord.Guild) -> discord.TextChannel:
"""Gets the best text channel to use for event notices.
Order of priority:
1. User-defined channel
2. Guild's system channel (if bot can speak in it)
3. First channel that the bot can speak in
"""
channel = None
channel_id = await self.config.guild(guild).channel()
if channel_id is not None:
channel = guild.get_channel(channel_id)
if channel is None or not self.__can_speak_in(channel):
channel = guild.system_channel
if channel is None or not self.__can_speak_in(channel):
for ch in guild.text_channels:
if self.__can_speak_in(ch):
channel = ch
break
return channel
async def _check_all_perms(self, guild: discord.Guild, detailed=False):
"""Check all permissions for all AutoRooms in a guild."""
result_required = True
result_optional = True
result_list = []
avcs = await self.get_all_autoroom_source_configs(guild)
for avc_id, avc_settings in avcs.items():
autoroom_source = guild.get_channel(avc_id)
category_dest = guild.get_channel(avc_settings["dest_category_id"])
if autoroom_source and category_dest:
if detailed:
(
required_check,
optional_check,
detail,
) = self.check_perms_source_dest(
autoroom_source,
category_dest,
with_manage_roles_guild=avc_settings["room_type"] !=
"server",
with_text_channel=avc_settings["text_channel"],
with_optional_clone_perms=True,
split_required_optional_check=True,
detailed=True,
)
result_list.append(detail)
result_required = result_required and required_check
result_optional = result_optional and optional_check
else:
required_check, optional_check = self.check_perms_source_dest(
autoroom_source,
category_dest,
with_manage_roles_guild=avc_settings["room_type"] !=
"server",
with_text_channel=avc_settings["text_channel"],
with_optional_clone_perms=True,
split_required_optional_check=True,
)
result_required = result_required and required_check
result_optional = result_optional and optional_check
if not result_required and not result_optional:
return result_required, result_optional
if detailed:
return result_required, result_optional, result_list
else:
return result_required, result_optional
def __init__(self, guild: discord.Guild):
super().__init__()
self.iterator: discord.guild.AuditLogIterator = guild.audit_logs(
limit=None, action=discord.AuditLogAction.ban)
self._cache: list[discord.AuditLogEntry] = []
self._ncache = 0
self._more = True
self._n_last_fetched = 0
def _find_role(guild: discord.Guild,
argument: str) -> Optional[discord.Role]:
match = _ID_RE.match(argument) or _ROLE_MENTION_RE.match(argument)
if match:
result = guild.get_role(int(match.group(1)))
else:
result = discord.utils.get(guild.roles, name=argument)
return result
async def get_member(guild: discord.Guild, member):
if isinstance(member, discord.Member):
return member
elif isinstance(member, int):
return guild.get_member(int)
elif isinstance(member, str):
return get_member_named(guild, member)
return member
def get_owner(embed: discord.Embed, guild: discord.Guild) -> discord.Member:
value = get_embed_field("Owner", embed)
if value is None:
return
user_id = int(re.search('<@([0-9]*)>', value).groups()[0])
return guild.get_member(user_id)
async def get_member(guild: Guild, user: User) -> Member:
member = guild.get_member(user.id)
if not member:
try:
member = await guild.fetch_member(user.id)
except NotFound:
raise MemberNotFound(f"No member with ID: {user.id} on guild {guild.id}")
return member
async def get_starboard_channel(self, server: discord.Guild) -> discord.TextChannel:
channel_id = await self.get_starboard_channel_id(server)
if (channel_id != 0):
return server.get_channel(channel_id)
return None
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_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)
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 getmuterole(self, guild: discord.Guild):
"""Return the role used to mute users, or None if unavailable."""
role_id_tuple = self.con.execute(
"SELECT role_id FROM moderationsettings WHERE guild_id = ?",
(guild.id, )).fetchone()
# See explanation for the and statements above in the modlog channel section
return role_id_tuple and role_id_tuple[0] and guild.get_role(
role_id_tuple[0])
def closest_user(member_string, guild: discord.Guild):
if member_string.startswith('<@!') and member_string.endswith('>'):
return guild.get_member(int(member_string[3:-1]))
return list(
sorted(guild.members,
key=lambda member: fuzz.partial_token_sort_ratio(
member_string.lower(), member.display_name.lower())))[-1]
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 build_profile_embed(self, karma_member: KarmaMember,
guild: discord.Guild) -> discord.Embed:
"""
Build the profile embed with top channel breakdown configured
:param karma_member: member whose profile to show
:param guild: the discord guild
:return: discord.Embed
"""
channel_cursor = self.karma_service.aggregate_member_by_channels(
karma_member)
embed: discord.Embed = discord.Embed(colour=embed_color)
embed.description = "Karma Profile with breakdown of top {} channels".format(
profile()["channels"])
channel_list = list(channel_cursor)
total_karma = self.karma_service.aggregate_member_by_karma(
karma_member)
if len(channel_list) > 0:
embed.add_field(name="0", value="0", inline=False)
index = 0
for document in channel_list:
channel = guild.get_channel(int(document["_id"]["channel_id"]))
if (index % 3) == 0 and index != 0:
if channel is None:
embed.add_field(
name=bold_field.format("deleted channel"),
value=document["karma"],
inline=False,
)
else:
embed.add_field(
name=bold_field.format(channel.name),
value=document["karma"],
inline=False,
)
else:
if channel is None:
embed.add_field(
name=bold_field.format("deleted channel"),
value=document["karma"],
inline=True,
)
else:
embed.add_field(
name=bold_field.format(channel.name),
value=document["karma"],
inline=True,
)
embed = add_filler_fields(embed, channel_list)
embed.set_field_at(index=0,
name="**total**",
value=str(total_karma),
inline=False)
return embed
else:
# small embed since no karma etc.
embed.add_field(name="**total**", value="0", inline=False)
return embed
async def bump_message(self, guild: discord.Guild):
guild = self.bot.get_guild(guild.id)
if not guild:
return
data = await self.config.guild(guild).all()
channel = guild.get_channel(data["channel"])
if not channel or not channel.permissions_for(guild.me).send_messages:
await self.config.guild(guild).channel.clear()
return
my_perms = channel.permissions_for(guild.me)
if data["lock"] and my_perms.manage_roles:
if my_perms.send_messages is not True:
my_perms.update(send_messages=True)
await channel.set_permissions(
guild.me,
overwrite=my_perms,
reason="DisboardReminder auto-lock")
current_perms = channel.overwrites_for(guild.default_role)
if current_perms.send_messages is not None:
current_perms.update(send_messages=None)
await channel.set_permissions(
guild.default_role,
overwrite=current_perms,
reason="DisboardReminder auto-lock",
)
if data["role"]:
role = guild.get_role(data["role"])
if role:
message = f"{role.mention}: {data['message']}"
await self.bot.get_cog("ForceMention").forcemention(
channel, role, message)
else:
await self.config.guild(guild).role.clear()
else:
message = data["message"]
mentionPerms = discord.AllowedMentions(roles=True)
try:
await channel.send(message, allowed_mentions=mentionPerms)
except discord.errors.Forbidden:
await self.config.guild(guild).channel.clear()
await self.config.guild(guild).nextBump.clear()
def _create_table(cursor: sqlite3.Cursor,
guild: discord.Guild,
*,
show_id: bool = True) -> str:
tabular_data = defaultdict(list)
for strike in cursor:
with contextlib.suppress(IndexError):
user = guild.get_member(strike["user"])
tabular_data[_("User")].append(user)
with contextlib.suppress(IndexError):
mod_id = strike["moderator"]
tabular_data[_("Moderator")].append(
guild.get_member(mod_id) or mod_id)
with contextlib.suppress(IndexError):
strike_id = strike["id"]
tabular_data[_("Time & Date (UTC)")].append(
discord.utils.snowflake_time(strike_id).strftime(
"%Y-%m-%d %H:%M"))
if show_id is True:
tabular_data[_("Strike ID")].append(strike_id)
with contextlib.suppress(IndexError):
strike_count = strike["count"]
tabular_data[_("Strike Count")].append(strike_count)
with contextlib.suppress(IndexError):
recent_id = strike["most_recent_id"]
tabular_data[_("Latest Strike Given (UTC)")].append(
discord.utils.snowflake_time(recent_id).strftime(
"%Y-%m-%d %H:%M"))
with contextlib.suppress(IndexError):
reason = strike["reason"]
if reason:
reason = "\n".join(
pagify(reason,
delims=[" "],
page_length=25,
shorten_by=0))
tabular_data[_("Reason")].append(reason)
if tabular_data:
return tabulate(tabular_data,
headers="keys",
tablefmt="fancy_grid",
numalign="left")
else:
return ""
async def construct(cls, discord_id: int, guild: discord.Guild):
playerobj = cls()
playerobj.data = await models.SRLNick.get_or_none(discord_user_id=discord_id)
if playerobj.data is None:
raise UnableToLookupUserException(f"Unable to pull nick data for {discord_id}")
playerobj.discord_user = guild.get_member(int(discord_id))
return playerobj
async def get_specific_announce_channel(
self, guild: discord.Guild) -> Union[discord.TextChannel, None]:
try:
channel_id = await self.config.guild(guild).get_raw(
self.rule_name, "rule_specific_announce")
return guild.get_channel(channel_id)
except KeyError:
# not set, so is disabled
return None
def get_role_mention(guild: discord.Guild, event: dict):
if event["mention"] is None:
return None
role = guild.get_role(int(event["mention"]))
if role is None:
return None
return role.mention
def create_role_from_file(self, server: discord.Guild, role: discord.Role):
role = server.create_role(
name=role["name"],
colour=discord.Colour(int(role["colour"], base=16)),
permissions=discord.Permissions(role["perms"]),
hoist=role["hoist"],
mentionable=role["mentionable"],
reason=role["reason"])
return role
def get_user_closest_to_name(guild: discord.Guild, name: str):
members = guild.members
member_names = []
for i in members:
member_names.append(i.display_name)
closest = process.extractOne(name, member_names)
if closest is None:
return None
return guild.get_member_named(closest[0])
def can_act(self, guild: discord.Guild, channel: discord.TextChannel,
mod: discord.Member, target: Union[discord.Member,
discord.User]) -> bool:
mod = guild.get_member(mod.id)
target = guild.get_member(target.id)
if mod == None or target == None: return False
rid = self.bot.db.configs.get(guild.id, "mod_role")
if rid != "":
if int(rid) in [x.id for x in target.roles]: return False
roles, channels = self.get_ignored_roles_channels(guild)
if any(x in [i.id for i in target.roles] for x in roles): return False
if channel.id in channels: return False
return mod.id != target.id \
and target.id != guild.owner.id \
and (target.guild_permissions.kick_members == False or target.guild_permissions.kick_members == False)
def get_user_from_mention(guild: discord.Guild, mention: str):
# member_id = get_id_from_mention(mention)
# member = guild.get_member(member_id)
# return member
member_id = get_numbers(mention)
if member_id:
return guild.get_member(member_id)
else:
return None
def get_lfc_settings(self, guild: discord.Guild):
settings = dict()
query = f'SELECT lfc FROM settings WHERE gid={guild.id};'
settings['status'] = self.execute_query(query)[0] == True
query = f'SELECT cid FROM lfc_channels WHERE gid={guild.id};'
r = self.execute_query_many(query)
settings['channels'] = [guild.get_channel(c[0]) for c in r]
settings['role'] = self.get_lfc_role(guild)
return settings
async def getlogchannel(self, guild: discord.Guild):
results = await self.bot.dbquery('logchannel', 'channelid', 'guildid=' + str(guild.id))
if len(results) < 1:
return None
try:
return guild.get_channel(int(results[0][0]))
except:
await self.bot.dbexec("DELETE FROM logchannel WHERE guildid=" + str(guild.id))
return None
async def send_to_changelog(guild: Guild, message: Union[str, Embed]):
channel: Optional[TextChannel] = guild.get_channel(await Settings.get(
int, "logging_changelog", -1))
if channel is not None:
if isinstance(message, str):
embed = Embed(colour=Colours.changelog, description=message)
else:
embed = message
await channel.send(embed=embed)
async def _check_guild(self, guild: discord.Guild):
member_ids: list = await self.config.guild(guild).nicknamed_member_ids()
if len(member_ids) == 0:
return
else:
member: discord.Member
for member in [guild.get_member(id) for id in member_ids]:
await self._check_member(member)
async def on_guild_remove(self, guild: discord.Guild) -> None:
log.info(
f'Left a guild. Name: {guild.name} | ID: {guild.id} | Owner: {guild.owner} | Members: {len(guild.members)}'
)
time = self.bot.utils.format_datetime(datetime=pendulum.now(tz='UTC'))
embed = discord.Embed(
colour=discord.Colour.gold(),
title=f'Left a guild',
description=
f'`Name:` {guild.name}\n`ID:` {guild.id}\n`Owner:` {guild.owner}\n`Time:` {time}\n`Members:` {len(guild.members)}'
)
embed.set_thumbnail(url=str(
guild.icon_url_as(
format='gif' if guild.is_icon_animated() else 'png')))
await self.bot.logging_webhook.send(
embed=embed, avatar_url=guild.icon_url_as(format='png'))
def get_role_from_payload(payload: discord.RawReactionActionEvent,
guild: discord.Guild) -> discord.Role:
g = Guild.objects(guild_id=payload.guild_id).first()
r = Role.objects(id__in=g.roles) \
.filter(message_id=payload.message_id) \
.filter(reaction=payload.emoji.name).first()
if not r:
return None
return guild.get_role(r.role_id)
async def get_tournament_role(self, guild: discord.Guild) -> discord.Role:
# no cache for this one
role_id = await self.data.guild(guild).roles.tournament()
if not role_id:
raise UserInputError("Le rôle de tournois n'est pas réglé.")
role = guild.get_role(role_id)
if not role:
raise UserInputError("Le rôle de tournois a été perdu.")
return role
async def update_bulletin_message(self, guild: discord.Guild,
channel: discord.TextChannel,
message_id: int):
"""
Modifies the bulletin message ID for a guild.
"""
guild = await self.get_or_create_guild(guild)
async with threadpool():
with self.get_session() as sess:
if channel is None:
guild.bulletin_channel = None
else:
guild.bulletin_channel = channel.id
guild.bulletin_message = message_id
sess.add(guild)
return guild
async def on_guild_join(self, guild: discord.Guild):
logger.info(
f"We have been added to a new guild! Hi: f{guild.id}: f{guild.name}"
)
try:
guild = db.Guild[str(guild.id)]
guild.disabled = False
except ObjectNotFound:
db.upsert_guild(str(guild.id), guild.name)
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
async def _get_announce_channel(self, guild: discord.Guild) -> discord.TextChannel:
channel_id = await self.config.guild(guild).announce_channel()
channel = None
if channel_id is not None:
channel = guild.get_channel(channel_id)
if channel is None:
channel = guild.system_channel
if channel is None:
channel = guild.text_channels[0]
return channel
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 get_audit_entry(guild: discord.Guild, action: discord.AuditLogAction,
target: Any = None) -> Optional[discord.AuditLogEntry]:
"""Gets an audit log entry of the specified action type.
The type of the action depends on the action.
:param guild: The guild where the audit log will be checked.
:param action: The action to filter.
:param target: The target to filter.
:return: The first matching audit log entry if found.
"""
if not guild.me.guild_permissions.view_audit_log:
return
now = dt.datetime.utcnow()
after = now - dt.timedelta(0, 5)
async for entry in guild.audit_logs(limit=10, oldest_first=False, action=action, after=after):
if abs((entry.created_at - now)) >= dt.timedelta(seconds=5):
break
if target is not None and entry.target.id == target.id:
return entry
