async def apply_voice_ban(self, ctx: Context, user: UserSnowflake,
reason: t.Optional[str], **kwargs) -> None:
"""Apply a voice ban infraction with kwargs passed to `post_infraction`."""
if await _utils.get_active_infraction(ctx, user, "voice_ban"):
return
infraction = await _utils.post_infraction(ctx,
user,
"voice_ban",
reason,
active=True,
**kwargs)
if infraction is None:
return
self.mod_log.ignore(Event.member_update, user.id)
if reason:
reason = textwrap.shorten(reason, width=512, placeholder="...")
await user.move_to(None,
reason="Disconnected from voice to apply voiceban.")
action = user.remove_roles(self._voice_verified_role, reason=reason)
await self.apply_infraction(ctx, infraction, user, action)
async def apply_infraction(
self,
ctx: Context,
infraction: _utils.Infraction,
user: UserSnowflake,
action_coro: t.Optional[t.Awaitable] = None,
user_reason: t.Optional[str] = None,
additional_info: str = "",
) -> bool:
"""
Apply an infraction to the user, log the infraction, and optionally notify the user.
`user_reason`, if provided, will be sent to the user in place of the infraction reason.
`additional_info` will be attached to the text field in the mod-log embed.
Returns whether or not the infraction succeeded.
"""
infr_type = infraction["type"]
icon = _utils.INFRACTION_ICONS[infr_type][0]
reason = infraction["reason"]
expiry = time.format_infraction_with_duration(infraction["expires_at"])
id_ = infraction['id']
if user_reason is None:
user_reason = reason
log.trace(f"Applying {infr_type} infraction #{id_} to {user}.")
# Default values for the confirmation message and mod log.
confirm_msg = ":ok_hand: applied"
# Specifying an expiry for a note or warning makes no sense.
if infr_type in ("note", "warning"):
expiry_msg = ""
else:
expiry_msg = f" until {expiry}" if expiry else " permanently"
dm_result = ""
dm_log_text = ""
expiry_log_text = f"\nExpires: {expiry}" if expiry else ""
log_title = "applied"
log_content = None
failed = False
# DM the user about the infraction if it's not a shadow/hidden infraction.
# This needs to happen before we apply the infraction, as the bot cannot
# send DMs to user that it doesn't share a guild with. If we were to
# apply kick/ban infractions first, this would mean that we'd make it
# impossible for us to deliver a DM. See python-discord/bot#982.
if not infraction["hidden"]:
dm_result = f"{constants.Emojis.failmail} "
dm_log_text = "\nDM: **Failed**"
# Sometimes user is a discord.Object; make it a proper user.
try:
if not isinstance(user, (discord.Member, discord.User)):
user = await self.bot.fetch_user(user.id)
except discord.HTTPException as e:
log.error(
f"Failed to DM {user.id}: could not fetch user (status {e.status})"
)
else:
# Accordingly display whether the user was successfully notified via DM.
if await _utils.notify_infraction(
user,
infr_type.replace("_", " ").title(), expiry,
user_reason, icon):
dm_result = ":incoming_envelope: "
dm_log_text = "\nDM: Sent"
end_msg = ""
if infraction["actor"] == self.bot.user.id:
log.trace(
f"Infraction #{id_} actor is bot; including the reason in the confirmation message."
)
if reason:
end_msg = f" (reason: {textwrap.shorten(reason, width=1500, placeholder='...')})"
elif is_mod_channel(ctx.channel):
log.trace(f"Fetching total infraction count for {user}.")
infractions = await self.bot.api_client.get(
"bot/infractions", params={"user__id": str(user.id)})
total = len(infractions)
end_msg = f" (#{id_} ; {total} infraction{ngettext('', 's', total)} total)"
# Execute the necessary actions to apply the infraction on Discord.
if action_coro:
log.trace(
f"Awaiting the infraction #{id_} application action coroutine."
)
try:
await action_coro
if expiry:
# Schedule the expiration of the infraction.
self.schedule_expiration(infraction)
except discord.HTTPException as e:
# Accordingly display that applying the infraction failed.
# Don't use ctx.message.author; antispam only patches ctx.author.
confirm_msg = ":x: failed to apply"
expiry_msg = ""
log_content = ctx.author.mention
log_title = "failed to apply"
log_msg = f"Failed to apply {' '.join(infr_type.split('_'))} infraction #{id_} to {user}"
if isinstance(e, discord.Forbidden):
log.warning(f"{log_msg}: bot lacks permissions.")
elif e.code == 10007 or e.status == 404:
log.info(
f"Can't apply {infraction['type']} to user {infraction['user']} because user left from guild."
)
else:
log.exception(log_msg)
failed = True
if failed:
log.trace(
f"Deleted infraction {infraction['id']} from database because applying infraction failed."
)
try:
await self.bot.api_client.delete(f"bot/infractions/{id_}")
except ResponseCodeError as e:
confirm_msg += " and failed to delete"
log_title += " and failed to delete"
log.error(
f"Deletion of {infr_type} infraction #{id_} failed with error code {e.status}."
)
infr_message = ""
else:
infr_message = f" **{' '.join(infr_type.split('_'))}** to {user.mention}{expiry_msg}{end_msg}"
# Send a confirmation message to the invoking context.
log.trace(f"Sending infraction #{id_} confirmation message.")
await ctx.send(f"{dm_result}{confirm_msg}{infr_message}.")
# Send a log message to the mod log.
# Don't use ctx.message.author for the actor; antispam only patches ctx.author.
log.trace(f"Sending apply mod log for infraction #{id_}.")
await self.mod_log.send_log_message(
icon_url=icon,
colour=Colours.soft_red,
title=f"Infraction {log_title}: {' '.join(infr_type.split('_'))}",
thumbnail=user.avatar_url_as(static_format="png"),
text=textwrap.dedent(f"""
Member: {messages.format_user(user)}
Actor: {ctx.author.mention}{dm_log_text}{expiry_log_text}
Reason: {reason}
{additional_info}
"""),
content=log_content,
footer=f"ID {infraction['id']}")
log.info(f"Applied {infr_type} infraction #{id_} to {user}.")
return not failed
async def pardon_infraction(self,
ctx: Context,
infr_type: str,
user: UserSnowflake,
send_msg: bool = True) -> None:
"""
Prematurely end an infraction for a user and log the action in the mod log.
If `send_msg` is True, then a pardoning confirmation message will be sent to
the context channel. Otherwise, no such message will be sent.
"""
log.trace(f"Pardoning {infr_type} infraction for {user}.")
# Check the current active infraction
log.trace(f"Fetching active {infr_type} infractions for {user}.")
response = await self.bot.api_client.get('bot/infractions',
params={
'active': 'true',
'type': infr_type,
'user__id': user.id
})
if not response:
log.debug(f"No active {infr_type} infraction found for {user}.")
await ctx.send(
f":x: There's no active {infr_type} infraction for user {user.mention}."
)
return
# Deactivate the infraction and cancel its scheduled expiration task.
log_text = await self.deactivate_infraction(response[0],
send_log=False)
log_text["Member"] = messages.format_user(user)
log_text["Actor"] = ctx.author.mention
log_content = None
id_ = response[0]['id']
footer = f"ID: {id_}"
# Accordingly display whether the user was successfully notified via DM.
dm_emoji = ""
if log_text.get("DM") == "Sent":
dm_emoji = ":incoming_envelope: "
elif "DM" in log_text:
dm_emoji = f"{constants.Emojis.failmail} "
# Accordingly display whether the pardon failed.
if "Failure" in log_text:
confirm_msg = ":x: failed to pardon"
log_title = "pardon failed"
log_content = ctx.author.mention
log.warning(
f"Failed to pardon {infr_type} infraction #{id_} for {user}.")
else:
confirm_msg = ":ok_hand: pardoned"
log_title = "pardoned"
log.info(f"Pardoned {infr_type} infraction #{id_} for {user}.")
# Send a confirmation message to the invoking context.
if send_msg:
log.trace(
f"Sending infraction #{id_} pardon confirmation message.")
await ctx.send(
f"{dm_emoji}{confirm_msg} infraction **{' '.join(infr_type.split('_'))}** for {user.mention}. "
f"{log_text.get('Failure', '')}")
# Move reason to end of entry to avoid cutting out some keys
log_text["Reason"] = log_text.pop("Reason")
# Send a log message to the mod log.
await self.mod_log.send_log_message(
icon_url=_utils.INFRACTION_ICONS[infr_type][1],
colour=Colours.soft_green,
title=f"Infraction {log_title}: {' '.join(infr_type.split('_'))}",
thumbnail=user.avatar_url_as(static_format="png"),
text="\n".join(f"{k}: {v}" for k, v in log_text.items()),
footer=footer,
content=log_content,
)