From 5e573141e6f8d66783c3a45160d202d5e1675382 Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Mon, 21 Jun 2021 23:13:18 +0200
Subject: [PATCH 001/120] Added function to user other units than days for
 mutes/bans

---
 moderation/mod/cog.py              | 123 +++++++++++++++++++----------
 moderation/mod/models.py           |  12 +--
 moderation/mod/translations/en.yml |  51 ++++++------
 3 files changed, 115 insertions(+), 71 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index e5aa02844..7fee766db 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -1,6 +1,7 @@
 import re
 from datetime import datetime, timedelta
-from typing import Optional, Union, List, Tuple
+from dateutil.relativedelta import relativedelta
+from typing import Optional, Union, List, Tuple, Generator
 
 from discord import Role, Guild, Member, Forbidden, HTTPException, User, Embed, NotFound, Message
 from discord.ext import commands, tasks
@@ -36,17 +37,54 @@
 t = t.mod
 
 
+days_in_minutes = 60*60*24
+
+
 class DurationConverter(Converter):
     async def convert(self, ctx, argument: str) -> Optional[int]:
         if argument.lower() in ("inf", "perm", "permanent", "-1", "∞"):
             return None
-        if (match := re.match(r"^(\d+)d?$", argument)) is None:
+        if (match := re.match(r"^(\d+y)?(\d+m)?(\d+w)?(\d+d)?(\d+h)?(\d+n)?$", argument)) is None:
             raise BadArgument(tg.invalid_duration)
-        if (days := int(match.group(1))) <= 0:
+
+        minutes = ToMinutes.convert(*[ToMinutes.toint(match.group(i)) for i in range(1, 7)])
+
+        if minutes <= 0:
             raise BadArgument(tg.invalid_duration)
-        if days >= (1 << 31):
+        if minutes >= (1 << 31):
             raise BadArgument(t.invalid_duration_inf)
-        return days
+        return minutes
+
+
+class ToMinutes:
+    @staticmethod
+    def toint(value: str) -> int:
+        return 0 if value is None else int(value[:-1])
+
+    @staticmethod
+    def convert(years: int, months: int, weeks: int, days: int, hours: int, minutes: int) -> int:
+        days += years * 365
+        days += months * 30
+        days += weeks * 7
+
+        td = timedelta(days=days, hours=hours, minutes=minutes)
+        return int(td.total_seconds() / 60)
+
+
+def time_to_units(minutes: Union[int, float]) -> str:
+    rd = relativedelta(datetime.fromtimestamp(0) + timedelta(minutes=minutes),
+                       datetime.fromtimestamp(0))  # Workaround that should be improved later
+
+    def generator() -> Generator:
+        for unit in [t.times.years(cnt=rd.years),
+                     t.times.months(cnt=rd.months),
+                     t.times.days(cnt=rd.days),
+                     t.times.hours(cnt=rd.hours),
+                     t.times.minutes(cnt=rd.minutes)]:
+            if not str(unit).startswith("0"):
+                yield str(unit)
+
+    return ", ".join(generator())
 
 
 async def get_mute_role(guild: Guild) -> Role:
@@ -96,7 +134,7 @@ async def send_to_changelog_mod(
 
 
 class ModCog(Cog, name="Mod Tools"):
-    CONTRIBUTORS = [Contributor.Defelo, Contributor.wolflu, Contributor.Florian]
+    CONTRIBUTORS = [Contributor.Defelo, Contributor.wolflu, Contributor.Florian, Contributor.LoC]
 
     async def on_ready(self):
         guild: Guild = self.bot.guilds[0]
@@ -118,7 +156,7 @@ async def mod_loop(self):
         guild: Guild = self.bot.guilds[0]
 
         async for ban in await db.stream(filter_by(Ban, active=True)):
-            if ban.days != -1 and datetime.utcnow() >= ban.timestamp + timedelta(days=ban.days):
+            if ban.minutes != -1 and datetime.utcnow() >= ban.timestamp + timedelta(minutes=ban.minutes):
                 await Ban.deactivate(ban.id)
 
                 try:
@@ -140,7 +178,7 @@ async def mod_loop(self):
             return
 
         async for mute in await db.stream(filter_by(Mute, active=True)):
-            if mute.days != -1 and datetime.utcnow() >= mute.timestamp + timedelta(days=mute.days):
+            if mute.minutes != -1 and datetime.utcnow() >= mute.timestamp + timedelta(minutes=mute.minutes):
                 if member := guild.get_member(mute.member):
                     await member.remove_roles(mute_role)
                 else:
@@ -190,17 +228,17 @@ async def count(cls):
     async def handle_get_user_status_entries(self, user_id: int) -> list[tuple[str, str]]:
         status = t.none
         if (ban := await db.get(Ban, member=user_id, active=True)) is not None:
-            if ban.days != -1:
-                expiry_date: datetime = ban.timestamp + timedelta(days=ban.days)
-                days_left = (expiry_date - datetime.utcnow()).days + 1
-                status = t.status_banned_days(cnt=ban.days, left=days_left)
+            if ban.minutes != -1:
+                expiry_date: datetime = ban.timestamp + timedelta(minutes=ban.minutes)
+                time_left = time_to_units((expiry_date - datetime.utcnow()).total_seconds()/60 + 1)
+                status = t.status_banned_time(time_to_units(ban.minutes), time_left)
             else:
                 status = t.status_banned
         elif (mute := await db.get(Mute, member=user_id, active=True)) is not None:
-            if mute.days != -1:
-                expiry_date: datetime = mute.timestamp + timedelta(days=mute.days)
-                days_left = (expiry_date - datetime.utcnow()).days + 1
-                status = t.status_muted_days(cnt=mute.days, left=days_left)
+            if mute.minutes != -1:
+                expiry_date: datetime = mute.timestamp + timedelta(minutes=mute.minutes)
+                time_left = time_to_units((expiry_date - datetime.utcnow()).total_seconds()/60 + 1)
+                status = t.status_muted_time(time_to_units(mute.minutes), time_left)
             else:
                 status = t.status_muted
         return [(t.active_sanctions, status)]
@@ -221,10 +259,10 @@ async def handle_get_userlog_entries(self, user_id: int) -> list[tuple[datetime,
         async for mute in await db.stream(filter_by(Mute, member=user_id)):
             text = t.ulog.muted.upgrade if mute.is_upgrade else t.ulog.muted.first
 
-            if mute.days == -1:
+            if mute.minutes == -1:
                 out.append((mute.timestamp, text.inf(f"<@{mute.mod}>", mute.reason)))
             else:
-                out.append((mute.timestamp, text.temp(f"<@{mute.mod}>", mute.reason, cnt=mute.days)))
+                out.append((mute.timestamp, text.temp(f"<@{mute.mod}>", time_to_units(mute.minutes), mute.reason)))
 
             if not mute.active and not mute.upgraded:
                 if mute.unmute_mod is None:
@@ -248,10 +286,10 @@ async def handle_get_userlog_entries(self, user_id: int) -> list[tuple[datetime,
         async for ban in await db.stream(filter_by(Ban, member=user_id)):
             text = t.ulog.banned.upgrade if ban.is_upgrade else t.ulog.banned.first
 
-            if ban.days == -1:
+            if ban.minutes == -1:
                 out.append((ban.timestamp, text.inf(f"<@{ban.mod}>", ban.reason)))
             else:
-                out.append((ban.timestamp, text.temp(f"<@{ban.mod}>", ban.reason, cnt=ban.days)))
+                out.append((ban.timestamp, text.temp(f"<@{ban.mod}>", time_to_units(ban.minutes), ban.reason)))
 
             if not ban.active and not ban.upgraded:
                 if ban.unban_mod is None:
@@ -332,15 +370,17 @@ async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
     @commands.command()
     @ModPermission.mute.check
     @guild_only()
-    async def mute(self, ctx: Context, user: UserMemberConverter, days: DurationConverter, *, reason: str):
+    async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConverter, *, reason: str):
         """
         mute a user
+        time format: `ymwdhn`
         set days to `inf` for a permanent mute
         """
 
         user: Union[Member, User]
 
-        days: Optional[int]
+        time: Optional[int]
+        minutes = time
 
         if len(reason) > 900:
             raise CommandError(t.reason_too_long)
@@ -356,11 +396,11 @@ async def mute(self, ctx: Context, user: UserMemberConverter, days: DurationConv
 
         active_mutes: List[Mute] = await db.all(filter_by(Mute, active=True, member=user.id))
         for mute in active_mutes:
-            if mute.days == -1:
+            if mute.minutes == -1:
                 raise UserCommandError(user, t.already_muted)
 
-            ts = mute.timestamp + timedelta(days=mute.days)
-            if days is not None and datetime.utcnow() + timedelta(days=days) <= ts:
+            ts = mute.timestamp + timedelta(minutes=mute.minutes)
+            if minutes is not None and datetime.utcnow() + timedelta(minutes=minutes) <= ts:
                 raise UserCommandError(user, t.already_muted)
 
         for mute in active_mutes:
@@ -370,9 +410,9 @@ async def mute(self, ctx: Context, user: UserMemberConverter, days: DurationConv
         server_embed = Embed(title=t.mute, description=t.muted_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.avatar_url)
 
-        if days is not None:
-            await Mute.create(user.id, str(user), ctx.author.id, days, reason, bool(active_mutes))
-            user_embed.description = t.muted(ctx.author.mention, ctx.guild.name, reason, cnt=days)
+        if minutes is not None:
+            await Mute.create(user.id, str(user), ctx.author.id, minutes, reason, bool(active_mutes))
+            user_embed.description = t.muted(ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason)
             await send_to_changelog_mod(
                 ctx.guild,
                 ctx.message,
@@ -380,7 +420,7 @@ async def mute(self, ctx: Context, user: UserMemberConverter, days: DurationConv
                 t.log_muted,
                 user,
                 reason,
-                duration=t.log_field.days(cnt=days),
+                duration=time_to_units(minutes),
             )
         else:
             await Mute.create(user.id, str(user), ctx.author.id, -1, reason, bool(active_mutes))
@@ -392,7 +432,7 @@ async def mute(self, ctx: Context, user: UserMemberConverter, days: DurationConv
                 t.log_muted,
                 user,
                 reason,
-                duration=t.log_field.days_infinity,
+                duration=t.log_field.infinity,
             )
 
         try:
@@ -486,17 +526,20 @@ async def ban(
         self,
         ctx: Context,
         user: UserMemberConverter,
-        ban_days: DurationConverter,
+        time: DurationConverter,
         delete_days: int,
         *,
         reason: str,
     ):
         """
         ban a user
+        time format: `ymwdhn`
         set ban_days to `inf` for a permanent ban
         """
 
-        ban_days: Optional[int]
+        time: Optional[int]
+        minutes = time
+
         user: Union[Member, User]
 
         if not ctx.guild.me.guild_permissions.ban_members:
@@ -514,11 +557,11 @@ async def ban(
 
         active_bans: List[Ban] = await db.all(filter_by(Ban, active=True, member=user.id))
         for ban in active_bans:
-            if ban.days == -1:
+            if ban.minutes == -1:
                 raise UserCommandError(user, t.already_banned)
 
-            ts = ban.timestamp + timedelta(days=ban.days)
-            if ban_days is not None and datetime.utcnow() + timedelta(days=ban_days) <= ts:
+            ts = ban.timestamp + timedelta(minutes=ban.minutes)
+            if minutes is not None and datetime.utcnow() + timedelta(minutes=minutes) <= ts:
                 raise UserCommandError(user, t.already_banned)
 
         for ban in active_bans:
@@ -530,9 +573,9 @@ async def ban(
         server_embed = Embed(title=t.ban, description=t.banned_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.avatar_url)
 
-        if ban_days is not None:
-            await Ban.create(user.id, str(user), ctx.author.id, ban_days, reason, bool(active_bans))
-            user_embed.description = t.banned(ctx.author.mention, ctx.guild.name, reason, cnt=ban_days)
+        if minutes is not None:
+            await Ban.create(user.id, str(user), ctx.author.id, minutes, reason, bool(active_bans))
+            user_embed.description = t.banned(ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason)
             await send_to_changelog_mod(
                 ctx.guild,
                 ctx.message,
@@ -540,7 +583,7 @@ async def ban(
                 t.log_banned,
                 user,
                 reason,
-                duration=t.log_field.days(cnt=ban_days),
+                duration=time_to_units(minutes),
             )
         else:
             await Ban.create(user.id, str(user), ctx.author.id, -1, reason, bool(active_bans))
@@ -552,7 +595,7 @@ async def ban(
                 t.log_banned,
                 user,
                 reason,
-                duration=t.log_field.days_infinity,
+                duration=t.log_field.infinity,
             )
 
         try:
diff --git a/moderation/mod/models.py b/moderation/mod/models.py
index 9da14605c..5fa08358a 100644
--- a/moderation/mod/models.py
+++ b/moderation/mod/models.py
@@ -56,7 +56,7 @@ class Mute(db.Base):
     member_name: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
     mod: Union[Column, int] = Column(BigInteger)
     timestamp: Union[Column, datetime] = Column(DateTime)
-    days: Union[Column, int] = Column(Integer)
+    minutes: Union[Column, int] = Column(Integer)
     reason: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
     active: Union[Column, bool] = Column(Boolean)
     deactivation_timestamp: Union[Column, Optional[datetime]] = Column(DateTime, nullable=True)
@@ -66,13 +66,13 @@ class Mute(db.Base):
     is_upgrade: Union[Column, bool] = Column(Boolean)
 
     @staticmethod
-    async def create(member: int, member_name: str, mod: int, days: int, reason: str, is_upgrade: bool = False) -> Mute:
+    async def create(member: int, member_name: str, mod: int, minutes: int, reason: str, is_upgrade: bool = False) -> Mute:
         row = Mute(
             member=member,
             member_name=member_name,
             mod=mod,
             timestamp=datetime.utcnow(),
-            days=days,
+            minutes=minutes,
             reason=reason,
             active=True,
             deactivation_timestamp=None,
@@ -123,7 +123,7 @@ class Ban(db.Base):
     member_name: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
     mod: Union[Column, int] = Column(BigInteger)
     timestamp: Union[Column, datetime] = Column(DateTime)
-    days: Union[Column, int] = Column(Integer)
+    minutes: Union[Column, int] = Column(Integer)
     reason: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
     active: Union[Column, bool] = Column(Boolean)
     deactivation_timestamp: Union[Column, Optional[datetime]] = Column(DateTime, nullable=True)
@@ -133,13 +133,13 @@ class Ban(db.Base):
     is_upgrade: Union[Column, bool] = Column(Boolean)
 
     @staticmethod
-    async def create(member: int, member_name: str, mod: int, days: int, reason: str, is_upgrade: bool = False) -> Ban:
+    async def create(member: int, member_name: str, mod: int, minutes: int, reason: str, is_upgrade: bool = False) -> Ban:
         row = Ban(
             member=member,
             member_name=member_name,
             mod=mod,
             timestamp=datetime.utcnow(),
-            days=days,
+            minutes=minutes,
             reason=reason,
             active=True,
             deactivation_timestamp=None,
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index 80d1bba30..e754442aa 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -4,6 +4,23 @@ permissions:
   kick: kick a user
   ban: ban a user
 
+times:
+  years:
+    one: "{cnt} year"
+    many: "{cnt} years"
+  months:
+    one: "{cnt} month"
+    many: "{cnt} months"
+  days:
+    one: "{cnt} day"
+    many: "{cnt} days"
+  hours:
+    one: "{cnt} hour"
+    many: "{cnt} hours"
+  minutes:
+    one: "{cnt} minute"
+    many: "{cnt} minutes"
+
 log_field:
   member: ":bust_in_silhouette: Member"
   member_id: ":dna: Member ID"
@@ -13,7 +30,7 @@ log_field:
   days:
     one: "{cnt} day"
     many: "{cnt} days"
-  days_infinity: "*Permanent*"
+  infinity: "*Permanent*"
 
 jump_url: "{} [[Jump]]({})"
 no_dm: ":warning: User does not allow direct messages."
@@ -37,9 +54,7 @@ unmute: ":loud_sound: Mute"
 mute_role_not_set: User could not be muted because no mute role is configured.
 cannot_mute: This member cannot be muted.
 already_muted: User is already muted for the given period of time.
-muted:
-  one: "{} just muted you on {} for {cnt} day:```\n{}\n```"
-  many: "{} just muted you on {} for {cnt} days:```\n{}\n```"
+muted: "{} just muted you on {} for {}:```\n{}\n```"
 muted_inf: "{} just muted you on {}:```\n{}\n```"
 muted_response: "User muted successfully :white_check_mark:"
 log_muted: ":mute: Member muted"
@@ -60,9 +75,7 @@ unban: ":white_check_mark: Ban"
 cannot_ban: This member cannot be banned.
 already_banned: This member is already banned for the given period of time.
 cannot_ban_permissions: User could not be banned because I don't have `ban_members` permission on this server.
-banned:
-  one: "{} just banned you from {} for {cnt} day:```\n{}\n```"
-  many: "{} just banned you from {} for {cnt} days:```\n{}\n```"
+banned: "{} just banned you from {} for {}:```\n{}\n```"
 banned_inf: "{} just banned you from {}:```\n{}\n```"
 banned_response: "User banned successfully :white_check_mark:"
 log_banned: ":no_entry: Member Banned"
@@ -85,13 +98,9 @@ autokicks:
 active_sanctions: Active Punishments
 none: None
 status_banned: ":no_entry: User is banned from this server."
-status_banned_days:
-  one: ":no_entry: User is banned for {cnt} day from this server ({left} left)."
-  many: ":no_entry: User is banned for {cnt} days from this server ({left} left)."
+status_banned_time: ":no_entry: User is banned for {} from this server ({} left)."
 status_muted: ":mute: User is muted on this server."
-status_muted_days:
-  one: ":mute: User is muted for {cnt} day on this server ({left} left)."
-  many: ":mute: User is muted for {cnt} days on this server ({left} left)."
+status_muted_time: ":mute: User is muted for {} on this server ({} left)."
 
 ulog:
   reported: ":speech_balloon: **Reported** by {} because of `{}`"
@@ -99,14 +108,10 @@ ulog:
 
   muted:
     first:
-      temp:
-        one: ":mute: **Muted** by {} for {cnt} day because of `{}`"
-        many: ":mute: **Muted** by {} for {cnt} days because of `{}`"
+      temp: ":mute: **Muted** by {} for {} because of `{}`"
       inf: ":mute: **Muted** permanently by {} because of `{}`"
     upgrade:
-      temp:
-        one: ":mute: **Mute upgraded** by {} to {cnt} day because of `{}`"
-        many: ":mute: **Mute upgraded** by {} to {cnt} days because of `{}`"
+      temp: ":mute: **Mute upgraded** by {} to {} because of `{}`"
       inf: ":mute: **Mute upgraded** to permanent by {} because of `{}`"
   unmuted: ":loud_sound: **Unmuted** by {} because of `{}`"
   unmuted_expired: ":loud_sound: **Unmuted** because the mute time has expired."
@@ -116,14 +121,10 @@ ulog:
 
   banned:
     first:
-      temp:
-        one: ":no_entry: **Banned** by {} for {cnt} day because of `{}`"
-        many: ":no_entry: **Banned** by {} for {cnt} days because of `{}`"
+      temp: ":no_entry: **Banned** by {} for {} because of `{}`"
       inf: ":no_entry: **Banned** permanently by {} because of `{}`"
     upgrade:
-      temp:
-        one: ":no_entry: **Ban upgraded** by {} to {cnt} day because of `{}`"
-        many: ":no_entry: **Ban upgraded** by {} to {cnt} days because of `{}`"
+      temp: ":no_entry: **Ban upgraded** by {} to {} because of `{}`"
       inf: ":no_entry: **Ban upgraded** to permanent by {} because of `{}`"
   unbanned: ":white_check_mark: **Unbanned** by {} because of `{}`"
   unbanned_expired: ":white_check_mark: **Unbanned** because the ban time has expired."

From dadf5f7aeade092ae81acbccde7407caae23f83b Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Mon, 21 Jun 2021 23:18:01 +0200
Subject: [PATCH 002/120] Removed unnecessary variable

---
 moderation/mod/cog.py | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 7fee766db..22df198cf 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -37,9 +37,6 @@
 t = t.mod
 
 
-days_in_minutes = 60*60*24
-
-
 class DurationConverter(Converter):
     async def convert(self, ctx, argument: str) -> Optional[int]:
         if argument.lower() in ("inf", "perm", "permanent", "-1", "∞"):

From 5d4df8bf25dd3ca6d5bb59c4d6780d1965206260 Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Mon, 21 Jun 2021 23:19:06 +0200
Subject: [PATCH 003/120] Enhanced code style

---
 moderation/mod/models.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/moderation/mod/models.py b/moderation/mod/models.py
index 5fa08358a..31db12e7e 100644
--- a/moderation/mod/models.py
+++ b/moderation/mod/models.py
@@ -66,7 +66,8 @@ class Mute(db.Base):
     is_upgrade: Union[Column, bool] = Column(Boolean)
 
     @staticmethod
-    async def create(member: int, member_name: str, mod: int, minutes: int, reason: str, is_upgrade: bool = False) -> Mute:
+    async def create(member: int, member_name: str, mod: int, minutes: int, reason: str,
+                     is_upgrade: bool = False) -> Mute:
         row = Mute(
             member=member,
             member_name=member_name,
@@ -133,7 +134,8 @@ class Ban(db.Base):
     is_upgrade: Union[Column, bool] = Column(Boolean)
 
     @staticmethod
-    async def create(member: int, member_name: str, mod: int, minutes: int, reason: str, is_upgrade: bool = False) -> Ban:
+    async def create(member: int, member_name: str, mod: int, minutes: int, reason: str,
+                     is_upgrade: bool = False) -> Ban:
         row = Ban(
             member=member,
             member_name=member_name,

From 5d5682092cff66af54447ec95ef6fdf617b971f6 Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Mon, 21 Jun 2021 23:22:49 +0200
Subject: [PATCH 004/120] Added whitespaces around operators

---
 moderation/mod/cog.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 22df198cf..a167b890f 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -227,14 +227,14 @@ async def handle_get_user_status_entries(self, user_id: int) -> list[tuple[str,
         if (ban := await db.get(Ban, member=user_id, active=True)) is not None:
             if ban.minutes != -1:
                 expiry_date: datetime = ban.timestamp + timedelta(minutes=ban.minutes)
-                time_left = time_to_units((expiry_date - datetime.utcnow()).total_seconds()/60 + 1)
+                time_left = time_to_units((expiry_date - datetime.utcnow()).total_seconds() / 60 + 1)
                 status = t.status_banned_time(time_to_units(ban.minutes), time_left)
             else:
                 status = t.status_banned
         elif (mute := await db.get(Mute, member=user_id, active=True)) is not None:
             if mute.minutes != -1:
                 expiry_date: datetime = mute.timestamp + timedelta(minutes=mute.minutes)
-                time_left = time_to_units((expiry_date - datetime.utcnow()).total_seconds()/60 + 1)
+                time_left = time_to_units((expiry_date - datetime.utcnow()).total_seconds() / 60 + 1)
                 status = t.status_muted_time(time_to_units(mute.minutes), time_left)
             else:
                 status = t.status_muted

From 8f036255285bd479c47b8f64f19e73b53b44cc89 Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Tue, 22 Jun 2021 21:36:55 +0200
Subject: [PATCH 005/120] Made reports available on private messages

---
 moderation/mod/cog.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index a167b890f..6f6f12a1e 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -310,7 +310,6 @@ async def on_member_join(self, member: Member):
             await member.add_roles(mute_role)
 
     @commands.command()
-    @guild_only()
     async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         """
         report a user

From ddf2d4d97c8ed29c85055afa342defd0a4281b9d Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Tue, 22 Jun 2021 22:44:48 +0200
Subject: [PATCH 006/120] Added report, warn, kick, mute and ban db ids to ulog
 for mods

---
 information/user_info/cog.py       |  7 ++-
 moderation/mod/cog.py              | 97 ++++++++++++++++++++++++------
 moderation/mod/translations/en.yml | 52 ++++++++++++----
 3 files changed, 121 insertions(+), 35 deletions(-)

diff --git a/information/user_info/cog.py b/information/user_info/cog.py
index 205c54a02..7ea36369f 100644
--- a/information/user_info/cog.py
+++ b/information/user_info/cog.py
@@ -160,7 +160,7 @@ async def userinfo(self, ctx: Context, user: Optional[Union[User, int]] = None):
 
     @commands.command(aliases=["userlog", "ulog"])
     @optional_permissions(UserInfoPermission.view_userlog)
-    async def userlogs(self, ctx: Context, user: Optional[Union[User, int]] = None):
+    async def userlogs(self, ctx: Context, user: Optional[Union[User, int]] = None, show_ids: bool = False):
         """
         show moderation log of a user
         """
@@ -169,6 +169,9 @@ async def userlogs(self, ctx: Context, user: Optional[Union[User, int]] = None):
 
         user, user_id, arg_passed = await get_user(ctx, user, UserInfoPermission.view_userlog)
 
+        if show_ids and not await UserInfoPermission.view_userlog.check_permissions(ctx.author):
+            raise CommandError(t.not_allowed)
+
         out: list[tuple[datetime, str]] = [(snowflake_time(user_id), t.ulog.created)]
 
         join: Join
@@ -199,7 +202,7 @@ async def userlogs(self, ctx: Context, user: Optional[Union[User, int]] = None):
                 else:
                     out.append((verification.timestamp, t.ulog.verification.revoked))
 
-        responses = await get_userlog_entries(user_id)
+        responses = await get_userlog_entries(user_id, show_ids)
         for response in responses:
             out += response
 
diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 6f6f12a1e..cb64aab90 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -241,41 +241,74 @@ async def handle_get_user_status_entries(self, user_id: int) -> list[tuple[str,
         return [(t.active_sanctions, status)]
 
     @get_userlog_entries.subscribe
-    async def handle_get_userlog_entries(self, user_id: int) -> list[tuple[datetime, str]]:
+    async def handle_get_userlog_entries(self, user_id: int, show_ids: bool) -> list[tuple[datetime, str]]:
         out: list[tuple[datetime, str]] = []
 
         report: Report
         async for report in await db.stream(filter_by(Report, member=user_id)):
-            out.append((report.timestamp, t.ulog.reported(f"<@{report.reporter}>", report.reason)))
+            if show_ids:
+                out.append((report.timestamp, t.ulog.reported.id_on(f"<@{report.reporter}>", report.reason, report.id)))
+            else:
+                out.append((report.timestamp, t.ulog.reported.id_off(f"<@{report.reporter}>", report.reason)))
 
         warn: Warn
         async for warn in await db.stream(filter_by(Warn, member=user_id)):
-            out.append((warn.timestamp, t.ulog.warned(f"<@{warn.mod}>", warn.reason)))
+            if show_ids:
+                out.append((warn.timestamp, t.ulog.warned.id_on(f"<@{warn.mod}>", warn.reason, warn.id)))
+            else:
+                out.append((warn.timestamp, t.ulog.warned.id_off(f"<@{warn.mod}>", warn.reason)))
 
         mute: Mute
         async for mute in await db.stream(filter_by(Mute, member=user_id)):
             text = t.ulog.muted.upgrade if mute.is_upgrade else t.ulog.muted.first
 
             if mute.minutes == -1:
-                out.append((mute.timestamp, text.inf(f"<@{mute.mod}>", mute.reason)))
+                if show_ids:
+                    out.append((mute.timestamp, text.inf.id_on(f"<@{mute.mod}>", mute.reason, mute.id)))
+                else:
+                    out.append((mute.timestamp, text.inf.id_off(f"<@{mute.mod}>", mute.reason)))
             else:
-                out.append((mute.timestamp, text.temp(f"<@{mute.mod}>", time_to_units(mute.minutes), mute.reason)))
+                if show_ids:
+                    out.append(
+                        (
+                            mute.timestamp,
+                            text.temp.id_on(f"<@{mute.mod}>", time_to_units(mute.minutes), mute.reason, mute.id)
+                        )
+                    )
+                else:
+                    out.append(
+                        (
+                            mute.timestamp,
+                            text.temp.id_off(f"<@{mute.mod}>", time_to_units(mute.minutes), mute.reason)
+                        )
+                    )
 
             if not mute.active and not mute.upgraded:
                 if mute.unmute_mod is None:
                     out.append((mute.deactivation_timestamp, t.ulog.unmuted_expired))
                 else:
-                    out.append(
-                        (
-                            mute.deactivation_timestamp,
-                            t.ulog.unmuted(f"<@{mute.unmute_mod}>", mute.unmute_reason),
-                        ),
-                    )
+                    if show_ids:
+                        out.append(
+                            (
+                                mute.deactivation_timestamp,
+                                t.ulog.unmuted.id_on(f"<@{mute.unmute_mod}>", mute.unmute_reason, mute.id),
+                            ),
+                        )
+                    else:
+                        out.append(
+                            (
+                                mute.deactivation_timestamp,
+                                t.ulog.unmuted.id_off(f"<@{mute.unmute_mod}>", mute.unmute_reason),
+                            ),
+                        )
 
         kick: Kick
         async for kick in await db.stream(filter_by(Kick, member=user_id)):
             if kick.mod is not None:
-                out.append((kick.timestamp, t.ulog.kicked(f"<@{kick.mod}>", kick.reason)))
+                if show_ids:
+                    out.append((kick.timestamp, t.ulog.kicked.id_on(f"<@{kick.mod}>", kick.reason, kick.id)))
+                else:
+                    out.append((kick.timestamp, t.ulog.kicked.id_off(f"<@{kick.mod}>", kick.reason)))
             else:
                 out.append((kick.timestamp, t.ulog.autokicked))
 
@@ -284,20 +317,44 @@ async def handle_get_userlog_entries(self, user_id: int) -> list[tuple[datetime,
             text = t.ulog.banned.upgrade if ban.is_upgrade else t.ulog.banned.first
 
             if ban.minutes == -1:
-                out.append((ban.timestamp, text.inf(f"<@{ban.mod}>", ban.reason)))
+                if show_ids:
+                    out.append((ban.timestamp, text.inf.id_on(f"<@{ban.mod}>", ban.reason, ban.id)))
+                else:
+                    out.append((ban.timestamp, text.inf.id_off(f"<@{ban.mod}>", ban.reason)))
             else:
-                out.append((ban.timestamp, text.temp(f"<@{ban.mod}>", time_to_units(ban.minutes), ban.reason)))
+                if show_ids:
+                    out.append(
+                        (
+                            ban.timestamp,
+                            text.temp.id_on(f"<@{ban.mod}>", time_to_units(ban.minutes), ban.reason, ban.id)
+                        )
+                    )
+                else:
+                    out.append(
+                        (
+                            ban.timestamp,
+                            text.temp.id_off(f"<@{ban.mod}>", time_to_units(ban.minutes), ban.reason)
+                        )
+                    )
 
             if not ban.active and not ban.upgraded:
                 if ban.unban_mod is None:
                     out.append((ban.deactivation_timestamp, t.ulog.unbanned_expired))
                 else:
-                    out.append(
-                        (
-                            ban.deactivation_timestamp,
-                            t.ulog.unbanned(f"<@{ban.unban_mod}>", ban.unban_reason),
-                        ),
-                    )
+                    if show_ids:
+                        out.append(
+                            (
+                                ban.deactivation_timestamp,
+                                t.ulog.unbanned.id_on(f"<@{ban.unban_mod}>", ban.unban_reason, ban.id),
+                            ),
+                        )
+                    else:
+                        out.append(
+                            (
+                                ban.deactivation_timestamp,
+                                t.ulog.unbanned.id_off(f"<@{ban.unban_mod}>", ban.unban_reason),
+                            ),
+                        )
 
         return out
 
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index e754442aa..159efe300 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -103,28 +103,54 @@ status_muted: ":mute: User is muted on this server."
 status_muted_time: ":mute: User is muted for {} on this server ({} left)."
 
 ulog:
-  reported: ":speech_balloon: **Reported** by {} because of `{}`"
-  warned: ":warning: **Warned** by {} because of `{}`"
+  reported:
+    id_off: ":speech_balloon: **Reported** by {} because of `{}`"
+    id_on: ":speech_balloon: **Reported** by {} because of `{}`\n`(ID: {})`"
+  warned:
+    id_off: ":warning: **Warned** by {} because of `{}`"
+    id_on: ":warning: **Warned** by {} because of `{}`\n`(ID: {})`"
 
   muted:
     first:
-      temp: ":mute: **Muted** by {} for {} because of `{}`"
-      inf: ":mute: **Muted** permanently by {} because of `{}`"
+      temp:
+        id_off: ":mute: **Muted** by {} for {} because of `{}`"
+        id_on: ":mute: **Muted** by {} for {} because of `{}`\n`(ID: {})`"
+      inf:
+        id_off: ":mute: **Muted** permanently by {} because of `{}`"
+        id_on: ":mute: **Muted** permanently by {} because of `{}`\n`(ID: {})`"
     upgrade:
-      temp: ":mute: **Mute upgraded** by {} to {} because of `{}`"
-      inf: ":mute: **Mute upgraded** to permanent by {} because of `{}`"
-  unmuted: ":loud_sound: **Unmuted** by {} because of `{}`"
+      temp:
+        id_off: ":mute: **Mute upgraded** by {} to {} because of `{}`"
+        id_on: ":mute: **Mute upgraded** by {} to {} because of `{}`\n`(ID: {})`"
+      inf:
+        id_off: ":mute: **Mute upgraded** to permanent by {} because of `{}`"
+        id_on: ":mute: **Mute upgraded** to permanent by {} because of `{}`\n`(ID: {})`"
+  unmuted:
+    id_off: ":loud_sound: **Unmuted** by {} because of `{}`"
+    id_on: ":loud_sound: **Unmuted** by {} because of `{}`\n`(ID: {})`"
   unmuted_expired: ":loud_sound: **Unmuted** because the mute time has expired."
 
-  kicked: ":x: **Kicked** by {} because of `{}`"
+  kicked:
+    id_off: ":x: **Kicked** by {} because of `{}`"
+    id_on: ":x: **Kicked** by {} because of `{}`\n`(ID: {})`"
   autokicked: ":hourglass: **Kicked** automatically."
 
   banned:
     first:
-      temp: ":no_entry: **Banned** by {} for {} because of `{}`"
-      inf: ":no_entry: **Banned** permanently by {} because of `{}`"
+      temp:
+        id_off: ":no_entry: **Banned** by {} for {} because of `{}`"
+        id_on: ":no_entry: **Banned** by {} for {} because of `{}`\n`(ID: {})`"
+      inf:
+        id_off: ":no_entry: **Banned** permanently by {} because of `{}`"
+        id_on: ":no_entry: **Banned** by {} for {} because of `{}`\n`(ID: {})`"
     upgrade:
-      temp: ":no_entry: **Ban upgraded** by {} to {} because of `{}`"
-      inf: ":no_entry: **Ban upgraded** to permanent by {} because of `{}`"
-  unbanned: ":white_check_mark: **Unbanned** by {} because of `{}`"
+      temp:
+        id_off: ":no_entry: **Ban upgraded** by {} to {} because of `{}`"
+        id_on: ":no_entry: **Banned** by {} for {} because of `{}`\n`(ID: {})`"
+      inf:
+        id_off: ":no_entry: **Ban upgraded** to permanent by {} because of `{}`"
+        id_on: ":no_entry: **Banned** by {} for {} because of `{}`\n`(ID: {})`"
+  unbanned:
+    id_off: ":white_check_mark: **Unbanned** by {} because of `{}`"
+    id_on: ":white_check_mark: **Unbanned** by {} because of `{}`\n`(ID: {})`"
   unbanned_expired: ":white_check_mark: **Unbanned** because the ban time has expired."

From 19ee12ac70168f26b7641bd48e3c6a4b041c5d99 Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Tue, 22 Jun 2021 23:05:51 +0200
Subject: [PATCH 007/120] Fixed giving too many arguments to pubsub
 subscription

---
 information/user_info/cog.py | 2 +-
 moderation/invites/cog.py    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/information/user_info/cog.py b/information/user_info/cog.py
index 7ea36369f..253d488d0 100644
--- a/information/user_info/cog.py
+++ b/information/user_info/cog.py
@@ -160,7 +160,7 @@ async def userinfo(self, ctx: Context, user: Optional[Union[User, int]] = None):
 
     @commands.command(aliases=["userlog", "ulog"])
     @optional_permissions(UserInfoPermission.view_userlog)
-    async def userlogs(self, ctx: Context, user: Optional[Union[User, int]] = None, show_ids: bool = False):
+    async def userlogs(self, ctx: Context, user: Optional[Union[User, int]] = None, show_ids: Optional[bool] = False):
         """
         show moderation log of a user
         """
diff --git a/moderation/invites/cog.py b/moderation/invites/cog.py
index 9ce3e6c05..936d935bf 100644
--- a/moderation/invites/cog.py
+++ b/moderation/invites/cog.py
@@ -76,7 +76,7 @@ class InvitesCog(Cog, name="Allowed Discord Invites"):
     CONTRIBUTORS = [Contributor.Defelo, Contributor.wolflu, Contributor.TNT2k, Contributor.Florian]
 
     @get_userlog_entries.subscribe
-    async def handle_get_ulog_entries(self, user_id: int):
+    async def handle_get_ulog_entries(self, user_id: int, _):
         out = []
         async for log in await db.stream(filter_by(InviteLog, applicant=user_id)):  # type: InviteLog
             if log.approved:

From ce407fe8243094c678db4cd03a3f1ce19104f486 Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Wed, 23 Jun 2021 12:37:15 +0200
Subject: [PATCH 008/120] Added function to attach an evidence image to reports

---
 moderation/mod/cog.py              | 14 ++++++++++++--
 moderation/mod/translations/en.yml |  6 +++---
 2 files changed, 15 insertions(+), 5 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index cb64aab90..bae6281e6 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -3,7 +3,7 @@
 from dateutil.relativedelta import relativedelta
 from typing import Optional, Union, List, Tuple, Generator
 
-from discord import Role, Guild, Member, Forbidden, HTTPException, User, Embed, NotFound, Message
+from discord import Role, Guild, Member, Forbidden, HTTPException, User, Embed, NotFound, Message, Attachment
 from discord.ext import commands, tasks
 from discord.ext.commands import (
     guild_only,
@@ -100,6 +100,7 @@ async def send_to_changelog_mod(
     reason: str,
     *,
     duration: Optional[str] = None,
+    evidence: Optional[Attachment] = None,
 ):
     embed = Embed(title=title, colour=colour, timestamp=datetime.utcnow())
 
@@ -125,6 +126,9 @@ async def send_to_changelog_mod(
     if duration:
         embed.add_field(name=t.log_field.duration, value=duration, inline=True)
 
+    if evidence:
+        embed.add_field(name=t.log_field.evidence, value=t.image_link(evidence.filename, evidence.url), inline=True)
+
     embed.add_field(name=t.log_field.reason, value=reason, inline=False)
 
     await send_to_changelog(guild, embed)
@@ -382,11 +386,17 @@ async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         if user == ctx.author:
             raise UserCommandError(user, t.no_self_report)
 
+        if attachments := ctx.message.attachments:
+            evidence = attachments[0]
+        else:
+            evidence = None
+
         await Report.create(user.id, str(user), ctx.author.id, reason)
         server_embed = Embed(title=t.report, description=t.reported_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.avatar_url)
         await reply(ctx, embed=server_embed)
-        await send_to_changelog_mod(ctx.guild, ctx.message, Colors.report, t.log_reported, user, reason)
+        await send_to_changelog_mod(ctx.guild,
+                                    ctx.message, Colors.report, t.log_reported, user, reason, evidence=evidence)
 
     @commands.command()
     @ModPermission.warn.check
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index 159efe300..f407c3716 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -27,12 +27,12 @@ log_field:
   channel: ":compass: Channel"
   duration: ":clock2: Duration"
   reason: ":scroll: Reason"
-  days:
-    one: "{cnt} day"
-    many: "{cnt} days"
   infinity: "*Permanent*"
+  evidence: ":file_cabinet: Evidence image"
+
 
 jump_url: "{} [[Jump]]({})"
+image_link: "{} [[Go to image]]({})"
 no_dm: ":warning: User does not allow direct messages."
 reason_too_long: "Reason is too long. :pencil:"
 invalid_duration_inf: Invalid duration. Try `inf` instead.

From aba7d8ce6ecd587c5e0fa599382c0cebd419756e Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Wed, 23 Jun 2021 12:48:22 +0200
Subject: [PATCH 009/120] Added evidence image to database on reports

---
 moderation/mod/cog.py    | 2 +-
 moderation/mod/models.py | 4 +++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index bae6281e6..d021542e7 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -391,7 +391,7 @@ async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         else:
             evidence = None
 
-        await Report.create(user.id, str(user), ctx.author.id, reason)
+        await Report.create(user.id, str(user), ctx.author.id, reason, evidence.url)
         server_embed = Embed(title=t.report, description=t.reported_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.avatar_url)
         await reply(ctx, embed=server_embed)
diff --git a/moderation/mod/models.py b/moderation/mod/models.py
index 31db12e7e..00609ec5f 100644
--- a/moderation/mod/models.py
+++ b/moderation/mod/models.py
@@ -17,15 +17,17 @@ class Report(db.Base):
     reporter: Union[Column, int] = Column(BigInteger)
     timestamp: Union[Column, datetime] = Column(DateTime)
     reason: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
+    evidence: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
 
     @staticmethod
-    async def create(member: int, member_name: str, reporter: int, reason: str) -> Report:
+    async def create(member: int, member_name: str, reporter: int, reason: str, evidence: Optional[str]) -> Report:
         row = Report(
             member=member,
             member_name=member_name,
             reporter=reporter,
             timestamp=datetime.utcnow(),
             reason=reason,
+            evidence=evidence,
         )
         await db.add(row)
         return row

From e65030a923ff4a1e06290b9beaa9a73c1289228a Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Wed, 23 Jun 2021 21:22:53 +0200
Subject: [PATCH 010/120] Added function to attach an evidence image to warns

---
 moderation/mod/cog.py              | 17 ++++++++++++++---
 moderation/mod/models.py           | 11 +++++++++--
 moderation/mod/translations/en.yml |  4 +++-
 3 files changed, 26 insertions(+), 6 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index d021542e7..8c2d9442c 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -414,11 +414,22 @@ async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         if user == self.bot.user:
             raise UserCommandError(user, t.cannot_warn)
 
+        if attachments := ctx.message.attachments:
+            evidence = attachments[0]
+        else:
+            evidence = None
+
         user_embed = Embed(
             title=t.warn,
-            description=t.warned(ctx.author.mention, ctx.guild.name, reason),
             colour=Colors.ModTools,
         )
+        if evidence:
+            user_embed.description = t.warned.evidence(ctx.author.mention, ctx.guild.name, reason,
+                                                       t.image_link(evidence.filename, evidence.url)
+                                                       )
+        else:
+            user_embed.description = t.warned.no_evidence(ctx.author.mention, ctx.guild.name, reason)
+
         server_embed = Embed(title=t.warn, description=t.warned_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.avatar_url)
         try:
@@ -426,9 +437,9 @@ async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         except (Forbidden, HTTPException):
             server_embed.description = t.no_dm + "\n\n" + server_embed.description
             server_embed.colour = Colors.error
-        await Warn.create(user.id, str(user), ctx.author.id, reason)
+        await Warn.create(user.id, str(user), ctx.author.id, reason, evidence.url)
         await reply(ctx, embed=server_embed)
-        await send_to_changelog_mod(ctx.guild, ctx.message, Colors.warn, t.log_warned, user, reason)
+        await send_to_changelog_mod(ctx.guild, ctx.message, Colors.warn, t.log_warned, user, reason, evidence=evidence)
 
     @commands.command()
     @ModPermission.mute.check
diff --git a/moderation/mod/models.py b/moderation/mod/models.py
index 00609ec5f..f9b37296d 100644
--- a/moderation/mod/models.py
+++ b/moderation/mod/models.py
@@ -42,10 +42,17 @@ class Warn(db.Base):
     mod: Union[Column, int] = Column(BigInteger)
     timestamp: Union[Column, datetime] = Column(DateTime)
     reason: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
+    evidence: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
 
     @staticmethod
-    async def create(member: int, member_name: str, mod: int, reason: str) -> Warn:
-        row = Warn(member=member, member_name=member_name, mod=mod, timestamp=datetime.utcnow(), reason=reason)
+    async def create(member: int, member_name: str, mod: int, reason: str, evidence: Optional[str]) -> Warn:
+        row = Warn(member=member,
+                   member_name=member_name,
+                   mod=mod,
+                   timestamp=datetime.utcnow(),
+                   reason=reason,
+                   evidence=evidence,
+                   )
         await db.add(row)
         return row
 
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index f407c3716..773f80f27 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -45,7 +45,9 @@ log_reported: ":speech_balloon: Member reported"
 
 warn: ":warning: Warn"
 cannot_warn: This member cannot be warned.
-warned: "{} just warned you on {}:```\n{}\n```"
+warned:
+  evidence: "{} just warned you on {}:```\n{}\n```Evidence: {}"
+  no_evidence: "{} just warned you on {}:```\n{}\n```"
 warned_response: "User warned successfully :white_check_mark:"
 log_warned: ":warning: Member warned"
 

From 79f2cd1860a1d5f0003bd6e45bade628b5d1cb8c Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Wed, 23 Jun 2021 21:45:17 +0200
Subject: [PATCH 011/120] Added function to attach an evidence image to mutes

---
 moderation/mod/cog.py              | 39 +++++++++++++++++++++++++-----
 moderation/mod/models.py           |  4 ++-
 moderation/mod/translations/en.yml |  8 ++++--
 3 files changed, 42 insertions(+), 9 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 8c2d9442c..de6060916 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -388,10 +388,12 @@ async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
 
         if attachments := ctx.message.attachments:
             evidence = attachments[0]
+            evidence_url = evidence.url
         else:
             evidence = None
+            evidence_url = None
 
-        await Report.create(user.id, str(user), ctx.author.id, reason, evidence.url)
+        await Report.create(user.id, str(user), ctx.author.id, reason, evidence_url)
         server_embed = Embed(title=t.report, description=t.reported_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.avatar_url)
         await reply(ctx, embed=server_embed)
@@ -416,8 +418,10 @@ async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
 
         if attachments := ctx.message.attachments:
             evidence = attachments[0]
+            evidence_url = evidence.url
         else:
             evidence = None
+            evidence_url = None
 
         user_embed = Embed(
             title=t.warn,
@@ -425,7 +429,7 @@ async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         )
         if evidence:
             user_embed.description = t.warned.evidence(ctx.author.mention, ctx.guild.name, reason,
-                                                       t.image_link(evidence.filename, evidence.url)
+                                                       t.image_link(evidence.filename, evidence_url),
                                                        )
         else:
             user_embed.description = t.warned.no_evidence(ctx.author.mention, ctx.guild.name, reason)
@@ -477,6 +481,13 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
             if minutes is not None and datetime.utcnow() + timedelta(minutes=minutes) <= ts:
                 raise UserCommandError(user, t.already_muted)
 
+        if attachments := ctx.message.attachments:
+            evidence = attachments[0]
+            evidence_url = evidence.url
+        else:
+            evidence = None
+            evidence_url = None
+
         for mute in active_mutes:
             await Mute.upgrade(mute.id, ctx.author.id)
 
@@ -485,8 +496,16 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
         server_embed.set_author(name=str(user), icon_url=user.avatar_url)
 
         if minutes is not None:
-            await Mute.create(user.id, str(user), ctx.author.id, minutes, reason, bool(active_mutes))
-            user_embed.description = t.muted(ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason)
+            await Mute.create(user.id, str(user), ctx.author.id, minutes, reason, evidence_url, bool(active_mutes))
+            if evidence:
+                user_embed.description = t.muted.evidence(ctx.author.mention, ctx.guild.name, time_to_units(minutes),
+                                                          reason, t.image_link(evidence.filename, evidence_url),
+                                                          )
+            else:
+                user_embed.description = t.muted.no_evidence(ctx.author.mention, ctx.guild.name, time_to_units(minutes),
+                                                             reason,
+                                                             )
+
             await send_to_changelog_mod(
                 ctx.guild,
                 ctx.message,
@@ -495,10 +514,17 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
                 user,
                 reason,
                 duration=time_to_units(minutes),
+                evidence=evidence,
             )
         else:
-            await Mute.create(user.id, str(user), ctx.author.id, -1, reason, bool(active_mutes))
-            user_embed.description = t.muted_inf(ctx.author.mention, ctx.guild.name, reason)
+            await Mute.create(user.id, str(user), ctx.author.id, -1, reason, evidence_url, bool(active_mutes))
+            if evidence:
+                user_embed.description = t.muted_inf.evidence(ctx.author.mention, ctx.guild.name, reason,
+                                                              t.image_link(evidence.filename, evidence_url),
+                                                              )
+            else:
+                user_embed.description = t.muted_inf.no_evidence(ctx.author.mention, ctx.guild.name, reason)
+
             await send_to_changelog_mod(
                 ctx.guild,
                 ctx.message,
@@ -507,6 +533,7 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
                 user,
                 reason,
                 duration=t.log_field.infinity,
+                evidence=evidence,
             )
 
         try:
diff --git a/moderation/mod/models.py b/moderation/mod/models.py
index f9b37296d..b055729cb 100644
--- a/moderation/mod/models.py
+++ b/moderation/mod/models.py
@@ -67,6 +67,7 @@ class Mute(db.Base):
     timestamp: Union[Column, datetime] = Column(DateTime)
     minutes: Union[Column, int] = Column(Integer)
     reason: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
+    evidence: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
     active: Union[Column, bool] = Column(Boolean)
     deactivation_timestamp: Union[Column, Optional[datetime]] = Column(DateTime, nullable=True)
     unmute_mod: Union[Column, Optional[int]] = Column(BigInteger, nullable=True)
@@ -76,7 +77,7 @@ class Mute(db.Base):
 
     @staticmethod
     async def create(member: int, member_name: str, mod: int, minutes: int, reason: str,
-                     is_upgrade: bool = False) -> Mute:
+                     evidence: Optional[str], is_upgrade: bool = False) -> Mute:
         row = Mute(
             member=member,
             member_name=member_name,
@@ -84,6 +85,7 @@ async def create(member: int, member_name: str, mod: int, minutes: int, reason:
             timestamp=datetime.utcnow(),
             minutes=minutes,
             reason=reason,
+            evidence=evidence,
             active=True,
             deactivation_timestamp=None,
             unmute_mod=None,
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index 773f80f27..325964e1a 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -56,8 +56,12 @@ unmute: ":loud_sound: Mute"
 mute_role_not_set: User could not be muted because no mute role is configured.
 cannot_mute: This member cannot be muted.
 already_muted: User is already muted for the given period of time.
-muted: "{} just muted you on {} for {}:```\n{}\n```"
-muted_inf: "{} just muted you on {}:```\n{}\n```"
+muted:
+  evidence: "{} just muted you on {} for {}:```\n{}\n```Evidence: {}"
+  no_evidence: "{} just muted you on {} for {}:```\n{}\n```"
+muted_inf:
+  evidence: "{} just muted you on {}:```\n{}\n```Evidence: {}"
+  no_evidence: "{} just muted you on {}:```\n{}\n```"
 muted_response: "User muted successfully :white_check_mark:"
 log_muted: ":mute: Member muted"
 log_unmuted_expired: "Unmuted automatically because the mute time for this user has expired."

From e4415ddc409f1a6a3ed1f9571f9d8006d4fb94ec Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Wed, 23 Jun 2021 21:57:39 +0200
Subject: [PATCH 012/120] Added function to attach an evidence image to kicks

---
 moderation/mod/cog.py              | 23 +++++++++++++++++++----
 moderation/mod/models.py           | 12 ++++++++++--
 moderation/mod/translations/en.yml |  4 +++-
 3 files changed, 32 insertions(+), 7 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index de6060916..fe1805777 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -595,14 +595,29 @@ async def kick(self, ctx: Context, member: Member, *, reason: str):
         if member.top_role >= ctx.guild.me.top_role or member.id == ctx.guild.owner_id:
             raise UserCommandError(member, t.cannot_kick)
 
-        await Kick.create(member.id, str(member), ctx.author.id, reason)
-        await send_to_changelog_mod(ctx.guild, ctx.message, Colors.kick, t.log_kicked, member, reason)
+        if attachments := ctx.message.attachments:
+            evidence = attachments[0]
+            evidence_url = evidence.url
+        else:
+            evidence = None
+            evidence_url = None
+
+        await Kick.create(member.id, str(member), ctx.author.id, reason, evidence_url)
+        await send_to_changelog_mod(ctx.guild, ctx.message, Colors.kick, t.log_kicked, member, reason,
+                                    evidence=evidence)
 
         user_embed = Embed(
             title=t.kick,
-            description=t.kicked(ctx.author.mention, ctx.guild.name, reason),
             colour=Colors.ModTools,
         )
+
+        if evidence:
+            user_embed.description = t.kicked.evidence(ctx.author.mention, ctx.guild.name, reason,
+                                                       t.image_link(evidence.filename, evidence_url),
+                                                       )
+        else:
+            user_embed.description = t.kicked.no_evidence(ctx.author.mention, ctx.guild.name, reason)
+
         server_embed = Embed(title=t.kick, description=t.kicked_response, colour=Colors.ModTools)
         server_embed.set_author(
             name=str(member),
@@ -615,7 +630,7 @@ async def kick(self, ctx: Context, member: Member, *, reason: str):
             server_embed.description = t.no_dm + "\n\n" + server_embed.description
             server_embed.colour = Colors.error
 
-        await member.kick(reason=reason)
+        # await member.kick(reason=reason)
         await revoke_verification(member)
 
         await reply(ctx, embed=server_embed)
diff --git a/moderation/mod/models.py b/moderation/mod/models.py
index b055729cb..22170833c 100644
--- a/moderation/mod/models.py
+++ b/moderation/mod/models.py
@@ -119,10 +119,18 @@ class Kick(db.Base):
     mod: Union[Column, int] = Column(BigInteger)
     timestamp: Union[Column, datetime] = Column(DateTime)
     reason: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
+    evidence: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
 
     @staticmethod
-    async def create(member: int, member_name: str, mod: Optional[int], reason: Optional[str]) -> Kick:
-        row = Kick(member=member, member_name=member_name, mod=mod, timestamp=datetime.utcnow(), reason=reason)
+    async def create(member: int, member_name: str, mod: Optional[int], reason: Optional[str],
+                     evidence: Optional[str]) -> Kick:
+        row = Kick(member=member,
+                   member_name=member_name,
+                   mod=mod,
+                   timestamp=datetime.utcnow(),
+                   reason=reason,
+                   evidence=evidence,
+                   )
         await db.add(row)
         return row
 
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index 325964e1a..05a023f90 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -70,7 +70,9 @@ log_unmuted: ":loud_sound: Member unmuted"
 not_muted: User is not muted.
 
 kick: ":x: Kick"
-kicked: "{} just kicked you from {}:```\n{}\n```"
+kicked:
+  evidence: "{} just kicked you from {}:```\n{}\n```Evidence: {}"
+  no_evidence: "{} just kicked you from {}:```\n{}\n```"
 kicked_response: "User kicked successfully :white_check_mark:"
 log_kicked: ":x: Member kicked"
 cannot_kick: This member cannot be kicked.

From 15c0c2a58beca16621416409608e8856b062905b Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Wed, 23 Jun 2021 22:17:33 +0200
Subject: [PATCH 013/120] Added function to attach an evidence image to bans

---
 moderation/mod/cog.py              | 32 +++++++++++++++++++++++++-----
 moderation/mod/models.py           |  4 +++-
 moderation/mod/translations/en.yml |  8 ++++++--
 3 files changed, 36 insertions(+), 8 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index fe1805777..77917813b 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -630,7 +630,7 @@ async def kick(self, ctx: Context, member: Member, *, reason: str):
             server_embed.description = t.no_dm + "\n\n" + server_embed.description
             server_embed.colour = Colors.error
 
-        # await member.kick(reason=reason)
+        await member.kick(reason=reason)
         await revoke_verification(member)
 
         await reply(ctx, embed=server_embed)
@@ -685,13 +685,27 @@ async def ban(
         async for mute in await db.stream(filter_by(Mute, active=True, member=user.id)):
             await Mute.upgrade(mute.id, ctx.author.id)
 
+        if attachments := ctx.message.attachments:
+            evidence = attachments[0]
+            evidence_url = evidence.url
+        else:
+            evidence = None
+            evidence_url = None
+
         user_embed = Embed(title=t.ban, colour=Colors.ModTools)
         server_embed = Embed(title=t.ban, description=t.banned_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.avatar_url)
 
         if minutes is not None:
-            await Ban.create(user.id, str(user), ctx.author.id, minutes, reason, bool(active_bans))
-            user_embed.description = t.banned(ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason)
+            await Ban.create(user.id, str(user), ctx.author.id, minutes, reason, evidence_url, bool(active_bans))
+            if evidence:
+                user_embed.description = t.banned.evidence(ctx.author.mention, ctx.guild.name, time_to_units(minutes),
+                                                           reason, t.image_link(evidence.filename, evidence_url)
+                                                           )
+            else:
+                user_embed.description = t.banned.no_evidence(ctx.author.mention, ctx.guild.name,
+                                                              time_to_units(minutes), reason
+                                                              )
             await send_to_changelog_mod(
                 ctx.guild,
                 ctx.message,
@@ -700,10 +714,17 @@ async def ban(
                 user,
                 reason,
                 duration=time_to_units(minutes),
+                evidence=evidence,
             )
         else:
-            await Ban.create(user.id, str(user), ctx.author.id, -1, reason, bool(active_bans))
-            user_embed.description = t.banned_inf(ctx.author.mention, ctx.guild.name, reason)
+            await Ban.create(user.id, str(user), ctx.author.id, -1, reason, evidence_url, bool(active_bans))
+            if evidence:
+                user_embed.description = t.banned.evidence(ctx.author.mention, ctx.guild.name, reason,
+                                                           t.image_link(evidence.filename, evidence_url)
+                                                           )
+            else:
+                user_embed.description = t.banned.evidence(ctx.author.mention, ctx.guild.name, reason)
+
             await send_to_changelog_mod(
                 ctx.guild,
                 ctx.message,
@@ -712,6 +733,7 @@ async def ban(
                 user,
                 reason,
                 duration=t.log_field.infinity,
+                evidence=evidence
             )
 
         try:
diff --git a/moderation/mod/models.py b/moderation/mod/models.py
index 22170833c..97f2a9a19 100644
--- a/moderation/mod/models.py
+++ b/moderation/mod/models.py
@@ -145,6 +145,7 @@ class Ban(db.Base):
     timestamp: Union[Column, datetime] = Column(DateTime)
     minutes: Union[Column, int] = Column(Integer)
     reason: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
+    evidence: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
     active: Union[Column, bool] = Column(Boolean)
     deactivation_timestamp: Union[Column, Optional[datetime]] = Column(DateTime, nullable=True)
     unban_reason: Union[Column, Optional[str]] = Column(Text(collation="utf8mb4_bin"), nullable=True)
@@ -154,7 +155,7 @@ class Ban(db.Base):
 
     @staticmethod
     async def create(member: int, member_name: str, mod: int, minutes: int, reason: str,
-                     is_upgrade: bool = False) -> Ban:
+                     evidence: Optional[str], is_upgrade: bool = False) -> Ban:
         row = Ban(
             member=member,
             member_name=member_name,
@@ -162,6 +163,7 @@ async def create(member: int, member_name: str, mod: int, minutes: int, reason:
             timestamp=datetime.utcnow(),
             minutes=minutes,
             reason=reason,
+            evidence=evidence,
             active=True,
             deactivation_timestamp=None,
             unban_reason=None,
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index 05a023f90..88635a24d 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -83,8 +83,12 @@ unban: ":white_check_mark: Ban"
 cannot_ban: This member cannot be banned.
 already_banned: This member is already banned for the given period of time.
 cannot_ban_permissions: User could not be banned because I don't have `ban_members` permission on this server.
-banned: "{} just banned you from {} for {}:```\n{}\n```"
-banned_inf: "{} just banned you from {}:```\n{}\n```"
+banned:
+  evidence: "{} just banned you from {} for {}:```\n{}\n```Evidence: {}"
+  no_evidence: "{} just banned you from {} for {}:```\n{}\n```"
+banned_inf:
+  evidence: "{} just banned you from {}:```\n{}\n```Evidence: {}"
+  no_evidence: "{} just banned you from {}:```\n{}\n```"
 banned_response: "User banned successfully :white_check_mark:"
 log_banned: ":no_entry: Member Banned"
 log_unbanned_expired: "Unbanned automatically because the ban time for this user has expired."

From fdd45a0d1402cf499df6593c58fd71dc502a212c Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Wed, 23 Jun 2021 22:53:40 +0200
Subject: [PATCH 014/120] Added evidence images to user log

---
 moderation/mod/cog.py              | 103 ++++++++++++++++++++++++-----
 moderation/mod/translations/en.yml |  30 +++++----
 2 files changed, 103 insertions(+), 30 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 77917813b..16c5af21c 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -91,6 +91,12 @@ async def get_mute_role(guild: Guild) -> Role:
     return mute_role
 
 
+def show_evidence(evidence: Optional[str]) -> str:
+    if evidence:
+        return t.ulog.evidence(evidence)
+    return ""
+
+
 async def send_to_changelog_mod(
     guild: Guild,
     message: Optional[Message],
@@ -251,39 +257,77 @@ async def handle_get_userlog_entries(self, user_id: int, show_ids: bool) -> list
         report: Report
         async for report in await db.stream(filter_by(Report, member=user_id)):
             if show_ids:
-                out.append((report.timestamp, t.ulog.reported.id_on(f"<@{report.reporter}>", report.reason, report.id)))
+                out.append(
+                    (report.timestamp,
+                     t.ulog.reported.id_on(f"<@{report.reporter}>", report.reason, report.id,
+                                           show_evidence(report.evidence)
+                                           )
+                     )
+                )
             else:
-                out.append((report.timestamp, t.ulog.reported.id_off(f"<@{report.reporter}>", report.reason)))
+                out.append(
+                    (report.timestamp,
+                     t.ulog.reported.id_off(f"<@{report.reporter}>", report.reason, show_evidence(report.evidence))
+                     )
+                )
 
         warn: Warn
         async for warn in await db.stream(filter_by(Warn, member=user_id)):
             if show_ids:
-                out.append((warn.timestamp, t.ulog.warned.id_on(f"<@{warn.mod}>", warn.reason, warn.id)))
+                out.append(
+                    (
+                        warn.timestamp,
+                        t.ulog.warned.id_on(f"<@{warn.mod}>", warn.reason, warn.id, show_evidence(warn.evidence))
+                    )
+                )
             else:
-                out.append((warn.timestamp, t.ulog.warned.id_off(f"<@{warn.mod}>", warn.reason)))
+                out.append(
+                    (
+                        warn.timestamp,
+                        t.ulog.warned.id_off(f"<@{warn.mod}>", warn.reason, show_evidence(warn.evidence))
+                    )
+                )
 
         mute: Mute
         async for mute in await db.stream(filter_by(Mute, member=user_id)):
-            text = t.ulog.muted.upgrade if mute.is_upgrade else t.ulog.muted.first
+            if mute.is_upgrade:
+                text = t.ulog.muted.upgrade
+                mute.evidence = None
+            else:
+                text = t.ulog.muted.first
 
             if mute.minutes == -1:
                 if show_ids:
-                    out.append((mute.timestamp, text.inf.id_on(f"<@{mute.mod}>", mute.reason, mute.id)))
+                    out.append(
+                        (
+                            mute.timestamp,
+                            text.inf.id_on(f"<@{mute.mod}>", mute.reason, mute.id, show_evidence(mute.evidence))
+                        )
+                    )
                 else:
-                    out.append((mute.timestamp, text.inf.id_off(f"<@{mute.mod}>", mute.reason)))
+                    out.append(
+                        (
+                            mute.timestamp,
+                            text.inf.id_off(f"<@{mute.mod}>", mute.reason, show_evidence(mute.evidence))
+                        )
+                    )
             else:
                 if show_ids:
                     out.append(
                         (
                             mute.timestamp,
-                            text.temp.id_on(f"<@{mute.mod}>", time_to_units(mute.minutes), mute.reason, mute.id)
+                            text.temp.id_on(f"<@{mute.mod}>", time_to_units(mute.minutes), mute.reason, mute.id,
+                                            show_evidence(mute.evidence)
+                                            )
                         )
                     )
                 else:
                     out.append(
                         (
                             mute.timestamp,
-                            text.temp.id_off(f"<@{mute.mod}>", time_to_units(mute.minutes), mute.reason)
+                            text.temp.id_off(f"<@{mute.mod}>", time_to_units(mute.minutes), mute.reason,
+                                             show_evidence(mute.evidence)
+                                             )
                         )
                     )
 
@@ -310,34 +354,61 @@ async def handle_get_userlog_entries(self, user_id: int, show_ids: bool) -> list
         async for kick in await db.stream(filter_by(Kick, member=user_id)):
             if kick.mod is not None:
                 if show_ids:
-                    out.append((kick.timestamp, t.ulog.kicked.id_on(f"<@{kick.mod}>", kick.reason, kick.id)))
+                    out.append(
+                        (
+                            kick.timestamp,
+                            t.ulog.kicked.id_on(f"<@{kick.mod}>", kick.reason, kick.id, show_evidence(kick.evidence))
+                        )
+                    )
                 else:
-                    out.append((kick.timestamp, t.ulog.kicked.id_off(f"<@{kick.mod}>", kick.reason)))
+                    out.append(
+                        (
+                            kick.timestamp,
+                            t.ulog.kicked.id_off(f"<@{kick.mod}>", kick.reason, show_evidence(kick.evidence))
+                        )
+                    )
             else:
                 out.append((kick.timestamp, t.ulog.autokicked))
 
         ban: Ban
         async for ban in await db.stream(filter_by(Ban, member=user_id)):
-            text = t.ulog.banned.upgrade if ban.is_upgrade else t.ulog.banned.first
+            if ban.is_upgrade:
+                text = t.ulog.banned.upgrade
+                ban.evidence = None
+            else:
+                text = t.ulog.banned.first
 
             if ban.minutes == -1:
                 if show_ids:
-                    out.append((ban.timestamp, text.inf.id_on(f"<@{ban.mod}>", ban.reason, ban.id)))
+                    out.append(
+                        (
+                            ban.timestamp,
+                            text.inf.id_on(f"<@{ban.mod}>", ban.reason, ban.id, show_evidence(ban.evidence))
+                        )
+                    )
                 else:
-                    out.append((ban.timestamp, text.inf.id_off(f"<@{ban.mod}>", ban.reason)))
+                    out.append(
+                        (
+                            ban.timestamp, text.inf.id_off(f"<@{ban.mod}>", ban.reason)
+                        )
+                    )
             else:
                 if show_ids:
                     out.append(
                         (
                             ban.timestamp,
-                            text.temp.id_on(f"<@{ban.mod}>", time_to_units(ban.minutes), ban.reason, ban.id)
+                            text.temp.id_on(f"<@{ban.mod}>", time_to_units(ban.minutes), ban.reason, ban.id,
+                                            show_evidence(ban.evidence)
+                                            )
                         )
                     )
                 else:
                     out.append(
                         (
                             ban.timestamp,
-                            text.temp.id_off(f"<@{ban.mod}>", time_to_units(ban.minutes), ban.reason)
+                            text.temp.id_off(f"<@{ban.mod}>", time_to_units(ban.minutes), ban.reason,
+                                             show_evidence(ban.evidence)
+                                             )
                         )
                     )
 
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index 88635a24d..ff0d4fda7 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -115,21 +115,23 @@ status_muted: ":mute: User is muted on this server."
 status_muted_time: ":mute: User is muted for {} on this server ({} left)."
 
 ulog:
+  evidence: "\n[[Evidence]]({})"
+
   reported:
-    id_off: ":speech_balloon: **Reported** by {} because of `{}`"
-    id_on: ":speech_balloon: **Reported** by {} because of `{}`\n`(ID: {})`"
+    id_off: ":speech_balloon: **Reported** by {} because of `{}`{}"
+    id_on: ":speech_balloon: **Reported** by {} because of `{}`\n`(ID: {})`{}"
   warned:
-    id_off: ":warning: **Warned** by {} because of `{}`"
-    id_on: ":warning: **Warned** by {} because of `{}`\n`(ID: {})`"
+    id_off: ":warning: **Warned** by {} because of `{}`{}"
+    id_on: ":warning: **Warned** by {} because of `{}`\n`(ID: {})`{}"
 
   muted:
     first:
       temp:
-        id_off: ":mute: **Muted** by {} for {} because of `{}`"
-        id_on: ":mute: **Muted** by {} for {} because of `{}`\n`(ID: {})`"
+        id_off: ":mute: **Muted** by {} for {} because of `{}`{}"
+        id_on: ":mute: **Muted** by {} for {} because of `{}`\n`(ID: {})`{}"
       inf:
-        id_off: ":mute: **Muted** permanently by {} because of `{}`"
-        id_on: ":mute: **Muted** permanently by {} because of `{}`\n`(ID: {})`"
+        id_off: ":mute: **Muted** permanently by {} because of `{}`{}"
+        id_on: ":mute: **Muted** permanently by {} because of `{}`\n`(ID: {})`{}"
     upgrade:
       temp:
         id_off: ":mute: **Mute upgraded** by {} to {} because of `{}`"
@@ -143,18 +145,18 @@ ulog:
   unmuted_expired: ":loud_sound: **Unmuted** because the mute time has expired."
 
   kicked:
-    id_off: ":x: **Kicked** by {} because of `{}`"
-    id_on: ":x: **Kicked** by {} because of `{}`\n`(ID: {})`"
+    id_off: ":x: **Kicked** by {} because of `{}`{}"
+    id_on: ":x: **Kicked** by {} because of `{}`\n`(ID: {})`{}"
   autokicked: ":hourglass: **Kicked** automatically."
 
   banned:
     first:
       temp:
-        id_off: ":no_entry: **Banned** by {} for {} because of `{}`"
-        id_on: ":no_entry: **Banned** by {} for {} because of `{}`\n`(ID: {})`"
+        id_off: ":no_entry: **Banned** by {} for {} because of `{}`{}"
+        id_on: ":no_entry: **Banned** by {} for {} because of `{}`\n`(ID: {})`{}"
       inf:
-        id_off: ":no_entry: **Banned** permanently by {} because of `{}`"
-        id_on: ":no_entry: **Banned** by {} for {} because of `{}`\n`(ID: {})`"
+        id_off: ":no_entry: **Banned** permanently by {} because of `{}`{}"
+        id_on: ":no_entry: **Banned** by {} for {} because of `{}`\n`(ID: {})`{}"
     upgrade:
       temp:
         id_off: ":no_entry: **Ban upgraded** by {} to {} because of `{}`"

From 9615ecdfbeb9e56179d68558ca03159c73f25b0f Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Mon, 5 Jul 2021 22:26:20 +0200
Subject: [PATCH 015/120] Added function to edit warn reasons

---
 moderation/mod/cog.py              | 64 +++++++++++++++++++++++++++++-
 moderation/mod/models.py           |  6 +++
 moderation/mod/translations/en.yml |  8 ++++
 3 files changed, 77 insertions(+), 1 deletion(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 16c5af21c..c6103544e 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -14,12 +14,13 @@
 )
 
 from PyDrocsid.cog import Cog
-from PyDrocsid.command import reply, UserCommandError
+from PyDrocsid.command import reply, UserCommandError, confirm
 from PyDrocsid.converter import UserMemberConverter
 from PyDrocsid.database import db, filter_by, db_wrapper
 from PyDrocsid.settings import RoleSettings
 from PyDrocsid.translations import t
 from PyDrocsid.util import is_teamler
+from PyDrocsid.config import Config
 from .colors import Colors
 from .models import Mute, Ban, Report, Warn, Kick
 from .permissions import ModPermission
@@ -97,6 +98,16 @@ def show_evidence(evidence: Optional[str]) -> str:
     return ""
 
 
+async def compare_mod_level(mod1: Member, mod2: Member) -> bool:
+    print(mod1)
+    print(mod2)
+
+    lvl1 = await Config.PERMISSION_LEVELS.get_permission_level(mod1)
+    lvl2 = await Config.PERMISSION_LEVELS.get_permission_level(mod2)
+
+    return lvl1.level > lvl2.level or mod1 == mod1.guild.owner
+
+
 async def send_to_changelog_mod(
     guild: Guild,
     message: Optional[Message],
@@ -516,6 +527,57 @@ async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         await reply(ctx, embed=server_embed)
         await send_to_changelog_mod(ctx.guild, ctx.message, Colors.warn, t.log_warned, user, reason, evidence=evidence)
 
+    @commands.command()
+    @ModPermission.warn.check
+    @guild_only()
+    async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
+        """
+        edit a warn
+        get the warn id from the users user log
+        """
+
+        warn = await db.get(Warn, id=warn_id)
+        if warn is None:
+            raise CommandError(t.no_warn)
+
+        if not await compare_mod_level(ctx.author, ctx.guild.get_member(warn.mod)):
+            raise CommandError(tg.permission_denied)
+
+        conf_embed = Embed(
+            title=t.confirmation,
+            description=t.confirm_warn_edit(warn.reason, reason),
+            color=Colors.ModTools
+        )
+
+        async with confirm(ctx, conf_embed) as (result, msg):
+            if not result:
+                conf_embed.description += "\n\n" + t.edit_canceled
+                return
+
+            conf_embed.description += "\n\n" + t.edit_confirmed
+            if msg:
+                await msg.delete(delay=5)
+
+        await Warn.edit(warn_id, ctx.author.id, reason)
+
+        user = self.bot.get_user(warn.member)
+
+        user_embed = Embed(
+            title=t.warn,
+            description=t.warn_edited(warn.reason, reason),
+            colour=Colors.ModTools,
+        )
+        server_embed = Embed(title=t.warn, description=t.warn_edited_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.avatar_url)
+
+        try:
+            await user.send(embed=user_embed)
+        except (Forbidden, HTTPException):
+            server_embed.description = t.no_dm + "\n\n" + server_embed.description
+            server_embed.colour = Colors.error
+        await reply(ctx, embed=server_embed)
+        await send_to_changelog_mod(ctx.guild, ctx.message, Colors.warn, t.log_warn_edited, user, reason)
+
     @commands.command()
     @ModPermission.mute.check
     @guild_only()
diff --git a/moderation/mod/models.py b/moderation/mod/models.py
index 97f2a9a19..0d452541f 100644
--- a/moderation/mod/models.py
+++ b/moderation/mod/models.py
@@ -56,6 +56,12 @@ async def create(member: int, member_name: str, mod: int, reason: str, evidence:
         await db.add(row)
         return row
 
+    @staticmethod
+    async def edit(warn_id: int, mod: int, new_reason: str):
+        row = await db.get(Warn, id=warn_id)
+        row.mod = mod
+        row.reason = new_reason
+
 
 class Mute(db.Base):
     __tablename__ = "mute"
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index ff0d4fda7..3349ce15e 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -36,6 +36,9 @@ image_link: "{} [[Go to image]]({})"
 no_dm: ":warning: User does not allow direct messages."
 reason_too_long: "Reason is too long. :pencil:"
 invalid_duration_inf: Invalid duration. Try `inf` instead.
+confirmation: Edit confirmation
+edit_canceled: ":x: Edit canceled"
+edit_confirmed: ":white_check_mark: Edit confirmed"
 
 report: ":speech_balloon: Report"
 cannot_report: This member cannot be reported.
@@ -50,6 +53,11 @@ warned:
   no_evidence: "{} just warned you on {}:```\n{}\n```"
 warned_response: "User warned successfully :white_check_mark:"
 log_warned: ":warning: Member warned"
+no_warn: No warn with this ID could be found
+confirm_warn_edit: "Are you sure you want to change this warns reason from ```\n{}\n```to```\n{}\n```?"
+warn_edited: "The warn reason has been changed from ```\n{}\n```to```\n{}\n```"
+warn_edited_response: ":white_check_mark: The warn reason has been edited"
+log_warn_edited: ":warning: Warn edited"
 
 mute: ":mute: Mute"
 unmute: ":loud_sound: Mute"

From 1a01fa0b70c360752c5bd98943f722b3c15ecc31 Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Mon, 5 Jul 2021 22:28:00 +0200
Subject: [PATCH 016/120] Removed forgotten print statements

---
 moderation/mod/cog.py | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index c6103544e..451a0b855 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -99,9 +99,6 @@ def show_evidence(evidence: Optional[str]) -> str:
 
 
 async def compare_mod_level(mod1: Member, mod2: Member) -> bool:
-    print(mod1)
-    print(mod2)
-
     lvl1 = await Config.PERMISSION_LEVELS.get_permission_level(mod1)
     lvl2 = await Config.PERMISSION_LEVELS.get_permission_level(mod2)
 

From 8298a342a3738d3a410e261f32eb894e3d14cb93 Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Tue, 6 Jul 2021 11:03:32 +0200
Subject: [PATCH 017/120] Added function to edit mute reasons

---
 moderation/mod/cog.py              | 60 ++++++++++++++++++++++++++++++
 moderation/mod/models.py           | 10 +++++
 moderation/mod/translations/en.yml |  6 +++
 3 files changed, 76 insertions(+)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 451a0b855..aca1e5438 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -11,6 +11,7 @@
     CommandError,
     Converter,
     BadArgument,
+    UserInputError,
 )
 
 from PyDrocsid.cog import Cog
@@ -674,6 +675,65 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
 
         await reply(ctx, embed=server_embed)
 
+    @commands.group()
+    @ModPermission.mute.check
+    @guild_only()
+    async def edit_mute(self, ctx):
+        if ctx.invoked_subcommand is None:
+            raise UserInputError
+
+    @edit_mute.command(name="reason")
+    async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
+        """
+        edit a mute
+        get the mute id from the users user log
+        """
+
+        mute = await db.get(Mute, id=mute_id)
+        if mute is None:
+            raise CommandError(t.no_warn)
+
+        if not await compare_mod_level(ctx.author, ctx.guild.get_member(mute.mod)):
+            raise CommandError(tg.permission_denied)
+
+        conf_embed = Embed(
+            title=t.confirmation,
+            description=t.confirm_mute_edit.reason(mute.reason, reason),
+            color=Colors.ModTools
+        )
+
+        async with confirm(ctx, conf_embed) as (result, msg):
+            if not result:
+                conf_embed.description += "\n\n" + t.edit_canceled
+                return
+
+            conf_embed.description += "\n\n" + t.edit_confirmed
+            if msg:
+                await msg.delete(delay=5)
+
+        await Mute.edit(mute_id, ctx.author.id, reason)
+
+        user = self.bot.get_user(mute.member)
+
+        user_embed = Embed(
+            title=t.warn,
+            description=t.mute_edited.reason(mute.reason, reason),
+            colour=Colors.ModTools,
+        )
+        server_embed = Embed(title=t.mute, description=t.mute_edited_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.avatar_url)
+
+        try:
+            await user.send(embed=user_embed)
+        except (Forbidden, HTTPException):
+            server_embed.description = t.no_dm + "\n\n" + server_embed.description
+            server_embed.colour = Colors.error
+        await reply(ctx, embed=server_embed)
+        await send_to_changelog_mod(ctx.guild, ctx.message, Colors.mute, t.log_mute_edited, user, reason)
+
+
+
+
     @commands.command()
     @ModPermission.mute.check
     @guild_only()
diff --git a/moderation/mod/models.py b/moderation/mod/models.py
index 0d452541f..4007840fb 100644
--- a/moderation/mod/models.py
+++ b/moderation/mod/models.py
@@ -115,6 +115,16 @@ async def upgrade(ban_id: int, mod: int):
         mute = await Mute.deactivate(ban_id, mod)
         mute.upgraded = True
 
+    @staticmethod
+    async def edit(mute_id: int, mod: int, new_reason: Optional[str] = None, new_duration: Optional[int] = None):
+        row = await db.get(Mute, id=mute_id)
+        row.mod = mod
+
+        if new_reason:
+            row.reason = new_reason
+        if new_duration:
+            row.minutes = new_duration
+
 
 class Kick(db.Base):
     __tablename__ = "kick"
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index 3349ce15e..ead4eadae 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -76,6 +76,12 @@ log_unmuted_expired: "Unmuted automatically because the mute time for this user
 unmuted_response: "User unmuted successfully :white_check_mark:"
 log_unmuted: ":loud_sound: Member unmuted"
 not_muted: User is not muted.
+confirm_mute_edit:
+  reason: "Are you sure you want to change this mutes reason from ```\n{}\n```to```\n{}\n```?"
+mute_edited:
+  reason: "The mute reason has been changed from ```\n{}\n```to```\n{}\n```"
+mute_edited_response: ":white_check_mark: The mute reason has been edited"
+log_mute_edited: ":mute: Mute edited"
 
 kick: ":x: Kick"
 kicked:

From 199b7f51f283bb39366a43184e9df5b6ad75310f Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Tue, 6 Jul 2021 13:32:38 +0200
Subject: [PATCH 018/120] Added function to edit mute durations

---
 moderation/mod/cog.py              | 123 ++++++++++++++++++++++++-----
 moderation/mod/models.py           |  16 ++--
 moderation/mod/translations/en.yml |  14 ++--
 3 files changed, 121 insertions(+), 32 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index aca1e5438..ffe255a87 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -299,8 +299,8 @@ async def handle_get_userlog_entries(self, user_id: int, show_ids: bool) -> list
 
         mute: Mute
         async for mute in await db.stream(filter_by(Mute, member=user_id)):
-            if mute.is_upgrade:
-                text = t.ulog.muted.upgrade
+            if mute.is_update:
+                text = t.ulog.muted.update
                 mute.evidence = None
             else:
                 text = t.ulog.muted.first
@@ -340,7 +340,7 @@ async def handle_get_userlog_entries(self, user_id: int, show_ids: bool) -> list
                         )
                     )
 
-            if not mute.active and not mute.upgraded:
+            if not mute.active and not mute.updated:
                 if mute.unmute_mod is None:
                     out.append((mute.deactivation_timestamp, t.ulog.unmuted_expired))
                 else:
@@ -541,6 +541,9 @@ async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
         if not await compare_mod_level(ctx.author, ctx.guild.get_member(warn.mod)):
             raise CommandError(tg.permission_denied)
 
+        if len(reason) > 900:
+            raise CommandError(t.reason_too_long)
+
         conf_embed = Embed(
             title=t.confirmation,
             description=t.confirm_warn_edit(warn.reason, reason),
@@ -583,7 +586,7 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
         """
         mute a user
         time format: `ymwdhn`
-        set days to `inf` for a permanent mute
+        set time to `inf` for a permanent mute
         """
 
         user: Union[Member, User]
@@ -604,13 +607,8 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
             await user.move_to(None)
 
         active_mutes: List[Mute] = await db.all(filter_by(Mute, active=True, member=user.id))
-        for mute in active_mutes:
-            if mute.minutes == -1:
-                raise UserCommandError(user, t.already_muted)
-
-            ts = mute.timestamp + timedelta(minutes=mute.minutes)
-            if minutes is not None and datetime.utcnow() + timedelta(minutes=minutes) <= ts:
-                raise UserCommandError(user, t.already_muted)
+        if active_mutes:
+            raise UserCommandError(user, t.already_muted)
 
         if attachments := ctx.message.attachments:
             evidence = attachments[0]
@@ -619,15 +617,12 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
             evidence = None
             evidence_url = None
 
-        for mute in active_mutes:
-            await Mute.upgrade(mute.id, ctx.author.id)
-
         user_embed = Embed(title=t.mute, colour=Colors.ModTools)
         server_embed = Embed(title=t.mute, description=t.muted_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.avatar_url)
 
         if minutes is not None:
-            await Mute.create(user.id, str(user), ctx.author.id, minutes, reason, evidence_url, bool(active_mutes))
+            await Mute.create(user.id, str(user), ctx.author.id, minutes, reason, evidence_url)
             if evidence:
                 user_embed.description = t.muted.evidence(ctx.author.mention, ctx.guild.name, time_to_units(minutes),
                                                           reason, t.image_link(evidence.filename, evidence_url),
@@ -648,7 +643,7 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
                 evidence=evidence,
             )
         else:
-            await Mute.create(user.id, str(user), ctx.author.id, -1, reason, evidence_url, bool(active_mutes))
+            await Mute.create(user.id, str(user), ctx.author.id, -1, reason, evidence_url)
             if evidence:
                 user_embed.description = t.muted_inf.evidence(ctx.author.mention, ctx.guild.name, reason,
                                                               t.image_link(evidence.filename, evidence_url),
@@ -679,6 +674,10 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
     @ModPermission.mute.check
     @guild_only()
     async def edit_mute(self, ctx):
+        """
+        edit a mute
+        """
+
         if ctx.invoked_subcommand is None:
             raise UserInputError
 
@@ -691,11 +690,14 @@ async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
 
         mute = await db.get(Mute, id=mute_id)
         if mute is None:
-            raise CommandError(t.no_warn)
+            raise CommandError(t.no_mute)
 
         if not await compare_mod_level(ctx.author, ctx.guild.get_member(mute.mod)):
             raise CommandError(tg.permission_denied)
 
+        if len(reason) > 900:
+            raise CommandError(t.reason_too_long)
+
         conf_embed = Embed(
             title=t.confirmation,
             description=t.confirm_mute_edit.reason(mute.reason, reason),
@@ -716,7 +718,7 @@ async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
         user = self.bot.get_user(mute.member)
 
         user_embed = Embed(
-            title=t.warn,
+            title=t.mute,
             description=t.mute_edited.reason(mute.reason, reason),
             colour=Colors.ModTools,
         )
@@ -731,6 +733,91 @@ async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
         await reply(ctx, embed=server_embed)
         await send_to_changelog_mod(ctx.guild, ctx.message, Colors.mute, t.log_mute_edited, user, reason)
 
+    @edit_mute.command(name="duration")
+    async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time: DurationConverter):
+        """
+        edit a mute duration
+        time format: `ymwdhn`
+        set time to `inf` for a permanent mute
+        """
+
+        user: Union[Member, User]
+        time: Optional[int]
+        minutes = time
+
+        active_mutes: List[Mute] = await db.all(filter_by(Mute, active=True, member=user.id))
+
+        if not active_mutes:
+            raise CommandError(t.not_muted)
+
+        mute = sorted(active_mutes, key=lambda active_mute: active_mute.timestamp)[0]
+
+        if not await compare_mod_level(ctx.author, ctx.guild.get_member(mute.mod)):
+            raise CommandError(tg.permission_denied)
+
+        conf_embed = Embed(
+            title=t.confirmation,
+            color=Colors.ModTools,
+        )
+
+        if minutes is None:
+            conf_embed.description = t.confirm_mute_edit.duration(time_to_units(mute.minutes), t.infinity)
+        else:
+            conf_embed.description = t.confirm_mute_edit.duration(time_to_units(mute.minutes), time_to_units(minutes))
+
+        async with confirm(ctx, conf_embed) as (result, msg):
+            if not result:
+                conf_embed.description += "\n\n" + t.edit_canceled
+                return
+
+            conf_embed.description += "\n\n" + t.edit_confirmed
+            if msg:
+                await msg.delete(delay=5)
+
+        for mute in active_mutes:
+            await Mute.update(mute.id, ctx.author.id)
+
+        user_embed = Embed(
+            title=t.mute,
+            colour=Colors.ModTools,
+        )
+        server_embed = Embed(title=t.mute, description=t.mute_edited_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.avatar_url)
+
+        if minutes is not None:
+            await Mute.create(user.id, str(user), ctx.author.id, minutes, mute.reason, mute.evidence, True)
+            user_embed.description = t.mute_edited.duration(time_to_units(mute.minutes), time_to_units(minutes))
+            await send_to_changelog_mod(
+                ctx.guild,
+                ctx.message,
+                Colors.mute,
+                t.log_mute_edited,
+                user,
+                mute.reason,
+                duration=time_to_units(minutes),
+            )
+
+        else:
+            await Mute.create(user.id, str(user), ctx.author.id, -1, mute.reason, mute.evidence, True)
+            user_embed.description = t.mute_edited.duration(time_to_units(mute.minutes), t.infinity)
+            await send_to_changelog_mod(
+                ctx.guild,
+                ctx.message,
+                Colors.mute,
+                t.log_mute_edited,
+                user, mute.reason,
+                duration=t.log_field.infinity,
+            )
+
+        try:
+            await user.send(embed=user_embed)
+        except (Forbidden, HTTPException):
+            server_embed.description = t.no_dm + "\n\n" + server_embed.description
+            server_embed.colour = Colors.error
+        await reply(ctx, embed=server_embed)
+
+
+
 
 
 
diff --git a/moderation/mod/models.py b/moderation/mod/models.py
index 4007840fb..6e03e96ad 100644
--- a/moderation/mod/models.py
+++ b/moderation/mod/models.py
@@ -78,12 +78,12 @@ class Mute(db.Base):
     deactivation_timestamp: Union[Column, Optional[datetime]] = Column(DateTime, nullable=True)
     unmute_mod: Union[Column, Optional[int]] = Column(BigInteger, nullable=True)
     unmute_reason: Union[Column, Optional[str]] = Column(Text(collation="utf8mb4_bin"), nullable=True)
-    upgraded: Union[Column, bool] = Column(Boolean, default=False)
-    is_upgrade: Union[Column, bool] = Column(Boolean)
+    updated: Union[Column, bool] = Column(Boolean, default=False)
+    is_update: Union[Column, bool] = Column(Boolean)
 
     @staticmethod
     async def create(member: int, member_name: str, mod: int, minutes: int, reason: str,
-                     evidence: Optional[str], is_upgrade: bool = False) -> Mute:
+                     evidence: Optional[str], is_update: bool = False) -> Mute:
         row = Mute(
             member=member,
             member_name=member_name,
@@ -96,7 +96,7 @@ async def create(member: int, member_name: str, mod: int, minutes: int, reason:
             deactivation_timestamp=None,
             unmute_mod=None,
             unmute_reason=None,
-            is_upgrade=is_upgrade,
+            is_update=is_update,
         )
         await db.add(row)
         return row
@@ -111,19 +111,17 @@ async def deactivate(mute_id: int, unmute_mod: int = None, reason: str = None) -
         return row
 
     @staticmethod
-    async def upgrade(ban_id: int, mod: int):
+    async def update(ban_id: int, mod: int):
         mute = await Mute.deactivate(ban_id, mod)
-        mute.upgraded = True
+        mute.updated = True
 
     @staticmethod
-    async def edit(mute_id: int, mod: int, new_reason: Optional[str] = None, new_duration: Optional[int] = None):
+    async def edit(mute_id: int, mod: int, new_reason: str):
         row = await db.get(Mute, id=mute_id)
         row.mod = mod
 
         if new_reason:
             row.reason = new_reason
-        if new_duration:
-            row.minutes = new_duration
 
 
 class Kick(db.Base):
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index ead4eadae..16f89e129 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -39,6 +39,7 @@ invalid_duration_inf: Invalid duration. Try `inf` instead.
 confirmation: Edit confirmation
 edit_canceled: ":x: Edit canceled"
 edit_confirmed: ":white_check_mark: Edit confirmed"
+infinity: Permanent
 
 report: ":speech_balloon: Report"
 cannot_report: This member cannot be reported.
@@ -76,10 +77,13 @@ log_unmuted_expired: "Unmuted automatically because the mute time for this user
 unmuted_response: "User unmuted successfully :white_check_mark:"
 log_unmuted: ":loud_sound: Member unmuted"
 not_muted: User is not muted.
+no_mute: No mute with this ID could be found
 confirm_mute_edit:
   reason: "Are you sure you want to change this mutes reason from ```\n{}\n```to```\n{}\n```?"
+  duration: "Are you sure you want to change the mute duration from ```\n{}\n```to```\n{}\n```?"
 mute_edited:
   reason: "The mute reason has been changed from ```\n{}\n```to```\n{}\n```"
+  duration: "The mute duration has been changed from ```\n{}\n```to```\n{}\n```"
 mute_edited_response: ":white_check_mark: The mute reason has been edited"
 log_mute_edited: ":mute: Mute edited"
 
@@ -146,13 +150,13 @@ ulog:
       inf:
         id_off: ":mute: **Muted** permanently by {} because of `{}`{}"
         id_on: ":mute: **Muted** permanently by {} because of `{}`\n`(ID: {})`{}"
-    upgrade:
+    update:
       temp:
-        id_off: ":mute: **Mute upgraded** by {} to {} because of `{}`"
-        id_on: ":mute: **Mute upgraded** by {} to {} because of `{}`\n`(ID: {})`"
+        id_off: ":mute: **Mute updated** by {} to {} because of `{}`"
+        id_on: ":mute: **Mute updated** by {} to {} because of `{}`\n`(ID: {})`"
       inf:
-        id_off: ":mute: **Mute upgraded** to permanent by {} because of `{}`"
-        id_on: ":mute: **Mute upgraded** to permanent by {} because of `{}`\n`(ID: {})`"
+        id_off: ":mute: **Mute updated** to permanent by {} because of `{}`"
+        id_on: ":mute: **Mute updated** to permanent by {} because of `{}`\n`(ID: {})`"
   unmuted:
     id_off: ":loud_sound: **Unmuted** by {} because of `{}`"
     id_on: ":loud_sound: **Unmuted** by {} because of `{}`\n`(ID: {})`"

From c30138c9acd782f3773a30a6e3282c56fcb2e460 Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Wed, 7 Jul 2021 11:16:53 +0200
Subject: [PATCH 019/120] Added function to edit kick reasons

---
 moderation/mod/cog.py              | 61 +++++++++++++++++++++++++++---
 moderation/mod/models.py           |  6 +++
 moderation/mod/translations/en.yml |  5 +++
 3 files changed, 66 insertions(+), 6 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index ffe255a87..2f49925de 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -684,7 +684,7 @@ async def edit_mute(self, ctx):
     @edit_mute.command(name="reason")
     async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
         """
-        edit a mute
+        edit a mute reason
         get the mute id from the users user log
         """
 
@@ -816,11 +816,6 @@ async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time
             server_embed.colour = Colors.error
         await reply(ctx, embed=server_embed)
 
-
-
-
-
-
     @commands.command()
     @ModPermission.mute.check
     @guild_only()
@@ -912,6 +907,60 @@ async def kick(self, ctx: Context, member: Member, *, reason: str):
 
         await reply(ctx, embed=server_embed)
 
+    @commands.command()
+    @ModPermission.warn.check
+    @guild_only()
+    async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
+        """
+        edit a kick
+        get the kick id from the users user log
+        """
+
+        kick = await db.get(Kick, id=kick_id)
+        if kick is None:
+            raise CommandError(t.no_kick)
+
+        if not await compare_mod_level(ctx.author, ctx.guild.get_member(kick.mod)):
+            raise CommandError(tg.permission_denied)
+
+        if len(reason) > 900:
+            raise CommandError(t.reason_too_long)
+
+        conf_embed = Embed(
+            title=t.confirmation,
+            description=t.confirm_kick_edit(kick.reason, reason),
+            color=Colors.ModTools
+        )
+
+        async with confirm(ctx, conf_embed) as (result, msg):
+            if not result:
+                conf_embed.description += "\n\n" + t.edit_canceled
+                return
+
+            conf_embed.description += "\n\n" + t.edit_confirmed
+            if msg:
+                await msg.delete(delay=5)
+
+        await Kick.edit(kick_id, ctx.author.id, reason)
+
+        user = self.bot.get_user(kick.member)
+
+        user_embed = Embed(
+            title=t.kick,
+            description=t.kick_edited(kick.reason, reason),
+            colour=Colors.ModTools,
+        )
+        server_embed = Embed(title=t.kick, description=t.kick_edited_reponse, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.avatar_url)
+
+        try:
+            await user.send(embed=user_embed)
+        except (Forbidden, HTTPException):
+            server_embed.description = t.no_dm + "\n\n" + server_embed.description
+            server_embed.colour = Colors.error
+        await reply(ctx, embed=server_embed)
+        await send_to_changelog_mod(ctx.guild, ctx.message, Colors.kick, t.log_kick_edited, user, reason)
+
     @commands.command()
     @ModPermission.ban.check
     @guild_only()
diff --git a/moderation/mod/models.py b/moderation/mod/models.py
index 6e03e96ad..342a9691e 100644
--- a/moderation/mod/models.py
+++ b/moderation/mod/models.py
@@ -148,6 +148,12 @@ async def create(member: int, member_name: str, mod: Optional[int], reason: Opti
         await db.add(row)
         return row
 
+    @staticmethod
+    async def edit(kick_id: int, mod: int, new_reason: str):
+        row = await db.get(Kick, id=kick_id)
+        row.mod = mod
+        row.reason = new_reason
+
 
 class Ban(db.Base):
     __tablename__ = "ban"
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index 16f89e129..3b2cb190c 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -95,6 +95,11 @@ kicked_response: "User kicked successfully :white_check_mark:"
 log_kicked: ":x: Member kicked"
 cannot_kick: This member cannot be kicked.
 cannot_kick_permissions: User could not be kicked because I don't have `kick_members` permission on this server.
+no_kick: No kick with this ID could be found
+confirm_kick_edit: "Are you sure you want to change this kicks reason from ```\n{}\n```to```\n{}\n```?"
+kick_edited: "The kick reason has been changed from ```\n{}\n```to```\n{}\n```"
+kick_edited_reponse: ":white_check_mark: The kick reason has been edited"
+log_kick_edited: ":x: Kick edited"
 
 ban: ":no_entry: Ban"
 unban: ":white_check_mark: Ban"

From 458d35a66faf8b78068b25b80dca98627a3fc310 Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Wed, 7 Jul 2021 11:37:16 +0200
Subject: [PATCH 020/120] Added function to edit ban reasons

---
 moderation/mod/cog.py              | 69 ++++++++++++++++++++++++++++--
 moderation/mod/models.py           | 10 +++--
 moderation/mod/translations/en.yml |  9 ++++
 3 files changed, 82 insertions(+), 6 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 2f49925de..2d9417a7a 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -713,8 +713,6 @@ async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
             if msg:
                 await msg.delete(delay=5)
 
-        await Mute.edit(mute_id, ctx.author.id, reason)
-
         user = self.bot.get_user(mute.member)
 
         user_embed = Embed(
@@ -725,6 +723,8 @@ async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
         server_embed = Embed(title=t.mute, description=t.mute_edited_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.avatar_url)
 
+        await Mute.edit(mute_id, ctx.author.id, reason)
+
         try:
             await user.send(embed=user_embed)
         except (Forbidden, HTTPException):
@@ -1009,7 +1009,7 @@ async def ban(
         for ban in active_bans:
             await Ban.upgrade(ban.id, ctx.author.id)
         async for mute in await db.stream(filter_by(Mute, active=True, member=user.id)):
-            await Mute.upgrade(mute.id, ctx.author.id)
+            await Mute.update(mute.id, ctx.author.id)
 
         if attachments := ctx.message.attachments:
             evidence = attachments[0]
@@ -1073,6 +1073,69 @@ async def ban(
 
         await reply(ctx, embed=server_embed)
 
+    @commands.group()
+    @ModPermission.mute.check
+    @guild_only()
+    async def edit_ban(self, ctx):
+        """
+        edit a ban
+        """
+
+        if ctx.invoked_subcommand is None:
+            raise UserInputError
+
+    @edit_ban.command(name="reason")
+    async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
+        """
+        edit a ban reason
+        get the ban id from the users user log
+        """
+
+        ban = await db.get(Ban, id=ban_id)
+        if ban is None:
+            raise CommandError(t.no_ban)
+
+        if not await compare_mod_level(ctx.author, ctx.guild.get_member(ban.mod)):
+            raise CommandError(tg.permission_denied)
+
+        if len(reason) > 900:
+            raise CommandError(t.reason_too_long)
+
+        conf_embed = Embed(
+            title=t.confirmation,
+            description=t.confirm_ban_edit.reason(ban.reason, reason),
+            color=Colors.ModTools
+        )
+
+        async with confirm(ctx, conf_embed) as (result, msg):
+            if not result:
+                conf_embed.description += "\n\n" + t.edit_canceled
+                return
+
+            conf_embed.description += "\n\n" + t.edit_confirmed
+            if msg:
+                await msg.delete(delay=5)
+
+        user = self.bot.get_user(ban.member)
+
+        user_embed = Embed(
+            title=t.ban,
+            description=t.ban_edited.reason(ban.reason, reason),
+            colour=Colors.ModTools,
+        )
+        server_embed = Embed(title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.avatar_url)
+
+        await Ban.edit(ban_id, ctx.author.id, reason)
+
+        try:
+            await user.send(embed=user_embed)
+        except (Forbidden, HTTPException):
+            server_embed.description = t.no_dm + "\n\n" + server_embed.description
+            server_embed.colour = Colors.error
+        await reply(ctx, embed=server_embed)
+        await send_to_changelog_mod(ctx.guild, ctx.message, Colors.ban, t.log_ban_edited, user, reason)
+
     @commands.command()
     @ModPermission.ban.check
     @guild_only()
diff --git a/moderation/mod/models.py b/moderation/mod/models.py
index 342a9691e..fb6a52b04 100644
--- a/moderation/mod/models.py
+++ b/moderation/mod/models.py
@@ -119,9 +119,7 @@ async def update(ban_id: int, mod: int):
     async def edit(mute_id: int, mod: int, new_reason: str):
         row = await db.get(Mute, id=mute_id)
         row.mod = mod
-
-        if new_reason:
-            row.reason = new_reason
+        row.reason = new_reason
 
 
 class Kick(db.Base):
@@ -206,3 +204,9 @@ async def deactivate(ban_id: int, unban_mod: int = None, unban_reason: str = Non
     async def upgrade(ban_id: int, mod: int):
         ban = await Ban.deactivate(ban_id, mod)
         ban.upgraded = True
+
+    @staticmethod
+    async def edit(ban_id: int, mod: int, new_reason: str):
+        row = await db.get(Ban, id=ban_id)
+        row.mod = mod
+        row.reason = new_reason
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index 3b2cb190c..150d54dff 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -119,6 +119,15 @@ not_banned: This member is not banned.
 unbanned_response: "User unbanned. :white_check_mark:"
 log_unbanned: ":white_check_mark: Member Unbanned"
 cannot_unban_permissions: User could not be unbanned because I don't have `ban_members` permission on this server.
+no_ban: No ban with this ID could be found
+confirm_ban_edit:
+  reason: "Are you sure you want to change this bans reason from ```\n{}\n```to```\n{}\n```?"
+  duration: "Are you sure you want to change the bans duration from ```\n{}\n```to```\n{}\n```?"
+ban_edited:
+  reason: "The ban reason has been changed from ```\n{}\n```to```\n{}\n```"
+  duration: "The ban duration has been changed from ```\n{}\n```to```\n{}\n```"
+ban_edited_response: ":white_check_mark: The ban reason has been edited"
+log_ban_edited: ":no_entry: Ban edited"
 
 reported_cnt: ":speech_balloon:  Reported"
 warned_cnt: ":warning:  Warned"

From ca83e225605bf56cb81cc1c6147e103a29fd78c2 Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Sun, 11 Jul 2021 22:57:50 +0200
Subject: [PATCH 021/120] Added a function to edit ban durations

---
 moderation/mod/cog.py              | 110 ++++++++++++++++++++++++-----
 moderation/mod/models.py           |  12 ++--
 moderation/mod/translations/en.yml |  10 +--
 3 files changed, 103 insertions(+), 29 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 2d9417a7a..c84822f09 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -381,8 +381,8 @@ async def handle_get_userlog_entries(self, user_id: int, show_ids: bool) -> list
 
         ban: Ban
         async for ban in await db.stream(filter_by(Ban, member=user_id)):
-            if ban.is_upgrade:
-                text = t.ulog.banned.upgrade
+            if ban.is_update:
+                text = t.ulog.banned.update
                 ban.evidence = None
             else:
                 text = t.ulog.banned.first
@@ -421,7 +421,7 @@ async def handle_get_userlog_entries(self, user_id: int, show_ids: bool) -> list
                         )
                     )
 
-            if not ban.active and not ban.upgraded:
+            if not ban.active and not ban.updated:
                 if ban.unban_mod is None:
                     out.append((ban.deactivation_timestamp, t.ulog.unbanned_expired))
                 else:
@@ -998,18 +998,8 @@ async def ban(
             raise UserCommandError(user, t.cannot_ban)
 
         active_bans: List[Ban] = await db.all(filter_by(Ban, active=True, member=user.id))
-        for ban in active_bans:
-            if ban.minutes == -1:
-                raise UserCommandError(user, t.already_banned)
-
-            ts = ban.timestamp + timedelta(minutes=ban.minutes)
-            if minutes is not None and datetime.utcnow() + timedelta(minutes=minutes) <= ts:
-                raise UserCommandError(user, t.already_banned)
-
-        for ban in active_bans:
-            await Ban.upgrade(ban.id, ctx.author.id)
-        async for mute in await db.stream(filter_by(Mute, active=True, member=user.id)):
-            await Mute.update(mute.id, ctx.author.id)
+        if active_bans:
+            raise UserCommandError(user, t.already_banned)
 
         if attachments := ctx.message.attachments:
             evidence = attachments[0]
@@ -1023,7 +1013,7 @@ async def ban(
         server_embed.set_author(name=str(user), icon_url=user.avatar_url)
 
         if minutes is not None:
-            await Ban.create(user.id, str(user), ctx.author.id, minutes, reason, evidence_url, bool(active_bans))
+            await Ban.create(user.id, str(user), ctx.author.id, minutes, reason, evidence_url, False)
             if evidence:
                 user_embed.description = t.banned.evidence(ctx.author.mention, ctx.guild.name, time_to_units(minutes),
                                                            reason, t.image_link(evidence.filename, evidence_url)
@@ -1043,7 +1033,7 @@ async def ban(
                 evidence=evidence,
             )
         else:
-            await Ban.create(user.id, str(user), ctx.author.id, -1, reason, evidence_url, bool(active_bans))
+            await Ban.create(user.id, str(user), ctx.author.id, -1, reason, evidence_url, False)
             if evidence:
                 user_embed.description = t.banned.evidence(ctx.author.mention, ctx.guild.name, reason,
                                                            t.image_link(evidence.filename, evidence_url)
@@ -1068,7 +1058,7 @@ async def ban(
             server_embed.description = t.no_dm + "\n\n" + server_embed.description
             server_embed.colour = Colors.error
 
-        await ctx.guild.ban(user, delete_message_days=delete_days, reason=reason)
+        # await ctx.guild.ban(user, delete_message_days=delete_days, reason=reason)
         await revoke_verification(user)
 
         await reply(ctx, embed=server_embed)
@@ -1136,6 +1126,90 @@ async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
         await reply(ctx, embed=server_embed)
         await send_to_changelog_mod(ctx.guild, ctx.message, Colors.ban, t.log_ban_edited, user, reason)
 
+    @edit_ban.command(name="duration")
+    async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time: DurationConverter):
+        """
+        edit a ban duration
+        time format: `ymwdhn`
+        set time to `inf` for a permanent ban
+        """
+
+        user: Union[Member, User]
+        time: Optional[int]
+        minutes = time
+
+        active_bans: List[Mute] = await db.all(filter_by(Ban, active=True, member=user.id))
+
+        if not active_bans:
+            raise CommandError(t.not_muted)
+
+        ban = sorted(active_bans, key=lambda active_ban: active_ban.timestamp)[0]
+
+        if not await compare_mod_level(ctx.author, ctx.guild.get_member(ban.mod)):
+            raise CommandError(tg.permission_denied)
+
+        conf_embed = Embed(
+            title=t.confirmation,
+            color=Colors.ModTools,
+        )
+
+        if minutes is None:
+            conf_embed.description = t.confirm_ban_edit.duration(time_to_units(ban.minutes), t.infinity)
+        else:
+            conf_embed.description = t.confirm_ban_edit.duration(time_to_units(ban.minutes), time_to_units(minutes))
+
+        async with confirm(ctx, conf_embed) as (result, msg):
+            if not result:
+                conf_embed.description += "\n\n" + t.edit_canceled
+                return
+
+            conf_embed.description += "\n\n" + t.edit_confirmed
+            if msg:
+                await msg.delete(delay=5)
+
+        for ban in active_bans:
+            await ban.update(ban.id, ctx.author.id)
+
+        user_embed = Embed(
+            title=t.ban,
+            colour=Colors.ModTools,
+        )
+        server_embed = Embed(title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.avatar_url)
+
+        if minutes is not None:
+            await Ban.create(user.id, str(user), ctx.author.id, minutes, ban.reason, ban.evidence, True)
+            user_embed.description = t.ban_edited.duration(time_to_units(ban.minutes), time_to_units(minutes))
+            await send_to_changelog_mod(
+                ctx.guild,
+                ctx.message,
+                Colors.mute,
+                t.log_ban_edited,
+                user,
+                ban.reason,
+                duration=time_to_units(minutes),
+            )
+
+        else:
+            await Ban.create(user.id, str(user), ctx.author.id, -1, ban.reason, ban.evidence, True)
+            user_embed.description = t.ban_edited.duration(time_to_units(ban.minutes), t.infinity)
+            await send_to_changelog_mod(
+                ctx.guild,
+                ctx.message,
+                Colors.mute,
+                t.log_ban_edited,
+                user,
+                ban.reason,
+                duration=t.log_field.infinity,
+            )
+
+        try:
+            await user.send(embed=user_embed)
+        except (Forbidden, HTTPException):
+            server_embed.description = t.no_dm + "\n\n" + server_embed.description
+            server_embed.colour = Colors.error
+        await reply(ctx, embed=server_embed)
+
     @commands.command()
     @ModPermission.ban.check
     @guild_only()
diff --git a/moderation/mod/models.py b/moderation/mod/models.py
index fb6a52b04..360f2ca0e 100644
--- a/moderation/mod/models.py
+++ b/moderation/mod/models.py
@@ -168,12 +168,12 @@ class Ban(db.Base):
     deactivation_timestamp: Union[Column, Optional[datetime]] = Column(DateTime, nullable=True)
     unban_reason: Union[Column, Optional[str]] = Column(Text(collation="utf8mb4_bin"), nullable=True)
     unban_mod: Union[Column, Optional[int]] = Column(BigInteger, nullable=True)
-    upgraded: Union[Column, bool] = Column(Boolean, default=False)
-    is_upgrade: Union[Column, bool] = Column(Boolean)
+    updated: Union[Column, bool] = Column(Boolean, default=False)
+    is_update: Union[Column, bool] = Column(Boolean)
 
     @staticmethod
     async def create(member: int, member_name: str, mod: int, minutes: int, reason: str,
-                     evidence: Optional[str], is_upgrade: bool = False) -> Ban:
+                     evidence: Optional[str], is_update: bool = False) -> Ban:
         row = Ban(
             member=member,
             member_name=member_name,
@@ -186,7 +186,7 @@ async def create(member: int, member_name: str, mod: int, minutes: int, reason:
             deactivation_timestamp=None,
             unban_reason=None,
             unban_mod=None,
-            is_upgrade=is_upgrade,
+            is_update=is_update,
         )
         await db.add(row)
         return row
@@ -201,9 +201,9 @@ async def deactivate(ban_id: int, unban_mod: int = None, unban_reason: str = Non
         return row
 
     @staticmethod
-    async def upgrade(ban_id: int, mod: int):
+    async def update(ban_id: int, mod: int):
         ban = await Ban.deactivate(ban_id, mod)
-        ban.upgraded = True
+        ban.updated = True
 
     @staticmethod
     async def edit(ban_id: int, mod: int, new_reason: str):
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index 150d54dff..a8fe96dd7 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -189,13 +189,13 @@ ulog:
       inf:
         id_off: ":no_entry: **Banned** permanently by {} because of `{}`{}"
         id_on: ":no_entry: **Banned** by {} for {} because of `{}`\n`(ID: {})`{}"
-    upgrade:
+    update:
       temp:
-        id_off: ":no_entry: **Ban upgraded** by {} to {} because of `{}`"
-        id_on: ":no_entry: **Banned** by {} for {} because of `{}`\n`(ID: {})`"
+        id_off: ":no_entry: **Ban updated** by {} to {} because of `{}`"
+        id_on: ":no_entry: **Ban updated** by {} to {} because of `{}`\n`(ID: {})`"
       inf:
-        id_off: ":no_entry: **Ban upgraded** to permanent by {} because of `{}`"
-        id_on: ":no_entry: **Banned** by {} for {} because of `{}`\n`(ID: {})`"
+        id_off: ":no_entry: **Ban updated** to permanent by {} because of `{}`"
+        id_on: ":no_entry: **Ban updated** to permanent by {} because of `{}`\n`(ID: {})`"
   unbanned:
     id_off: ":white_check_mark: **Unbanned** by {} because of `{}`"
     id_on: ":white_check_mark: **Unbanned** by {} because of `{}`\n`(ID: {})`"

From 478c50d995b096189e8206458a3af25c7daf6e3a Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Sun, 11 Jul 2021 23:12:08 +0200
Subject: [PATCH 022/120] Fixed possibility to use senseless time periods for
 mute/ban edits

---
 moderation/mod/cog.py | 24 ++++++++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index c84822f09..2e3deed10 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -755,15 +755,23 @@ async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time
         if not await compare_mod_level(ctx.author, ctx.guild.get_member(mute.mod)):
             raise CommandError(tg.permission_denied)
 
+        if mute.minutes == minutes or (mute.minutes == -1 and minutes is None):
+            raise CommandError(t.already_muted)
+
         conf_embed = Embed(
             title=t.confirmation,
             color=Colors.ModTools,
         )
 
+        if mute.minutes == -1:
+            old_mute_minutes = t.infinity
+        else:
+            old_mute_minutes = time_to_units(mute.minutes)
+
         if minutes is None:
-            conf_embed.description = t.confirm_mute_edit.duration(time_to_units(mute.minutes), t.infinity)
+            conf_embed.description = t.confirm_mute_edit.duration(old_mute_minutes, t.infinity)
         else:
-            conf_embed.description = t.confirm_mute_edit.duration(time_to_units(mute.minutes), time_to_units(minutes))
+            conf_embed.description = t.confirm_mute_edit.duration(old_mute_minutes, time_to_units(minutes))
 
         async with confirm(ctx, conf_embed) as (result, msg):
             if not result:
@@ -1148,15 +1156,23 @@ async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time:
         if not await compare_mod_level(ctx.author, ctx.guild.get_member(ban.mod)):
             raise CommandError(tg.permission_denied)
 
+        if ban.minutes == minutes or (ban.minutes == -1 and minutes is None):
+            raise CommandError(t.already_banned)
+
         conf_embed = Embed(
             title=t.confirmation,
             color=Colors.ModTools,
         )
 
+        if ban.minutes == -1:
+            old_ban_minutes = t.infinity
+        else:
+            old_ban_minutes = time_to_units(ban.minutes)
+
         if minutes is None:
-            conf_embed.description = t.confirm_ban_edit.duration(time_to_units(ban.minutes), t.infinity)
+            conf_embed.description = t.confirm_ban_edit.duration(old_ban_minutes, t.infinity)
         else:
-            conf_embed.description = t.confirm_ban_edit.duration(time_to_units(ban.minutes), time_to_units(minutes))
+            conf_embed.description = t.confirm_ban_edit.duration(old_ban_minutes, time_to_units(minutes))
 
         async with confirm(ctx, conf_embed) as (result, msg):
             if not result:

From d70eec7b487128057fcc35da4d0d2ed09aebd488 Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Mon, 12 Jul 2021 21:53:12 +0200
Subject: [PATCH 023/120] Added mod level to database for warns, mutes, kicks,
 bans

---
 moderation/mod/cog.py    | 130 +++++++++++++++++++++++++++++++--------
 moderation/mod/models.py |  31 +++++++---
 2 files changed, 126 insertions(+), 35 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 2e3deed10..431a53f3d 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -99,11 +99,13 @@ def show_evidence(evidence: Optional[str]) -> str:
     return ""
 
 
-async def compare_mod_level(mod1: Member, mod2: Member) -> bool:
-    lvl1 = await Config.PERMISSION_LEVELS.get_permission_level(mod1)
-    lvl2 = await Config.PERMISSION_LEVELS.get_permission_level(mod2)
+def get_mod_level(mod: Member):
+    lvl = await Config.PERMISSION_LEVELS.get_permission_level(mod)
+    return lvl.level
 
-    return lvl1.level > lvl2.level or mod1 == mod1.guild.owner
+
+async def compare_mod_level(mod: Member, mod_level: int) -> bool:
+    return get_mod_level(mod) > mod_level or mod == mod.guild.owner
 
 
 async def send_to_changelog_mod(
@@ -212,7 +214,7 @@ async def mod_loop(self):
 
     @log_auto_kick.subscribe
     async def handle_log_auto_kick(self, member: Member):
-        await Kick.create(member.id, str(member), None, None)
+        await Kick.create(member.id, str(member), None, None, None, None)
 
     @get_user_info_entries.subscribe
     async def handle_get_user_stats_entries(self, user_id: int) -> list[tuple[str, str]]:
@@ -521,7 +523,7 @@ async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         except (Forbidden, HTTPException):
             server_embed.description = t.no_dm + "\n\n" + server_embed.description
             server_embed.colour = Colors.error
-        await Warn.create(user.id, str(user), ctx.author.id, reason, evidence.url)
+        await Warn.create(user.id, str(user), ctx.author.id, get_mod_level(ctx.author), reason, evidence.url)
         await reply(ctx, embed=server_embed)
         await send_to_changelog_mod(ctx.guild, ctx.message, Colors.warn, t.log_warned, user, reason, evidence=evidence)
 
@@ -538,7 +540,7 @@ async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
         if warn is None:
             raise CommandError(t.no_warn)
 
-        if not await compare_mod_level(ctx.author, ctx.guild.get_member(warn.mod)):
+        if not await compare_mod_level(ctx.author, warn.mod_level):
             raise CommandError(tg.permission_denied)
 
         if len(reason) > 900:
@@ -559,7 +561,7 @@ async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
             if msg:
                 await msg.delete(delay=5)
 
-        await Warn.edit(warn_id, ctx.author.id, reason)
+        await Warn.edit(warn_id, ctx.author.id, get_mod_level(ctx.author), reason)
 
         user = self.bot.get_user(warn.member)
 
@@ -622,7 +624,15 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
         server_embed.set_author(name=str(user), icon_url=user.avatar_url)
 
         if minutes is not None:
-            await Mute.create(user.id, str(user), ctx.author.id, minutes, reason, evidence_url)
+            await Mute.create(
+                user.id,
+                str(user),
+                ctx.author.id,
+                get_mod_level(ctx.author),
+                minutes,
+                reason,
+                evidence_url,
+            )
             if evidence:
                 user_embed.description = t.muted.evidence(ctx.author.mention, ctx.guild.name, time_to_units(minutes),
                                                           reason, t.image_link(evidence.filename, evidence_url),
@@ -643,7 +653,15 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
                 evidence=evidence,
             )
         else:
-            await Mute.create(user.id, str(user), ctx.author.id, -1, reason, evidence_url)
+            await Mute.create(
+                user.id,
+                str(user),
+                ctx.author.id,
+                get_mod_level(ctx.author),
+                -1,
+                reason,
+                evidence_url,
+            )
             if evidence:
                 user_embed.description = t.muted_inf.evidence(ctx.author.mention, ctx.guild.name, reason,
                                                               t.image_link(evidence.filename, evidence_url),
@@ -692,7 +710,7 @@ async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
         if mute is None:
             raise CommandError(t.no_mute)
 
-        if not await compare_mod_level(ctx.author, ctx.guild.get_member(mute.mod)):
+        if not await compare_mod_level(ctx.author, mute.mod_level):
             raise CommandError(tg.permission_denied)
 
         if len(reason) > 900:
@@ -723,7 +741,7 @@ async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
         server_embed = Embed(title=t.mute, description=t.mute_edited_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.avatar_url)
 
-        await Mute.edit(mute_id, ctx.author.id, reason)
+        await Mute.edit(mute_id, ctx.author.id, get_mod_level(ctx.author), reason)
 
         try:
             await user.send(embed=user_embed)
@@ -752,7 +770,7 @@ async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time
 
         mute = sorted(active_mutes, key=lambda active_mute: active_mute.timestamp)[0]
 
-        if not await compare_mod_level(ctx.author, ctx.guild.get_member(mute.mod)):
+        if not await compare_mod_level(ctx.author, mute.mod_level):
             raise CommandError(tg.permission_denied)
 
         if mute.minutes == minutes or (mute.minutes == -1 and minutes is None):
@@ -793,7 +811,16 @@ async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time
         server_embed.set_author(name=str(user), icon_url=user.avatar_url)
 
         if minutes is not None:
-            await Mute.create(user.id, str(user), ctx.author.id, minutes, mute.reason, mute.evidence, True)
+            await Mute.create(
+                user.id,
+                str(user),
+                ctx.author.id,
+                get_mod_level(ctx.author),
+                minutes,
+                mute.reason,
+                mute.evidence,
+                True,
+            )
             user_embed.description = t.mute_edited.duration(time_to_units(mute.minutes), time_to_units(minutes))
             await send_to_changelog_mod(
                 ctx.guild,
@@ -806,7 +833,16 @@ async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time
             )
 
         else:
-            await Mute.create(user.id, str(user), ctx.author.id, -1, mute.reason, mute.evidence, True)
+            await Mute.create(
+                user.id,
+                str(user),
+                ctx.author.id,
+                get_mod_level(ctx.author),
+                -1,
+                mute.reason,
+                mute.evidence,
+                True,
+            )
             user_embed.description = t.mute_edited.duration(time_to_units(mute.minutes), t.infinity)
             await send_to_changelog_mod(
                 ctx.guild,
@@ -845,6 +881,9 @@ async def unmute(self, ctx: Context, user: UserMemberConverter, *, reason: str):
             await user.remove_roles(mute_role)
 
         async for mute in await db.stream(filter_by(Mute, active=True, member=user.id)):
+            if not await compare_mod_level(ctx.author, mute.mod_level):
+                raise CommandError(tg.permission_denied)
+
             await Mute.deactivate(mute.id, ctx.author.id, reason)
             was_muted = True
         if not was_muted:
@@ -882,7 +921,7 @@ async def kick(self, ctx: Context, member: Member, *, reason: str):
             evidence = None
             evidence_url = None
 
-        await Kick.create(member.id, str(member), ctx.author.id, reason, evidence_url)
+        await Kick.create(member.id, str(member), ctx.author.id, get_mod_level(ctx.author), reason, evidence_url)
         await send_to_changelog_mod(ctx.guild, ctx.message, Colors.kick, t.log_kicked, member, reason,
                                     evidence=evidence)
 
@@ -928,7 +967,7 @@ async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
         if kick is None:
             raise CommandError(t.no_kick)
 
-        if not await compare_mod_level(ctx.author, ctx.guild.get_member(kick.mod)):
+        if not await compare_mod_level(ctx.author, kick.mod_level):
             raise CommandError(tg.permission_denied)
 
         if len(reason) > 900:
@@ -949,7 +988,7 @@ async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
             if msg:
                 await msg.delete(delay=5)
 
-        await Kick.edit(kick_id, ctx.author.id, reason)
+        await Kick.edit(kick_id, ctx.author.id, get_mod_level(ctx.author), reason)
 
         user = self.bot.get_user(kick.member)
 
@@ -1021,7 +1060,16 @@ async def ban(
         server_embed.set_author(name=str(user), icon_url=user.avatar_url)
 
         if minutes is not None:
-            await Ban.create(user.id, str(user), ctx.author.id, minutes, reason, evidence_url, False)
+            await Ban.create(
+                user.id,
+                str(user),
+                ctx.author.id,
+                get_mod_level(ctx.author),
+                minutes,
+                reason,
+                evidence_url,
+                False,
+            )
             if evidence:
                 user_embed.description = t.banned.evidence(ctx.author.mention, ctx.guild.name, time_to_units(minutes),
                                                            reason, t.image_link(evidence.filename, evidence_url)
@@ -1041,7 +1089,16 @@ async def ban(
                 evidence=evidence,
             )
         else:
-            await Ban.create(user.id, str(user), ctx.author.id, -1, reason, evidence_url, False)
+            await Ban.create(
+                user.id,
+                str(user),
+                ctx.author.id,
+                get_mod_level(ctx.author),
+                -1,
+                reason,
+                evidence_url,
+                False,
+            )
             if evidence:
                 user_embed.description = t.banned.evidence(ctx.author.mention, ctx.guild.name, reason,
                                                            t.image_link(evidence.filename, evidence_url)
@@ -1093,7 +1150,7 @@ async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
         if ban is None:
             raise CommandError(t.no_ban)
 
-        if not await compare_mod_level(ctx.author, ctx.guild.get_member(ban.mod)):
+        if not await compare_mod_level(ctx.author, ban.mod_level):
             raise CommandError(tg.permission_denied)
 
         if len(reason) > 900:
@@ -1124,7 +1181,7 @@ async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
         server_embed = Embed(title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.avatar_url)
 
-        await Ban.edit(ban_id, ctx.author.id, reason)
+        await Ban.edit(ban_id, ctx.author.id, get_mod_level(ctx.author), reason)
 
         try:
             await user.send(embed=user_embed)
@@ -1153,7 +1210,7 @@ async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time:
 
         ban = sorted(active_bans, key=lambda active_ban: active_ban.timestamp)[0]
 
-        if not await compare_mod_level(ctx.author, ctx.guild.get_member(ban.mod)):
+        if not await compare_mod_level(ctx.author, ban.mod_level):
             raise CommandError(tg.permission_denied)
 
         if ban.minutes == minutes or (ban.minutes == -1 and minutes is None):
@@ -1194,7 +1251,16 @@ async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time:
         server_embed.set_author(name=str(user), icon_url=user.avatar_url)
 
         if minutes is not None:
-            await Ban.create(user.id, str(user), ctx.author.id, minutes, ban.reason, ban.evidence, True)
+            await Ban.create(
+                user.id,
+                str(user),
+                ctx.author.id,
+                get_mod_level(ctx.author),
+                minutes,
+                ban.reason,
+                ban.evidence,
+                True,
+            )
             user_embed.description = t.ban_edited.duration(time_to_units(ban.minutes), time_to_units(minutes))
             await send_to_changelog_mod(
                 ctx.guild,
@@ -1207,7 +1273,16 @@ async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time:
             )
 
         else:
-            await Ban.create(user.id, str(user), ctx.author.id, -1, ban.reason, ban.evidence, True)
+            await Ban.create(
+                user.id,
+                str(user),
+                ctx.author.id,
+                get_mod_level(ctx.author),
+                -1,
+                ban.reason,
+                ban.evidence,
+                True,
+            )
             user_embed.description = t.ban_edited.duration(time_to_units(ban.minutes), t.infinity)
             await send_to_changelog_mod(
                 ctx.guild,
@@ -1249,8 +1324,11 @@ async def unban(self, ctx: Context, user: UserMemberConverter, *, reason: str):
             was_banned = False
 
         async for ban in await db.stream(filter_by(Ban, active=True, member=user.id)):
-            was_banned = True
+            if not await compare_mod_level(ctx.author, ban.mod_level):
+                raise CommandError(tg.permission_denied)
+
             await Ban.deactivate(ban.id, ctx.author.id, reason)
+            was_banned = True
         if not was_banned:
             raise UserCommandError(user, t.not_banned)
 
diff --git a/moderation/mod/models.py b/moderation/mod/models.py
index 360f2ca0e..973c45ee0 100644
--- a/moderation/mod/models.py
+++ b/moderation/mod/models.py
@@ -40,15 +40,18 @@ class Warn(db.Base):
     member: Union[Column, int] = Column(BigInteger)
     member_name: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
     mod: Union[Column, int] = Column(BigInteger)
+    mod_level: Union[Column, int] = Column(Integer)
     timestamp: Union[Column, datetime] = Column(DateTime)
     reason: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
     evidence: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
 
     @staticmethod
-    async def create(member: int, member_name: str, mod: int, reason: str, evidence: Optional[str]) -> Warn:
+    async def create(member: int, member_name: str, mod: int, mod_level: int, reason: str,
+                     evidence: Optional[str]) -> Warn:
         row = Warn(member=member,
                    member_name=member_name,
                    mod=mod,
+                   mod_level=mod_level,
                    timestamp=datetime.utcnow(),
                    reason=reason,
                    evidence=evidence,
@@ -57,9 +60,10 @@ async def create(member: int, member_name: str, mod: int, reason: str, evidence:
         return row
 
     @staticmethod
-    async def edit(warn_id: int, mod: int, new_reason: str):
+    async def edit(warn_id: int, mod: int, mod_level: int, new_reason: str):
         row = await db.get(Warn, id=warn_id)
         row.mod = mod
+        row.mod_level = mod_level
         row.reason = new_reason
 
 
@@ -70,6 +74,7 @@ class Mute(db.Base):
     member: Union[Column, int] = Column(BigInteger)
     member_name: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
     mod: Union[Column, int] = Column(BigInteger)
+    mod_level: Union[Column, int] = Column(Integer)
     timestamp: Union[Column, datetime] = Column(DateTime)
     minutes: Union[Column, int] = Column(Integer)
     reason: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
@@ -82,12 +87,13 @@ class Mute(db.Base):
     is_update: Union[Column, bool] = Column(Boolean)
 
     @staticmethod
-    async def create(member: int, member_name: str, mod: int, minutes: int, reason: str,
+    async def create(member: int, member_name: str, mod: int, mod_level: int, minutes: int, reason: str,
                      evidence: Optional[str], is_update: bool = False) -> Mute:
         row = Mute(
             member=member,
             member_name=member_name,
             mod=mod,
+            mod_level=mod_level,
             timestamp=datetime.utcnow(),
             minutes=minutes,
             reason=reason,
@@ -116,9 +122,10 @@ async def update(ban_id: int, mod: int):
         mute.updated = True
 
     @staticmethod
-    async def edit(mute_id: int, mod: int, new_reason: str):
+    async def edit(mute_id: int, mod: int, mod_level: int, new_reason: str):
         row = await db.get(Mute, id=mute_id)
         row.mod = mod
+        row.mod_level = mod_level
         row.reason = new_reason
 
 
@@ -129,16 +136,18 @@ class Kick(db.Base):
     member: Union[Column, int] = Column(BigInteger)
     member_name: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
     mod: Union[Column, int] = Column(BigInteger)
+    mod_level: Union[Column, int] = Column(Integer)
     timestamp: Union[Column, datetime] = Column(DateTime)
     reason: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
     evidence: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
 
     @staticmethod
-    async def create(member: int, member_name: str, mod: Optional[int], reason: Optional[str],
-                     evidence: Optional[str]) -> Kick:
+    async def create(member: int, member_name: str, mod: Optional[int], mod_level: Optional[int],
+                     reason: Optional[str], evidence: Optional[str]) -> Kick:
         row = Kick(member=member,
                    member_name=member_name,
                    mod=mod,
+                   mod_level=mod_level,
                    timestamp=datetime.utcnow(),
                    reason=reason,
                    evidence=evidence,
@@ -147,9 +156,10 @@ async def create(member: int, member_name: str, mod: Optional[int], reason: Opti
         return row
 
     @staticmethod
-    async def edit(kick_id: int, mod: int, new_reason: str):
+    async def edit(kick_id: int, mod: int, mod_level: int, new_reason: str):
         row = await db.get(Kick, id=kick_id)
         row.mod = mod
+        row.mod_level = mod_level
         row.reason = new_reason
 
 
@@ -160,6 +170,7 @@ class Ban(db.Base):
     member: Union[Column, int] = Column(BigInteger)
     member_name: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
     mod: Union[Column, int] = Column(BigInteger)
+    mod_level: Union[Column, int] = Column(Integer)
     timestamp: Union[Column, datetime] = Column(DateTime)
     minutes: Union[Column, int] = Column(Integer)
     reason: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
@@ -172,12 +183,13 @@ class Ban(db.Base):
     is_update: Union[Column, bool] = Column(Boolean)
 
     @staticmethod
-    async def create(member: int, member_name: str, mod: int, minutes: int, reason: str,
+    async def create(member: int, member_name: str, mod: int, mod_level: int, minutes: int, reason: str,
                      evidence: Optional[str], is_update: bool = False) -> Ban:
         row = Ban(
             member=member,
             member_name=member_name,
             mod=mod,
+            mod_level=mod_level,
             timestamp=datetime.utcnow(),
             minutes=minutes,
             reason=reason,
@@ -206,7 +218,8 @@ async def update(ban_id: int, mod: int):
         ban.updated = True
 
     @staticmethod
-    async def edit(ban_id: int, mod: int, new_reason: str):
+    async def edit(ban_id: int, mod: int, mod_level: int, new_reason: str):
         row = await db.get(Ban, id=ban_id)
         row.mod = mod
+        row.mod_level = mod_level
         row.reason = new_reason

From becc4e093b0931ade0ffe41cb17119dbd88705b9 Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Sat, 17 Jul 2021 11:25:04 +0200
Subject: [PATCH 024/120] Added setting for whether to send a user a concerning
 delete message

---
 moderation/mod/cog.py              | 46 +++++++++++++++++++-----------
 moderation/mod/permissions.py      |  1 +
 moderation/mod/settings.py         |  5 ++++
 moderation/mod/translations/en.yml | 14 ++++++++-
 4 files changed, 49 insertions(+), 17 deletions(-)
 create mode 100644 moderation/mod/settings.py

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 431a53f3d..a0eb3980d 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -25,6 +25,7 @@
 from .colors import Colors
 from .models import Mute, Ban, Report, Warn, Kick
 from .permissions import ModPermission
+from .settings import ModSettings
 from ...contributor import Contributor
 from ...pubsub import (
     send_to_changelog,
@@ -99,13 +100,13 @@ def show_evidence(evidence: Optional[str]) -> str:
     return ""
 
 
-def get_mod_level(mod: Member):
+async def get_mod_level(mod: Member):
     lvl = await Config.PERMISSION_LEVELS.get_permission_level(mod)
     return lvl.level
 
 
 async def compare_mod_level(mod: Member, mod_level: int) -> bool:
-    return get_mod_level(mod) > mod_level or mod == mod.guild.owner
+    return await get_mod_level(mod) > mod_level or mod == mod.guild.owner
 
 
 async def send_to_changelog_mod(
@@ -452,6 +453,19 @@ async def on_member_join(self, member: Member):
         if await db.exists(filter_by(Mute, active=True, member=member.id)):
             await member.add_roles(mute_role)
 
+    @commands.command()
+    @ModPermission.modtools_write.check
+    async def send_delete_message(self, ctx: Context, send: bool):
+        """
+        configure whether to send a warn/mute/kick/ban delete message to the concerned user
+        """
+
+        await ModSettings.send_delete_user_message.set(send)
+        embed = Embed(title=t.modtools, description=t.configured_send_delete_message[send], color=Colors.ModTools)
+        await reply(ctx, embed=embed)
+
+        await send_to_changelog(ctx.guild, t.configured_send_delete_message[send])
+
     @commands.command()
     async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         """
@@ -523,7 +537,7 @@ async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         except (Forbidden, HTTPException):
             server_embed.description = t.no_dm + "\n\n" + server_embed.description
             server_embed.colour = Colors.error
-        await Warn.create(user.id, str(user), ctx.author.id, get_mod_level(ctx.author), reason, evidence.url)
+        await Warn.create(user.id, str(user), ctx.author.id, await get_mod_level(ctx.author), reason, evidence.url)
         await reply(ctx, embed=server_embed)
         await send_to_changelog_mod(ctx.guild, ctx.message, Colors.warn, t.log_warned, user, reason, evidence=evidence)
 
@@ -561,7 +575,7 @@ async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
             if msg:
                 await msg.delete(delay=5)
 
-        await Warn.edit(warn_id, ctx.author.id, get_mod_level(ctx.author), reason)
+        await Warn.edit(warn_id, ctx.author.id, await get_mod_level(ctx.author), reason)
 
         user = self.bot.get_user(warn.member)
 
@@ -628,7 +642,7 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
                 user.id,
                 str(user),
                 ctx.author.id,
-                get_mod_level(ctx.author),
+                await get_mod_level(ctx.author),
                 minutes,
                 reason,
                 evidence_url,
@@ -657,7 +671,7 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
                 user.id,
                 str(user),
                 ctx.author.id,
-                get_mod_level(ctx.author),
+                await get_mod_level(ctx.author),
                 -1,
                 reason,
                 evidence_url,
@@ -741,7 +755,7 @@ async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
         server_embed = Embed(title=t.mute, description=t.mute_edited_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.avatar_url)
 
-        await Mute.edit(mute_id, ctx.author.id, get_mod_level(ctx.author), reason)
+        await Mute.edit(mute_id, ctx.author.id, await get_mod_level(ctx.author), reason)
 
         try:
             await user.send(embed=user_embed)
@@ -815,7 +829,7 @@ async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time
                 user.id,
                 str(user),
                 ctx.author.id,
-                get_mod_level(ctx.author),
+                await get_mod_level(ctx.author),
                 minutes,
                 mute.reason,
                 mute.evidence,
@@ -837,7 +851,7 @@ async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time
                 user.id,
                 str(user),
                 ctx.author.id,
-                get_mod_level(ctx.author),
+                await get_mod_level(ctx.author),
                 -1,
                 mute.reason,
                 mute.evidence,
@@ -921,7 +935,7 @@ async def kick(self, ctx: Context, member: Member, *, reason: str):
             evidence = None
             evidence_url = None
 
-        await Kick.create(member.id, str(member), ctx.author.id, get_mod_level(ctx.author), reason, evidence_url)
+        await Kick.create(member.id, str(member), ctx.author.id, await get_mod_level(ctx.author), reason, evidence_url)
         await send_to_changelog_mod(ctx.guild, ctx.message, Colors.kick, t.log_kicked, member, reason,
                                     evidence=evidence)
 
@@ -988,7 +1002,7 @@ async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
             if msg:
                 await msg.delete(delay=5)
 
-        await Kick.edit(kick_id, ctx.author.id, get_mod_level(ctx.author), reason)
+        await Kick.edit(kick_id, ctx.author.id, await get_mod_level(ctx.author), reason)
 
         user = self.bot.get_user(kick.member)
 
@@ -1064,7 +1078,7 @@ async def ban(
                 user.id,
                 str(user),
                 ctx.author.id,
-                get_mod_level(ctx.author),
+                await get_mod_level(ctx.author),
                 minutes,
                 reason,
                 evidence_url,
@@ -1093,7 +1107,7 @@ async def ban(
                 user.id,
                 str(user),
                 ctx.author.id,
-                get_mod_level(ctx.author),
+                await get_mod_level(ctx.author),
                 -1,
                 reason,
                 evidence_url,
@@ -1181,7 +1195,7 @@ async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
         server_embed = Embed(title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.avatar_url)
 
-        await Ban.edit(ban_id, ctx.author.id, get_mod_level(ctx.author), reason)
+        await Ban.edit(ban_id, ctx.author.id, await get_mod_level(ctx.author), reason)
 
         try:
             await user.send(embed=user_embed)
@@ -1255,7 +1269,7 @@ async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time:
                 user.id,
                 str(user),
                 ctx.author.id,
-                get_mod_level(ctx.author),
+                await get_mod_level(ctx.author),
                 minutes,
                 ban.reason,
                 ban.evidence,
@@ -1277,7 +1291,7 @@ async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time:
                 user.id,
                 str(user),
                 ctx.author.id,
-                get_mod_level(ctx.author),
+                await get_mod_level(ctx.author),
                 -1,
                 ban.reason,
                 ban.evidence,
diff --git a/moderation/mod/permissions.py b/moderation/mod/permissions.py
index 06c8ebf38..5043d75b4 100644
--- a/moderation/mod/permissions.py
+++ b/moderation/mod/permissions.py
@@ -13,3 +13,4 @@ def description(self) -> str:
     mute = auto()
     kick = auto()
     ban = auto()
+    modtools_write = auto()
diff --git a/moderation/mod/settings.py b/moderation/mod/settings.py
new file mode 100644
index 000000000..2ac739ba0
--- /dev/null
+++ b/moderation/mod/settings.py
@@ -0,0 +1,5 @@
+from PyDrocsid.settings import Settings
+
+
+class ModSettings(Settings):
+    send_delete_user_message = True
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index a8fe96dd7..452d6cc77 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -3,6 +3,7 @@ permissions:
   mute: mute a user
   kick: kick a user
   ban: ban a user
+  modtools_write: write mod tools configuration
 
 times:
   years:
@@ -30,7 +31,10 @@ log_field:
   infinity: "*Permanent*"
   evidence: ":file_cabinet: Evidence image"
 
-
+modtools: Mod tools
+configured_send_delete_message:
+  off: "Sending a message to a user after a warn/mute/kick/ban concerning him has been set to `off`"
+  on: "Sending a message to a user after a warn/mute/kick/ban concerning him has been set to `on`"
 jump_url: "{} [[Jump]]({})"
 image_link: "{} [[Go to image]]({})"
 no_dm: ":warning: User does not allow direct messages."
@@ -41,12 +45,14 @@ edit_canceled: ":x: Edit canceled"
 edit_confirmed: ":white_check_mark: Edit confirmed"
 infinity: Permanent
 
+# reports
 report: ":speech_balloon: Report"
 cannot_report: This member cannot be reported.
 no_self_report: You cannot report yourself.
 reported_response: "User reported successfully :white_check_mark:"
 log_reported: ":speech_balloon: Member reported"
 
+# warns
 warn: ":warning: Warn"
 cannot_warn: This member cannot be warned.
 warned:
@@ -59,7 +65,9 @@ confirm_warn_edit: "Are you sure you want to change this warns reason from ```\n
 warn_edited: "The warn reason has been changed from ```\n{}\n```to```\n{}\n```"
 warn_edited_response: ":white_check_mark: The warn reason has been edited"
 log_warn_edited: ":warning: Warn edited"
+confirm_warn_delete: "Are you sure you want to delete this warning for *{}*?\n`(ID: {})`"
 
+# mutes
 mute: ":mute: Mute"
 unmute: ":loud_sound: Mute"
 mute_role_not_set: User could not be muted because no mute role is configured.
@@ -87,6 +95,7 @@ mute_edited:
 mute_edited_response: ":white_check_mark: The mute reason has been edited"
 log_mute_edited: ":mute: Mute edited"
 
+# kicks
 kick: ":x: Kick"
 kicked:
   evidence: "{} just kicked you from {}:```\n{}\n```Evidence: {}"
@@ -101,6 +110,7 @@ kick_edited: "The kick reason has been changed from ```\n{}\n```to```\n{}\n```"
 kick_edited_reponse: ":white_check_mark: The kick reason has been edited"
 log_kick_edited: ":x: Kick edited"
 
+# bans
 ban: ":no_entry: Ban"
 unban: ":white_check_mark: Ban"
 cannot_ban: This member cannot be banned.
@@ -139,6 +149,7 @@ autokicks:
   one: "(plus `{cnt}` autokick)"
   many: "(plus `{cnt}` autokicks)"
 
+# user stats
 active_sanctions: Active Punishments
 none: None
 status_banned: ":no_entry: User is banned from this server."
@@ -146,6 +157,7 @@ status_banned_time: ":no_entry: User is banned for {} from this server ({} left)
 status_muted: ":mute: User is muted on this server."
 status_muted_time: ":mute: User is muted for {} on this server ({} left)."
 
+# user log
 ulog:
   evidence: "\n[[Evidence]]({})"
 

From 288fb8ad3e2bb71d47ccec5b1712f43fe5dda1a1 Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Sat, 17 Jul 2021 12:15:11 +0200
Subject: [PATCH 025/120] Added a function to delete warns

---
 moderation/mod/cog.py              | 54 +++++++++++++++++++++++++++++-
 moderation/mod/models.py           |  5 +++
 moderation/mod/translations/en.yml |  3 ++
 3 files changed, 61 insertions(+), 1 deletion(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index a0eb3980d..05eb3c280 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -463,7 +463,6 @@ async def send_delete_message(self, ctx: Context, send: bool):
         await ModSettings.send_delete_user_message.set(send)
         embed = Embed(title=t.modtools, description=t.configured_send_delete_message[send], color=Colors.ModTools)
         await reply(ctx, embed=embed)
-
         await send_to_changelog(ctx.guild, t.configured_send_delete_message[send])
 
     @commands.command()
@@ -595,6 +594,59 @@ async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
         await reply(ctx, embed=server_embed)
         await send_to_changelog_mod(ctx.guild, ctx.message, Colors.warn, t.log_warn_edited, user, reason)
 
+    @commands.command()
+    @ModPermission.warn.check
+    @guild_only()
+    async def delete_warn(self, ctx: Context, warn_id: int):
+        """
+        delete a warn
+        get the warn id from the users user log
+         """
+
+        warn = await db.get(Warn, id=warn_id)
+        if warn is None:
+            raise CommandError(t.no_warn)
+
+        if not await compare_mod_level(ctx.author, warn.mod_level):
+            raise CommandError(tg.permission_denied)
+
+        conf_embed = Embed(
+            title=t.confirmation,
+            description=t.confirm_warn_delete(warn.member_name, warn.id),
+            color=Colors.ModTools
+        )
+
+        async with confirm(ctx, conf_embed) as (result, msg):
+            if not result:
+                conf_embed.description += "\n\n" + t.edit_canceled
+                return
+
+            conf_embed.description += "\n\n" + t.edit_confirmed
+            if msg:
+                await msg.delete(delay=5)
+
+        await Warn.delete(warn_id)
+
+        user = self.bot.get_user(warn.member)
+        server_embed = Embed(title=t.warn, description=t.warn_deleted_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.avatar_url)
+
+        if await ModSettings.send_delete_user_message.get():
+            user_embed = Embed(
+                title=t.warn,
+                description=t.warn_deleted(warn.reason),
+                colour=Colors.ModTools,
+            )
+
+            try:
+                await user.send(embed=user_embed)
+            except (Forbidden, HTTPException):
+                server_embed.description = t.no_dm + "\n\n" + server_embed.description
+                server_embed.colour = Colors.error
+
+        await reply(ctx, embed=server_embed)
+        await send_to_changelog_mod(ctx.guild, ctx.message, Colors.warn, t.log_warn_deleted, user, warn.reason)
+
     @commands.command()
     @ModPermission.mute.check
     @guild_only()
diff --git a/moderation/mod/models.py b/moderation/mod/models.py
index 973c45ee0..65c292c1e 100644
--- a/moderation/mod/models.py
+++ b/moderation/mod/models.py
@@ -66,6 +66,11 @@ async def edit(warn_id: int, mod: int, mod_level: int, new_reason: str):
         row.mod_level = mod_level
         row.reason = new_reason
 
+    @staticmethod
+    async def delete(warn_id: int):
+        row = await db.get(Warn, id=warn_id)
+        await db.delete(row)
+
 
 class Mute(db.Base):
     __tablename__ = "mute"
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index 452d6cc77..6011a8d21 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -66,6 +66,9 @@ warn_edited: "The warn reason has been changed from ```\n{}\n```to```\n{}\n```"
 warn_edited_response: ":white_check_mark: The warn reason has been edited"
 log_warn_edited: ":warning: Warn edited"
 confirm_warn_delete: "Are you sure you want to delete this warning for *{}*?\n`(ID: {})`"
+warn_deleted: "Your warn with the reason ```\n{}\n``` has been deleted"
+warn_deleted_response: ":white_check_mark: The warn has been deleted"
+log_warn_deleted: ":warning: Warn deleted"
 
 # mutes
 mute: ":mute: Mute"

From abad9adc470746238790c522e943886f22801ef5 Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Sat, 17 Jul 2021 12:41:45 +0200
Subject: [PATCH 026/120] Added a function to delete mutes

---
 moderation/mod/cog.py              | 86 ++++++++++++++++++++++++++++++
 moderation/mod/models.py           |  5 ++
 moderation/mod/translations/en.yml |  6 +++
 3 files changed, 97 insertions(+)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 05eb3c280..9aa1dbd6a 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -926,6 +926,92 @@ async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time
             server_embed.colour = Colors.error
         await reply(ctx, embed=server_embed)
 
+    @commands.command()
+    @ModPermission.mute.check
+    @guild_only()
+    async def delete_mute(self, ctx: Context, mute_id: int):
+        """
+        delete a warn
+        get the warn id from the users user log
+         """
+
+        mute = await db.get(Mute, id=mute_id)
+        if mute is None:
+            raise CommandError(t.no_mute)
+
+        if not await compare_mod_level(ctx.author, mute.mod_level):
+            raise CommandError(tg.permission_denied)
+
+        conf_embed = Embed(
+            title=t.confirmation,
+            description=t.confirm_mute_delete(mute.member_name, mute.id),
+            color=Colors.ModTools
+        )
+
+        async with confirm(ctx, conf_embed) as (result, msg):
+            if not result:
+                conf_embed.description += "\n\n" + t.edit_canceled
+                return
+
+            conf_embed.description += "\n\n" + t.edit_confirmed
+            if msg:
+                await msg.delete(delay=5)
+
+        active_mutes: List[Mute] = await db.all(filter_by(Mute, active=True, member=mute.member))
+
+        if len(active_mutes) == 1 and mute in active_mutes:
+            user = ctx.guild.get_member(mute.member)
+            if user is not None:
+                if (mute_role := get_mute_role(ctx.guild)) in user.roles:
+                    await user.remove_roles(mute_role)
+
+        user = self.bot.get_user(mute.member)
+
+        await Mute.delete(mute_id)
+
+        server_embed = Embed(title=t.mute, description=t.mute_deleted_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.avatar_url)
+
+        if await ModSettings.send_delete_user_message.get():
+            user_embed = Embed(
+                title=t.warn,
+                colour=Colors.ModTools,
+            )
+
+            if mute.minutes == -1:
+                user_embed.description = t.mute_deleted.inf(mute.reason)
+            else:
+                user_embed.description = t.mute_deleted.not_inf(time_to_units(mute.minutes), mute.reason)
+
+            try:
+                await user.send(embed=user_embed)
+            except (Forbidden, HTTPException):
+                server_embed.description = t.no_dm + "\n\n" + server_embed.description
+                server_embed.colour = Colors.error
+
+        await reply(ctx, embed=server_embed)
+
+        if mute.minutes == -1:
+            await send_to_changelog_mod(
+                ctx.guild,
+                ctx.message,
+                Colors.mute,
+                t.log_mute_deleted,
+                user,
+                mute.reason,
+                duration=t.log_field_infinity,
+            )
+        else:
+            await send_to_changelog_mod(
+                ctx.guild,
+                ctx.message,
+                Colors.mute,
+                t.log_mute_deleted,
+                user,
+                mute.reason,
+                duration=time_to_units(mute.minutes),
+            )
+
     @commands.command()
     @ModPermission.mute.check
     @guild_only()
diff --git a/moderation/mod/models.py b/moderation/mod/models.py
index 65c292c1e..7dafebd46 100644
--- a/moderation/mod/models.py
+++ b/moderation/mod/models.py
@@ -133,6 +133,11 @@ async def edit(mute_id: int, mod: int, mod_level: int, new_reason: str):
         row.mod_level = mod_level
         row.reason = new_reason
 
+    @staticmethod
+    async def delete(mute_id: int):
+        row = await db.get(Mute, id=mute_id)
+        await db.delete(row)
+
 
 class Kick(db.Base):
     __tablename__ = "kick"
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index 6011a8d21..cc5b75458 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -97,6 +97,12 @@ mute_edited:
   duration: "The mute duration has been changed from ```\n{}\n```to```\n{}\n```"
 mute_edited_response: ":white_check_mark: The mute reason has been edited"
 log_mute_edited: ":mute: Mute edited"
+confirm_mute_delete: "Are you sure you want to delete this mute for *{}*?\n`(ID: {})`"
+mute_deleted:
+  inf: "Your mute with the reason ```\n{}\n``` has been deleted"
+  not_inf: "Your mute for {} with the reason ```\n{}\n``` has been deleted"
+mute_deleted_response: ":white_check_mark: The mute has been deleted"
+log_mute_deleted: ":loud_sound: Mute deleted"
 
 # kicks
 kick: ":x: Kick"

From ebbe3807bf6e9b2f10bd2225e6f313d7af0790a7 Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Sun, 18 Jul 2021 12:06:13 +0200
Subject: [PATCH 027/120] Added a function to delete kicks

---
 moderation/mod/cog.py              | 53 ++++++++++++++++++++++++++++++
 moderation/mod/models.py           |  5 +++
 moderation/mod/translations/en.yml |  4 +++
 3 files changed, 62 insertions(+)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 9aa1dbd6a..772496ae7 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -1160,6 +1160,59 @@ async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
         await reply(ctx, embed=server_embed)
         await send_to_changelog_mod(ctx.guild, ctx.message, Colors.kick, t.log_kick_edited, user, reason)
 
+    @commands.command()
+    @ModPermission.kick.check
+    @guild_only()
+    async def delete_kick(self, ctx: Context, kick_id: int):
+        """
+        delete a warn
+        get the warn id from the users user log
+         """
+
+        kick = await db.get(Kick, id=kick_id)
+        if kick is None:
+            raise CommandError(t.no_kick)
+
+        if not await compare_mod_level(ctx.author, kick.mod_level):
+            raise CommandError(tg.permission_denied)
+
+        conf_embed = Embed(
+            title=t.confirmation,
+            description=t.confirm_kick_delete(kick.member_name, kick.id),
+            color=Colors.ModTools
+        )
+
+        async with confirm(ctx, conf_embed) as (result, msg):
+            if not result:
+                conf_embed.description += "\n\n" + t.edit_canceled
+                return
+
+            conf_embed.description += "\n\n" + t.edit_confirmed
+            if msg:
+                await msg.delete(delay=5)
+
+        await Kick.delete(kick_id)
+
+        user = self.bot.get_user(kick.member)
+        server_embed = Embed(title=t.warn, description=t.kick_deleted_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.avatar_url)
+
+        if await ModSettings.send_delete_user_message.get():
+            user_embed = Embed(
+                title=t.kick,
+                description=t.kick_deleted(kick.reason),
+                colour=Colors.ModTools,
+            )
+
+            try:
+                await user.send(embed=user_embed)
+            except (Forbidden, HTTPException):
+                server_embed.description = t.no_dm + "\n\n" + server_embed.description
+                server_embed.colour = Colors.error
+
+        await reply(ctx, embed=server_embed)
+        await send_to_changelog_mod(ctx.guild, ctx.message, Colors.kick, t.log_kick_deleted, user, kick.reason)
+
     @commands.command()
     @ModPermission.ban.check
     @guild_only()
diff --git a/moderation/mod/models.py b/moderation/mod/models.py
index 7dafebd46..eb15e56af 100644
--- a/moderation/mod/models.py
+++ b/moderation/mod/models.py
@@ -172,6 +172,11 @@ async def edit(kick_id: int, mod: int, mod_level: int, new_reason: str):
         row.mod_level = mod_level
         row.reason = new_reason
 
+    @staticmethod
+    async def delete(kick_id: int):
+        row = await db.get(Kick, id=kick_id)
+        await db.delete(row)
+
 
 class Ban(db.Base):
     __tablename__ = "ban"
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index cc5b75458..a0afb14ca 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -118,6 +118,10 @@ confirm_kick_edit: "Are you sure you want to change this kicks reason from ```\n
 kick_edited: "The kick reason has been changed from ```\n{}\n```to```\n{}\n```"
 kick_edited_reponse: ":white_check_mark: The kick reason has been edited"
 log_kick_edited: ":x: Kick edited"
+confirm_kick_delete: "Are you sure you want to delete this kick of *{}*?\n`(ID: {})`"
+kick_deleted: "Your kick with the reason ```\n{}\n``` has been deleted"
+kick_deleted_response: ":white_check_mark: The kick has been deleted"
+log_kick_deleted: ":x: Kick deleted"
 
 # bans
 ban: ":no_entry: Ban"

From 70dea0cb94286a34b4fa6da7b35da43a4c7884f2 Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Sun, 18 Jul 2021 12:21:34 +0200
Subject: [PATCH 028/120] Added a function to delete bans

---
 moderation/mod/cog.py              | 96 ++++++++++++++++++++++++++++--
 moderation/mod/models.py           |  5 ++
 moderation/mod/translations/en.yml |  6 ++
 3 files changed, 103 insertions(+), 4 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 772496ae7..483914ec3 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -931,8 +931,8 @@ async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time
     @guild_only()
     async def delete_mute(self, ctx: Context, mute_id: int):
         """
-        delete a warn
-        get the warn id from the users user log
+        delete a mute
+        get the mute id from the users user log
          """
 
         mute = await db.get(Mute, id=mute_id)
@@ -1165,8 +1165,8 @@ async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
     @guild_only()
     async def delete_kick(self, ctx: Context, kick_id: int):
         """
-        delete a warn
-        get the warn id from the users user log
+        delete a kick
+        get the kick id from the users user log
          """
 
         kick = await db.get(Kick, id=kick_id)
@@ -1506,6 +1506,94 @@ async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time:
             server_embed.colour = Colors.error
         await reply(ctx, embed=server_embed)
 
+    @commands.command()
+    @ModPermission.ban.check
+    @guild_only()
+    async def delete_ban(self, ctx: Context, ban_id: int):
+        """
+        delete a ban
+        get the ban id from the users user log
+         """
+
+        ban = await db.get(Ban, id=ban_id)
+        if ban is None:
+            raise CommandError(t.no_ban)
+
+        if not await compare_mod_level(ctx.author, ban.mod_level):
+            raise CommandError(tg.permission_denied)
+
+        conf_embed = Embed(
+            title=t.confirmation,
+            description=t.confirm_ban_delete(ban.member_name, ban.id),
+            color=Colors.ModTools
+        )
+
+        async with confirm(ctx, conf_embed) as (result, msg):
+            if not result:
+                conf_embed.description += "\n\n" + t.edit_canceled
+                return
+
+            conf_embed.description += "\n\n" + t.edit_confirmed
+            if msg:
+                await msg.delete(delay=5)
+
+        active_bans: List[Ban] = await db.all(filter_by(Ban, active=True, member=ban.member))
+
+        if len(active_bans) == 1 and ban in active_bans:
+            user = ctx.guild.get_member(ban.member)
+            if user is not None:
+                try:
+                    await ctx.guild.unban(user, reason="Ban deleted")
+                except HTTPException:
+                    pass
+
+        user = self.bot.get_user(ban.member)
+
+        await Ban.delete(ban_id)
+
+        server_embed = Embed(title=t.mute, description=t.ban_deleted_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.avatar_url)
+
+        if await ModSettings.send_delete_user_message.get():
+            user_embed = Embed(
+                title=t.ban,
+                colour=Colors.ModTools,
+            )
+
+            if ban.minutes == -1:
+                user_embed.description = t.ban_deleted.inf(ban.reason)
+            else:
+                user_embed.description = t.ban_deleted.not_inf(time_to_units(ban.minutes), ban.reason)
+
+            try:
+                await user.send(embed=user_embed)
+            except (Forbidden, HTTPException):
+                server_embed.description = t.no_dm + "\n\n" + server_embed.description
+                server_embed.colour = Colors.error
+
+        await reply(ctx, embed=server_embed)
+
+        if ban.minutes == -1:
+            await send_to_changelog_mod(
+                ctx.guild,
+                ctx.message,
+                Colors.ban,
+                t.log_ban_deleted,
+                user,
+                ban.reason,
+                duration=t.log_field_infinity,
+            )
+        else:
+            await send_to_changelog_mod(
+                ctx.guild,
+                ctx.message,
+                Colors.ban,
+                t.log_ban_deleted,
+                user,
+                ban.reason,
+                duration=time_to_units(ban.minutes),
+            )
+
     @commands.command()
     @ModPermission.ban.check
     @guild_only()
diff --git a/moderation/mod/models.py b/moderation/mod/models.py
index eb15e56af..26b0da50e 100644
--- a/moderation/mod/models.py
+++ b/moderation/mod/models.py
@@ -238,3 +238,8 @@ async def edit(ban_id: int, mod: int, mod_level: int, new_reason: str):
         row.mod = mod
         row.mod_level = mod_level
         row.reason = new_reason
+
+    @staticmethod
+    async def delete(ban_id: int):
+        row = await db.get(Ban, id=ban_id)
+        await db.delete(row)
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index a0afb14ca..f662129a7 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -151,6 +151,12 @@ ban_edited:
   duration: "The ban duration has been changed from ```\n{}\n```to```\n{}\n```"
 ban_edited_response: ":white_check_mark: The ban reason has been edited"
 log_ban_edited: ":no_entry: Ban edited"
+confirm_ban_delete: "Are you sure you want to delete this ban of *{}*?\n`(ID: {})`"
+ban_deleted:
+  inf: "Your ban with the reason ```\n{}\n``` has been deleted"
+  not_inf: "Your ban for {} with the reason ```\n{}\n``` has been deleted"
+ban_deleted_response: ":white_check_mark: The ban has been deleted"
+log_ban_deleted: ":white_check_mark: Ban deleted"
 
 reported_cnt: ":speech_balloon:  Reported"
 warned_cnt: ":warning:  Warned"

From 875d0c12ea58c7bed77865fa585599f2f9eea690 Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Sun, 18 Jul 2021 12:26:57 +0200
Subject: [PATCH 029/120] Fixed not comparing whether the original
 warn/mute/kick/ban creator is the editor/deleter

---
 moderation/mod/cog.py | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 483914ec3..0470231e8 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -553,7 +553,7 @@ async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
         if warn is None:
             raise CommandError(t.no_warn)
 
-        if not await compare_mod_level(ctx.author, warn.mod_level):
+        if not await compare_mod_level(ctx.author, warn.mod_level) or not ctx.author.id == warn.mod:
             raise CommandError(tg.permission_denied)
 
         if len(reason) > 900:
@@ -607,7 +607,7 @@ async def delete_warn(self, ctx: Context, warn_id: int):
         if warn is None:
             raise CommandError(t.no_warn)
 
-        if not await compare_mod_level(ctx.author, warn.mod_level):
+        if not await compare_mod_level(ctx.author, warn.mod_level) or not ctx.author.id == warn.mod:
             raise CommandError(tg.permission_denied)
 
         conf_embed = Embed(
@@ -776,7 +776,7 @@ async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
         if mute is None:
             raise CommandError(t.no_mute)
 
-        if not await compare_mod_level(ctx.author, mute.mod_level):
+        if not await compare_mod_level(ctx.author, mute.mod_level) or not ctx.author.id == mute.mod:
             raise CommandError(tg.permission_denied)
 
         if len(reason) > 900:
@@ -836,7 +836,7 @@ async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time
 
         mute = sorted(active_mutes, key=lambda active_mute: active_mute.timestamp)[0]
 
-        if not await compare_mod_level(ctx.author, mute.mod_level):
+        if not await compare_mod_level(ctx.author, mute.mod_level) or not ctx.author.id == mute.mod:
             raise CommandError(tg.permission_denied)
 
         if mute.minutes == minutes or (mute.minutes == -1 and minutes is None):
@@ -939,7 +939,7 @@ async def delete_mute(self, ctx: Context, mute_id: int):
         if mute is None:
             raise CommandError(t.no_mute)
 
-        if not await compare_mod_level(ctx.author, mute.mod_level):
+        if not await compare_mod_level(ctx.author, mute.mod_level) or not ctx.author.id == mute.mod:
             raise CommandError(tg.permission_denied)
 
         conf_embed = Embed(
@@ -1119,7 +1119,7 @@ async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
         if kick is None:
             raise CommandError(t.no_kick)
 
-        if not await compare_mod_level(ctx.author, kick.mod_level):
+        if not await compare_mod_level(ctx.author, kick.mod_level) or not ctx.author.id == kick.mod:
             raise CommandError(tg.permission_denied)
 
         if len(reason) > 900:
@@ -1173,7 +1173,7 @@ async def delete_kick(self, ctx: Context, kick_id: int):
         if kick is None:
             raise CommandError(t.no_kick)
 
-        if not await compare_mod_level(ctx.author, kick.mod_level):
+        if not await compare_mod_level(ctx.author, kick.mod_level) or not ctx.author.id == kick.mod:
             raise CommandError(tg.permission_denied)
 
         conf_embed = Embed(
@@ -1355,7 +1355,7 @@ async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
         if ban is None:
             raise CommandError(t.no_ban)
 
-        if not await compare_mod_level(ctx.author, ban.mod_level):
+        if not await compare_mod_level(ctx.author, ban.mod_level) or not ctx.author.id == ban.mod:
             raise CommandError(tg.permission_denied)
 
         if len(reason) > 900:
@@ -1415,7 +1415,7 @@ async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time:
 
         ban = sorted(active_bans, key=lambda active_ban: active_ban.timestamp)[0]
 
-        if not await compare_mod_level(ctx.author, ban.mod_level):
+        if not await compare_mod_level(ctx.author, ban.mod_level) or not ctx.author.id == ban.mod:
             raise CommandError(tg.permission_denied)
 
         if ban.minutes == minutes or (ban.minutes == -1 and minutes is None):
@@ -1519,7 +1519,7 @@ async def delete_ban(self, ctx: Context, ban_id: int):
         if ban is None:
             raise CommandError(t.no_ban)
 
-        if not await compare_mod_level(ctx.author, ban.mod_level):
+        if not await compare_mod_level(ctx.author, ban.mod_level) or not ctx.author.id == ban.mod:
             raise CommandError(tg.permission_denied)
 
         conf_embed = Embed(

From 26238a150e8296d2aa63336336a9f3ce56946ad9 Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Sun, 18 Jul 2021 12:35:46 +0200
Subject: [PATCH 030/120] Added mod comparison to unmutes/unbans

---
 moderation/mod/cog.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 0470231e8..5fa7844fd 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -1033,7 +1033,7 @@ async def unmute(self, ctx: Context, user: UserMemberConverter, *, reason: str):
             await user.remove_roles(mute_role)
 
         async for mute in await db.stream(filter_by(Mute, active=True, member=user.id)):
-            if not await compare_mod_level(ctx.author, mute.mod_level):
+            if not await compare_mod_level(ctx.author, mute.mod_level) or not ctx.author.id == mute.mod:
                 raise CommandError(tg.permission_denied)
 
             await Mute.deactivate(mute.id, ctx.author.id, reason)
@@ -1617,7 +1617,7 @@ async def unban(self, ctx: Context, user: UserMemberConverter, *, reason: str):
             was_banned = False
 
         async for ban in await db.stream(filter_by(Ban, active=True, member=user.id)):
-            if not await compare_mod_level(ctx.author, ban.mod_level):
+            if not await compare_mod_level(ctx.author, ban.mod_level) or not ctx.author.id == ban.mod:
                 raise CommandError(tg.permission_denied)
 
             await Ban.deactivate(ban.id, ctx.author.id, reason)

From a4c6966542364fbd575778a063a16568d5ba1c16 Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Sun, 18 Jul 2021 13:45:48 +0200
Subject: [PATCH 031/120] Added function to put bans initiated through discords
 ban system into the bots database

---
 moderation/mod/cog.py              | 59 +++++++++++++++++++++++++++---
 moderation/mod/translations/en.yml |  4 +-
 2 files changed, 57 insertions(+), 6 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 5fa7844fd..cf4f9d270 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -3,7 +3,20 @@
 from dateutil.relativedelta import relativedelta
 from typing import Optional, Union, List, Tuple, Generator
 
-from discord import Role, Guild, Member, Forbidden, HTTPException, User, Embed, NotFound, Message, Attachment
+from discord import (
+    Role,
+    Guild,
+    Member,
+    Forbidden,
+    HTTPException,
+    User,
+    Embed,
+    NotFound,
+    Message,
+    Attachment,
+    AuditLogAction,
+    AuditLogEntry,
+)
 from discord.ext import commands, tasks
 from discord.ext.commands import (
     guild_only,
@@ -29,6 +42,7 @@
 from ...contributor import Contributor
 from ...pubsub import (
     send_to_changelog,
+    send_alert,
     log_auto_kick,
     get_userlog_entries,
     get_user_info_entries,
@@ -401,7 +415,7 @@ async def handle_get_userlog_entries(self, user_id: int, show_ids: bool) -> list
                 else:
                     out.append(
                         (
-                            ban.timestamp, text.inf.id_off(f"<@{ban.mod}>", ban.reason)
+                            ban.timestamp, text.inf.id_off(f"<@{ban.mod}>", ban.reason, show_evidence(ban.evidence))
                         )
                     )
             else:
@@ -453,6 +467,41 @@ async def on_member_join(self, member: Member):
         if await db.exists(filter_by(Mute, active=True, member=member.id)):
             await member.add_roles(mute_role)
 
+    async def on_member_ban(self, guild: Guild, member: Member):
+        try:
+            entry: AuditLogEntry
+            async for entry in guild.audit_logs(limit=1, action=AuditLogAction.ban):
+                if entry.user == self.bot.user:
+                    return
+
+                if entry.reason:
+                    await Ban.create(
+                        entry.target.id,
+                        str(entry.target),
+                        entry.user.id,
+                        await get_mod_level(entry.user),
+                        -1,
+                        entry.reason,
+                        None,
+                        False,
+                    )
+
+                    await send_to_changelog_mod(
+                        guild,
+                        None,
+                        Colors.ban,
+                        t.log_banned,
+                        entry.target,
+                        entry.reason,
+                        duration=t.log_field.infinity,
+                    )
+
+                else:
+                    await send_alert(guild, t.alert_member_banned(str(entry.target), str(entry.user)))
+
+        except Forbidden:
+            raise CommandError(t.cannot_fetch_audit_logs)
+
     @commands.command()
     @ModPermission.modtools_write.check
     async def send_delete_message(self, ctx: Context, send: bool):
@@ -1305,11 +1354,11 @@ async def ban(
                 False,
             )
             if evidence:
-                user_embed.description = t.banned.evidence(ctx.author.mention, ctx.guild.name, reason,
+                user_embed.description = t.banned_inf.evidence(ctx.author.mention, ctx.guild.name, reason,
                                                            t.image_link(evidence.filename, evidence_url)
                                                            )
             else:
-                user_embed.description = t.banned.evidence(ctx.author.mention, ctx.guild.name, reason)
+                user_embed.description = t.banned_inf.evidence(ctx.author.mention, ctx.guild.name, reason)
 
             await send_to_changelog_mod(
                 ctx.guild,
@@ -1328,7 +1377,7 @@ async def ban(
             server_embed.description = t.no_dm + "\n\n" + server_embed.description
             server_embed.colour = Colors.error
 
-        # await ctx.guild.ban(user, delete_message_days=delete_days, reason=reason)
+        await ctx.guild.ban(user, delete_message_days=delete_days, reason=reason)
         await revoke_verification(user)
 
         await reply(ctx, embed=server_embed)
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index f662129a7..89d10dc9f 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -44,6 +44,7 @@ confirmation: Edit confirmation
 edit_canceled: ":x: Edit canceled"
 edit_confirmed: ":white_check_mark: Edit confirmed"
 infinity: Permanent
+cannot_fetch_audit_logs: A ban initiated through the server couldn't be added to the database because I don't have `view_audit_log` permissions on this server.
 
 # reports
 report: ":speech_balloon: Report"
@@ -157,6 +158,7 @@ ban_deleted:
   not_inf: "Your ban for {} with the reason ```\n{}\n``` has been deleted"
 ban_deleted_response: ":white_check_mark: The ban has been deleted"
 log_ban_deleted: ":white_check_mark: Ban deleted"
+alert_member_banned: "The member {} has been banned through discords ban system by {}"
 
 reported_cnt: ":speech_balloon:  Reported"
 warned_cnt: ":warning:  Warned"
@@ -219,7 +221,7 @@ ulog:
         id_on: ":no_entry: **Banned** by {} for {} because of `{}`\n`(ID: {})`{}"
       inf:
         id_off: ":no_entry: **Banned** permanently by {} because of `{}`{}"
-        id_on: ":no_entry: **Banned** by {} for {} because of `{}`\n`(ID: {})`{}"
+        id_on: ":no_entry: **Banned** by permanently by {} because of `{}`\n`(ID: {})`{}"
     update:
       temp:
         id_off: ":no_entry: **Ban updated** by {} to {} because of `{}`"

From ed72339793fa56c1211795429412da98dc9e6ca9 Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Mon, 19 Jul 2021 12:32:45 +0200
Subject: [PATCH 032/120] Updated get_userlog_entries pubsub documentation

---
 pubsub.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/pubsub.md b/pubsub.md
index dfcc57613..a4c3dc328 100644
--- a/pubsub.md
+++ b/pubsub.md
@@ -106,12 +106,13 @@ Subscriptions:
 Use this PubSub channel to get/provide log entries about a user for the user log command.
 
 ```python
-async def get_userlog_entries(user_id: int) -> list[list[tuple[datetime, str]]]
+async def get_userlog_entries(user_id: int, show_ids: bool) -> list[list[tuple[datetime, str]]]
 ```
 
 Arguments:
 
 - `user_id`: The user id
+- `show_ids`: whether to put ids from moderation events into the log entry (only relevant for the mod cog)
 
 Returns: A list of `(datetime, log_entry)` tuples
 

From 5eb7b4bd82ce36745f7e38cd1a0c1b42809500ab Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Mon, 19 Jul 2021 12:42:20 +0200
Subject: [PATCH 033/120] Added command aliases

---
 moderation/mod/cog.py | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index cf4f9d270..925c4336e 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -589,7 +589,7 @@ async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         await reply(ctx, embed=server_embed)
         await send_to_changelog_mod(ctx.guild, ctx.message, Colors.warn, t.log_warned, user, reason, evidence=evidence)
 
-    @commands.command()
+    @commands.command(aliases=["warn_edit"])
     @ModPermission.warn.check
     @guild_only()
     async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
@@ -643,7 +643,7 @@ async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
         await reply(ctx, embed=server_embed)
         await send_to_changelog_mod(ctx.guild, ctx.message, Colors.warn, t.log_warn_edited, user, reason)
 
-    @commands.command()
+    @commands.command(aliases=["warn_delete"])
     @ModPermission.warn.check
     @guild_only()
     async def delete_warn(self, ctx: Context, warn_id: int):
@@ -803,7 +803,7 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
 
         await reply(ctx, embed=server_embed)
 
-    @commands.group()
+    @commands.group(aliases=["mute_edit"])
     @ModPermission.mute.check
     @guild_only()
     async def edit_mute(self, ctx):
@@ -814,7 +814,7 @@ async def edit_mute(self, ctx):
         if ctx.invoked_subcommand is None:
             raise UserInputError
 
-    @edit_mute.command(name="reason")
+    @edit_mute.command(name="reason", aliases=["r"])
     async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
         """
         edit a mute reason
@@ -866,7 +866,7 @@ async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
         await reply(ctx, embed=server_embed)
         await send_to_changelog_mod(ctx.guild, ctx.message, Colors.mute, t.log_mute_edited, user, reason)
 
-    @edit_mute.command(name="duration")
+    @edit_mute.command(name="duration", aliases=["d"])
     async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time: DurationConverter):
         """
         edit a mute duration
@@ -975,7 +975,7 @@ async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time
             server_embed.colour = Colors.error
         await reply(ctx, embed=server_embed)
 
-    @commands.command()
+    @commands.command(aliases=["mute_delete"])
     @ModPermission.mute.check
     @guild_only()
     async def delete_mute(self, ctx: Context, mute_id: int):
@@ -1155,7 +1155,7 @@ async def kick(self, ctx: Context, member: Member, *, reason: str):
 
         await reply(ctx, embed=server_embed)
 
-    @commands.command()
+    @commands.command(aliases=["kick_edit"])
     @ModPermission.warn.check
     @guild_only()
     async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
@@ -1209,7 +1209,7 @@ async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
         await reply(ctx, embed=server_embed)
         await send_to_changelog_mod(ctx.guild, ctx.message, Colors.kick, t.log_kick_edited, user, reason)
 
-    @commands.command()
+    @commands.command(aliases=["kick_delete"])
     @ModPermission.kick.check
     @guild_only()
     async def delete_kick(self, ctx: Context, kick_id: int):
@@ -1382,7 +1382,7 @@ async def ban(
 
         await reply(ctx, embed=server_embed)
 
-    @commands.group()
+    @commands.group(aliases=["ban_edit"])
     @ModPermission.mute.check
     @guild_only()
     async def edit_ban(self, ctx):
@@ -1393,7 +1393,7 @@ async def edit_ban(self, ctx):
         if ctx.invoked_subcommand is None:
             raise UserInputError
 
-    @edit_ban.command(name="reason")
+    @edit_ban.command(name="reason", aliases=["r"])
     async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
         """
         edit a ban reason
@@ -1445,7 +1445,7 @@ async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
         await reply(ctx, embed=server_embed)
         await send_to_changelog_mod(ctx.guild, ctx.message, Colors.ban, t.log_ban_edited, user, reason)
 
-    @edit_ban.command(name="duration")
+    @edit_ban.command(name="duration", aliases=["d"])
     async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time: DurationConverter):
         """
         edit a ban duration
@@ -1555,7 +1555,7 @@ async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time:
             server_embed.colour = Colors.error
         await reply(ctx, embed=server_embed)
 
-    @commands.command()
+    @commands.command(aliases=["ban_delete"])
     @ModPermission.ban.check
     @guild_only()
     async def delete_ban(self, ctx: Context, ban_id: int):

From d6b73c19f744f9bcadce952b8093cacddee752d5 Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Mon, 19 Jul 2021 13:52:14 +0200
Subject: [PATCH 034/120] Added mod tools documentation

---
 moderation/mod/cog.py           |   2 +-
 moderation/mod/documentation.md | 292 ++++++++++++++++++++++++++++++++
 2 files changed, 293 insertions(+), 1 deletion(-)
 create mode 100644 moderation/mod/documentation.md

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 925c4336e..4b252b4fb 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -1277,7 +1277,7 @@ async def ban(
         """
         ban a user
         time format: `ymwdhn`
-        set ban_days to `inf` for a permanent ban
+        set time to `inf` for a permanent ban
         """
 
         time: Optional[int]
diff --git a/moderation/mod/documentation.md b/moderation/mod/documentation.md
new file mode 100644
index 000000000..31938b138
--- /dev/null
+++ b/moderation/mod/documentation.md
@@ -0,0 +1,292 @@
+# Mod Tools
+
+This cog contains commands for server moderation purposes.
+
+## `report`
+
+The .report command can be used to report misbehaviour of other server members.
+
+```css
+.report <user> <reason>
+```
+
+|Argument|Required|Description|
+|:------:|:------:|:----------|
+|`user`|:heavy_check_mark:|The user who should be reported|
+|`reason`|:heavy_check_mark:|A description of the users misbehaviour|
+
+The reason cannot be longer than 900 characters.
+
+## `warn`
+
+The .warn command can be used to warn a member because of his misbehaviour.
+
+```css
+.warn <user> <reason>
+```
+
+|Argument|Required|Description|
+|:------:|:------:|:----------|
+|`user`|:heavy_check_mark:|The user who should be warned|
+|`reason`|:heavy_check_mark:|A reason why the user is warned|
+
+The reason cannot be longer than 900 characters.
+
+
+## `edit_warn`
+
+The .edit_warn command can be used to edit a warns reason.
+
+```css
+.[edit_warn|warn_edit] <warn_id> <reason>
+```
+
+|Argument|Required|Description|
+|:------:|:------:|:----------|
+|`user`|:heavy_check_mark:|The id of the warn whose reason should be changed|
+|`reason`|:heavy_check_mark:|The new warn reason|
+
+You can obtain the warn id from a users user log.
+The reason cannot be longer than 900 characters.
+To perform these changes, you need to be the moderator who created the original warn, have a higher moderation level or be the server owner.
+
+## `delete_warn`
+
+The .delete_warn command can be used to delete warns from the database.
+
+```css
+.[delete_warn|warn_delete] <warn_id>
+```
+
+|Argument|Required|Description|
+|:------:|:------:|:----------|
+|`user`|:heavy_check_mark:|The id of the warn which should be deleted|
+
+You can obtain the warn id from a users user log.
+To perform these changes, you need to be the moderator who created the original warn, have a higher moderation level or be the server owner.
+
+## `mute`
+
+The .mute command can be used to give a member a formerly configured mute role.
+
+```css
+.mute <user> <time> <reason>
+```
+
+|Argument|Required|Description|
+|:------:|:------:|:----------|
+|`user`|:heavy_check_mark:|The user who should be warned|
+|`time`|:heavy_check_mark:|How long the user should be muted|
+|`reason`|:heavy_check_mark:|A reason why the user is muted|
+
+The time must be provided as `[years]y[months]m[weeks]w[days]d[hours]h[minutes]n`, but any time unit that is not required can be ignored.
+Set the duration to `inf` to mute a user permanently.
+The reason cannot be longer than 900 characters.
+
+## `edit_mute`
+
+The edit_mute command can be used to edit a mute. There are two subcommands:
+
+### `reason`
+
+You can edit a mute reason by using:
+
+```css
+.[edit_mute|mute_edit] [reason|r] <mute_id> <reason>
+```
+
+|Argument|Required|Description|
+|:------:|:------:|:----------|
+|`mute_id`|:heavy_check_mark:|The id of the mute whose reason should be changed|
+|`reason`|:heavy_check_mark:|The new mute reason|
+
+You can obtain the mute id from a users user log.
+To perform these changes, you need to be the moderator who created the original mute, have a higher moderation level or be the server owner.
+The reason cannot be longer than 900 characters.
+
+### `duration`
+
+You can edit a mute duration by using:
+
+```css
+.[edit_mute|mute_edit] [duration|d] <user> <time>
+```
+
+|Argument|Required|Description|
+|:------:|:------:|:----------|
+|`user`|:heavy_check_mark:|The user whose mute duration should be changed|
+|`time`|:heavy_check_mark:|The new mute duration|
+
+The time format required is the same as before.
+To perform these changes, you need to be the moderator who created the original mute, have a higher moderation level or be the server owner.
+You can only edit the duration of active mutes.
+
+## `delete_mute`
+
+The .delete_mute command can be used to delete a mute from the database.
+
+```css
+.[delete_mute|mute_delete] <mute_id>
+```
+
+|Argument|Required|Description|
+|:------:|:------:|:----------|
+|`mute_id`|:heavy_check_mark:|The id of the mute which should be deleted|
+
+You can obtain a mute id from a users user log.
+To perform these changes, you need to be the moderator who created the mute, have a higher moderation level or be the server owner.
+If the mute id is linked to an active mute, the mute role will be removed from the user.
+
+## `unmute`
+
+The .unmute command can be used to unmute a user.
+
+```css
+.unmute <user> <reason
+```
+
+|Argument|Required|Description|
+|:------:|:------:|:----------|
+|`user`|:heavy_check_mark:|The user who should be unmuted|
+|`reason`|:heavy_check_mark:|The reason why the user should be unmuted|
+
+To perform these changes, you need to be the moderator who created the mute, have a higher moderation level or be the server owner.
+The mute role will be removed from the user instantly.
+
+## `kick`
+
+The .kick command can be used to kick a user from the server.
+
+```css
+.kick <user> <reason>
+```
+
+|Argument|Required|Description|
+|:------:|:------:|:----------|
+|`user`|:heavy_check_mark:|The user who should be kicked|
+|`reason`|:heavy_check_mark:|A reason why the user is kicked|
+
+The reason cannot be longer than 900 characters.
+
+
+## `edit_kick`
+
+The .edit_kick command can be used to edit a kick reason.
+
+```css
+.[edit_kick|kick_edit] <kick_id> <reason>
+```
+
+|Argument|Required|Description|
+|:------:|:------:|:----------|
+|`kick_id`|:heavy_check_mark:|The id of the kick whose reason should be changed|
+|`reason`|:heavy_check_mark:|The new kick reason|
+
+You can obtain the kick id from a users user log.
+The reason cannot be longer than 900 characters.
+To perform these changes, you need to be the moderator who created the original kick, have a higher moderation level or be the server owner.
+
+## `delete_kick`
+
+The .delete_kick command can be used to delete warns from the database.
+
+```css
+.[delete_kick|kick_delete] <kick_id>
+```
+
+|Argument|Required|Description|
+|:------:|:------:|:----------|
+|`user`|:heavy_check_mark:|The id of the kick which should be deleted|
+
+You can obtain the kick id from a users user log.
+To perform these changes, you need to be the moderator who created the original kick, have a higher moderation level or be the server owner.
+
+## `ban`
+
+The .ban command can be used to ban a user from the server.
+
+```css
+.ban <user> <time> <delete_days> <reason>
+```
+
+|Argument|Required|Description|
+|:------:|:------:|:----------|
+|`user`|:heavy_check_mark:|The user who should be banned|
+|`time`|:heavy_check_mark:|How long the user should be banned|
+|`delete_days`|:heavy_check_mark:|How many days in the past messages of the user should be deleted|
+|`reason`|:heavy_check_mark:|A reason why the user is banned|
+
+The time must be provided as `[years]y[months]m[weeks]w[days]d[hours]h[minutes]n`, but any time unit that is not required can be ignored.
+Set the duration to `inf` to ban a user permanently.
+The amount of delete days must be between zero and seven.
+The reason cannot be longer than 900 characters.
+
+## `edit_ban`
+
+The .edit_ban command can be used to edit a ban. There are two subcommands:
+
+### `reason`
+
+You can edit a ban reason by using:
+
+```css
+.[edit_ban|ban_edit] [reason|r] <ban_id> <reason>
+```
+
+|Argument|Required|Description|
+|:------:|:------:|:----------|
+|`ban_id`|:heavy_check_mark:|The id of the ban whose reason should be changed|
+|`reason`|:heavy_check_mark:|The new ban reason|
+
+You can obtain the ban id from a users user log.
+To perform these changes, you need to be the moderator who created the original ban, have a higher moderation level or be the server owner.
+The reason cannot be longer than 900 characters.
+
+### `duration`
+
+You can edit a ban duration by using:
+
+```css
+.[edit_ban|ban_edit] [duration|d] <user> <time>
+```
+
+|Argument|Required|Description|
+|:------:|:------:|:----------|
+|`user`|:heavy_check_mark:|The user whose ban duration should be changed|
+|`time`|:heavy_check_mark:|The new ban duration|
+
+The time format required is the same as before.
+To perform these changes, you need to be the moderator who created the original ban, have a higher moderation level or be the server owner.
+You can only edit the duration of active bans.
+
+## `delete_ban`
+
+The .delete_ban command can be used to delete a ban from the database.
+
+```css
+.[delete_ban|ban_delete] <ban_id>
+```
+
+|Argument|Required|Description|
+|:------:|:------:|:----------|
+|`ban_id`|:heavy_check_mark:|The id of the ban which should be deleted|
+
+You can obtain a ban id from a users user log.
+To perform these changes, you need to be the moderator who created the ban, have a higher moderation level or be the server owner.
+If the ban id is linked to an active ban, the user will be unbanned.
+
+## `unban`
+
+The .unban command can be used to unban a user.
+
+```css
+.unban <user> <reason
+```
+
+|Argument|Required|Description|
+|:------:|:------:|:----------|
+|`user`|:heavy_check_mark:|The user who should be unbanned|
+|`reason`|:heavy_check_mark:|The reason why the user should be unbanned|
+
+To perform these changes, you need to be the moderator who created the ban, have a higher moderation level or be the server owner.
+The user will be unbanned instantly.

From dbc1b3bb09f4cfdfad87d1b9d62272a7853eb637 Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Mon, 19 Jul 2021 13:57:42 +0200
Subject: [PATCH 035/120] Added send_delete_message command to mod tools
 documentation

---
 moderation/mod/documentation.md | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/moderation/mod/documentation.md b/moderation/mod/documentation.md
index 31938b138..621944f1c 100644
--- a/moderation/mod/documentation.md
+++ b/moderation/mod/documentation.md
@@ -2,6 +2,14 @@
 
 This cog contains commands for server moderation purposes.
 
+## `send_delete_message`
+
+The .send_delete_message command can be used to configure whether to send a warn/mute/kick/ban deletion message to the concerned user.
+
+|Argument|Required|Description|
+|:------:|:------:|:----------|
+|`send`|:heavy_check_mark:|Whether to send a deletion message or not|
+
 ## `report`
 
 The .report command can be used to report misbehaviour of other server members.

From 794687014a0c1a3a85c0b1e66f48e0be3ed3e3f1 Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Mon, 19 Jul 2021 14:31:46 +0200
Subject: [PATCH 036/120] Fixed codestyle

---
 moderation/mod/cog.py    | 214 +++++++++++++++++++++------------------
 moderation/mod/models.py |  73 ++++++++-----
 2 files changed, 162 insertions(+), 125 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 4b252b4fb..4be154b8d 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -86,15 +86,18 @@ def convert(years: int, months: int, weeks: int, days: int, hours: int, minutes:
 
 
 def time_to_units(minutes: Union[int, float]) -> str:
-    rd = relativedelta(datetime.fromtimestamp(0) + timedelta(minutes=minutes),
-                       datetime.fromtimestamp(0))  # Workaround that should be improved later
+    rd = relativedelta(
+        datetime.fromtimestamp(0) + timedelta(minutes=minutes),datetime.fromtimestamp(0)
+    )  # Workaround that should be improved later
 
     def generator() -> Generator:
-        for unit in [t.times.years(cnt=rd.years),
-                     t.times.months(cnt=rd.months),
-                     t.times.days(cnt=rd.days),
-                     t.times.hours(cnt=rd.hours),
-                     t.times.minutes(cnt=rd.minutes)]:
+        for unit in [
+            t.times.years(cnt=rd.years),
+            t.times.months(cnt=rd.months),
+            t.times.days(cnt=rd.days),
+            t.times.hours(cnt=rd.hours),
+            t.times.minutes(cnt=rd.minutes),
+        ]:
             if not str(unit).startswith("0"):
                 yield str(unit)
 
@@ -284,17 +287,19 @@ async def handle_get_userlog_entries(self, user_id: int, show_ids: bool) -> list
         async for report in await db.stream(filter_by(Report, member=user_id)):
             if show_ids:
                 out.append(
-                    (report.timestamp,
-                     t.ulog.reported.id_on(f"<@{report.reporter}>", report.reason, report.id,
-                                           show_evidence(report.evidence)
-                                           )
-                     )
+                    (
+                        report.timestamp,
+                        t.ulog.reported.id_on(
+                            f"<@{report.reporter}>", report.reason, report.id, show_evidence(report.evidence)
+                        ),
+                    )
                 )
             else:
                 out.append(
-                    (report.timestamp,
-                     t.ulog.reported.id_off(f"<@{report.reporter}>", report.reason, show_evidence(report.evidence))
-                     )
+                    (
+                        report.timestamp,
+                        t.ulog.reported.id_off(f"<@{report.reporter}>", report.reason, show_evidence(report.evidence)),
+                    )
                 )
 
         warn: Warn
@@ -303,15 +308,12 @@ async def handle_get_userlog_entries(self, user_id: int, show_ids: bool) -> list
                 out.append(
                     (
                         warn.timestamp,
-                        t.ulog.warned.id_on(f"<@{warn.mod}>", warn.reason, warn.id, show_evidence(warn.evidence))
+                        t.ulog.warned.id_on(f"<@{warn.mod}>", warn.reason, warn.id, show_evidence(warn.evidence)),
                     )
                 )
             else:
                 out.append(
-                    (
-                        warn.timestamp,
-                        t.ulog.warned.id_off(f"<@{warn.mod}>", warn.reason, show_evidence(warn.evidence))
-                    )
+                    (warn.timestamp, t.ulog.warned.id_off(f"<@{warn.mod}>", warn.reason, show_evidence(warn.evidence)))
                 )
 
         mute: Mute
@@ -327,33 +329,34 @@ async def handle_get_userlog_entries(self, user_id: int, show_ids: bool) -> list
                     out.append(
                         (
                             mute.timestamp,
-                            text.inf.id_on(f"<@{mute.mod}>", mute.reason, mute.id, show_evidence(mute.evidence))
+                            text.inf.id_on(f"<@{mute.mod}>", mute.reason, mute.id, show_evidence(mute.evidence)),
                         )
                     )
                 else:
                     out.append(
-                        (
-                            mute.timestamp,
-                            text.inf.id_off(f"<@{mute.mod}>", mute.reason, show_evidence(mute.evidence))
-                        )
+                        (mute.timestamp, text.inf.id_off(f"<@{mute.mod}>", mute.reason, show_evidence(mute.evidence)))
                     )
             else:
                 if show_ids:
                     out.append(
                         (
                             mute.timestamp,
-                            text.temp.id_on(f"<@{mute.mod}>", time_to_units(mute.minutes), mute.reason, mute.id,
-                                            show_evidence(mute.evidence)
-                                            )
+                            text.temp.id_on(
+                                f"<@{mute.mod}>",
+                                time_to_units(mute.minutes),
+                                mute.reason,
+                                mute.id,
+                                show_evidence(mute.evidence),
+                            ),
                         )
                     )
                 else:
                     out.append(
                         (
                             mute.timestamp,
-                            text.temp.id_off(f"<@{mute.mod}>", time_to_units(mute.minutes), mute.reason,
-                                             show_evidence(mute.evidence)
-                                             )
+                            text.temp.id_off(
+                                f"<@{mute.mod}>", time_to_units(mute.minutes), mute.reason, show_evidence(mute.evidence)
+                            ),
                         )
                     )
 
@@ -383,14 +386,14 @@ async def handle_get_userlog_entries(self, user_id: int, show_ids: bool) -> list
                     out.append(
                         (
                             kick.timestamp,
-                            t.ulog.kicked.id_on(f"<@{kick.mod}>", kick.reason, kick.id, show_evidence(kick.evidence))
+                            t.ulog.kicked.id_on(f"<@{kick.mod}>", kick.reason, kick.id, show_evidence(kick.evidence)),
                         )
                     )
                 else:
                     out.append(
                         (
                             kick.timestamp,
-                            t.ulog.kicked.id_off(f"<@{kick.mod}>", kick.reason, show_evidence(kick.evidence))
+                            t.ulog.kicked.id_off(f"<@{kick.mod}>", kick.reason, show_evidence(kick.evidence)),
                         )
                     )
             else:
@@ -409,32 +412,34 @@ async def handle_get_userlog_entries(self, user_id: int, show_ids: bool) -> list
                     out.append(
                         (
                             ban.timestamp,
-                            text.inf.id_on(f"<@{ban.mod}>", ban.reason, ban.id, show_evidence(ban.evidence))
+                            text.inf.id_on(f"<@{ban.mod}>", ban.reason, ban.id, show_evidence(ban.evidence)),
                         )
                     )
                 else:
                     out.append(
-                        (
-                            ban.timestamp, text.inf.id_off(f"<@{ban.mod}>", ban.reason, show_evidence(ban.evidence))
-                        )
+                        (ban.timestamp, text.inf.id_off(f"<@{ban.mod}>", ban.reason, show_evidence(ban.evidence)))
                     )
             else:
                 if show_ids:
                     out.append(
                         (
                             ban.timestamp,
-                            text.temp.id_on(f"<@{ban.mod}>", time_to_units(ban.minutes), ban.reason, ban.id,
-                                            show_evidence(ban.evidence)
-                                            )
+                            text.temp.id_on(
+                                f"<@{ban.mod}>",
+                                time_to_units(ban.minutes),
+                                ban.reason,
+                                ban.id,
+                                show_evidence(ban.evidence),
+                            ),
                         )
                     )
                 else:
                     out.append(
                         (
                             ban.timestamp,
-                            text.temp.id_off(f"<@{ban.mod}>", time_to_units(ban.minutes), ban.reason,
-                                             show_evidence(ban.evidence)
-                                             )
+                            text.temp.id_off(
+                                f"<@{ban.mod}>", time_to_units(ban.minutes), ban.reason, show_evidence(ban.evidence)
+                            ),
                         )
                     )
 
@@ -541,8 +546,9 @@ async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         server_embed = Embed(title=t.report, description=t.reported_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.avatar_url)
         await reply(ctx, embed=server_embed)
-        await send_to_changelog_mod(ctx.guild,
-                                    ctx.message, Colors.report, t.log_reported, user, reason, evidence=evidence)
+        await send_to_changelog_mod(
+            ctx.guild, ctx.message, Colors.report, t.log_reported, user, reason, evidence=evidence
+        )
 
     @commands.command()
     @ModPermission.warn.check
@@ -572,9 +578,12 @@ async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
             colour=Colors.ModTools,
         )
         if evidence:
-            user_embed.description = t.warned.evidence(ctx.author.mention, ctx.guild.name, reason,
-                                                       t.image_link(evidence.filename, evidence_url),
-                                                       )
+            user_embed.description = t.warned.evidence(
+                ctx.author.mention,
+                ctx.guild.name,
+                reason,
+                t.image_link(evidence.filename, evidence_url),
+            )
         else:
             user_embed.description = t.warned.no_evidence(ctx.author.mention, ctx.guild.name, reason)
 
@@ -609,9 +618,7 @@ async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
             raise CommandError(t.reason_too_long)
 
         conf_embed = Embed(
-            title=t.confirmation,
-            description=t.confirm_warn_edit(warn.reason, reason),
-            color=Colors.ModTools
+            title=t.confirmation, description=t.confirm_warn_edit(warn.reason, reason), color=Colors.ModTools
         )
 
         async with confirm(ctx, conf_embed) as (result, msg):
@@ -650,7 +657,7 @@ async def delete_warn(self, ctx: Context, warn_id: int):
         """
         delete a warn
         get the warn id from the users user log
-         """
+        """
 
         warn = await db.get(Warn, id=warn_id)
         if warn is None:
@@ -660,9 +667,7 @@ async def delete_warn(self, ctx: Context, warn_id: int):
             raise CommandError(tg.permission_denied)
 
         conf_embed = Embed(
-            title=t.confirmation,
-            description=t.confirm_warn_delete(warn.member_name, warn.id),
-            color=Colors.ModTools
+            title=t.confirmation, description=t.confirm_warn_delete(warn.member_name, warn.id), color=Colors.ModTools
         )
 
         async with confirm(ctx, conf_embed) as (result, msg):
@@ -749,13 +754,20 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
                 evidence_url,
             )
             if evidence:
-                user_embed.description = t.muted.evidence(ctx.author.mention, ctx.guild.name, time_to_units(minutes),
-                                                          reason, t.image_link(evidence.filename, evidence_url),
-                                                          )
+                user_embed.description = t.muted.evidence(
+                    ctx.author.mention,
+                    ctx.guild.name,
+                    time_to_units(minutes),
+                    reason,
+                    t.image_link(evidence.filename, evidence_url),
+                )
             else:
-                user_embed.description = t.muted.no_evidence(ctx.author.mention, ctx.guild.name, time_to_units(minutes),
-                                                             reason,
-                                                             )
+                user_embed.description = t.muted.no_evidence(
+                    ctx.author.mention,
+                    ctx.guild.name,
+                    time_to_units(minutes),
+                    reason,
+                )
 
             await send_to_changelog_mod(
                 ctx.guild,
@@ -778,9 +790,12 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
                 evidence_url,
             )
             if evidence:
-                user_embed.description = t.muted_inf.evidence(ctx.author.mention, ctx.guild.name, reason,
-                                                              t.image_link(evidence.filename, evidence_url),
-                                                              )
+                user_embed.description = t.muted_inf.evidence(
+                    ctx.author.mention,
+                    ctx.guild.name,
+                    reason,
+                    t.image_link(evidence.filename, evidence_url),
+                )
             else:
                 user_embed.description = t.muted_inf.no_evidence(ctx.author.mention, ctx.guild.name, reason)
 
@@ -832,9 +847,7 @@ async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
             raise CommandError(t.reason_too_long)
 
         conf_embed = Embed(
-            title=t.confirmation,
-            description=t.confirm_mute_edit.reason(mute.reason, reason),
-            color=Colors.ModTools
+            title=t.confirmation, description=t.confirm_mute_edit.reason(mute.reason, reason), color=Colors.ModTools
         )
 
         async with confirm(ctx, conf_embed) as (result, msg):
@@ -964,7 +977,8 @@ async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time
                 ctx.message,
                 Colors.mute,
                 t.log_mute_edited,
-                user, mute.reason,
+                user,
+                mute.reason,
                 duration=t.log_field.infinity,
             )
 
@@ -982,7 +996,7 @@ async def delete_mute(self, ctx: Context, mute_id: int):
         """
         delete a mute
         get the mute id from the users user log
-         """
+        """
 
         mute = await db.get(Mute, id=mute_id)
         if mute is None:
@@ -992,9 +1006,7 @@ async def delete_mute(self, ctx: Context, mute_id: int):
             raise CommandError(tg.permission_denied)
 
         conf_embed = Embed(
-            title=t.confirmation,
-            description=t.confirm_mute_delete(mute.member_name, mute.id),
-            color=Colors.ModTools
+            title=t.confirmation, description=t.confirm_mute_delete(mute.member_name, mute.id), color=Colors.ModTools
         )
 
         async with confirm(ctx, conf_embed) as (result, msg):
@@ -1123,8 +1135,9 @@ async def kick(self, ctx: Context, member: Member, *, reason: str):
             evidence_url = None
 
         await Kick.create(member.id, str(member), ctx.author.id, await get_mod_level(ctx.author), reason, evidence_url)
-        await send_to_changelog_mod(ctx.guild, ctx.message, Colors.kick, t.log_kicked, member, reason,
-                                    evidence=evidence)
+        await send_to_changelog_mod(
+            ctx.guild, ctx.message, Colors.kick, t.log_kicked, member, reason, evidence=evidence
+        )
 
         user_embed = Embed(
             title=t.kick,
@@ -1132,9 +1145,12 @@ async def kick(self, ctx: Context, member: Member, *, reason: str):
         )
 
         if evidence:
-            user_embed.description = t.kicked.evidence(ctx.author.mention, ctx.guild.name, reason,
-                                                       t.image_link(evidence.filename, evidence_url),
-                                                       )
+            user_embed.description = t.kicked.evidence(
+                ctx.author.mention,
+                ctx.guild.name,
+                reason,
+                t.image_link(evidence.filename, evidence_url),
+            )
         else:
             user_embed.description = t.kicked.no_evidence(ctx.author.mention, ctx.guild.name, reason)
 
@@ -1175,9 +1191,7 @@ async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
             raise CommandError(t.reason_too_long)
 
         conf_embed = Embed(
-            title=t.confirmation,
-            description=t.confirm_kick_edit(kick.reason, reason),
-            color=Colors.ModTools
+            title=t.confirmation, description=t.confirm_kick_edit(kick.reason, reason), color=Colors.ModTools
         )
 
         async with confirm(ctx, conf_embed) as (result, msg):
@@ -1216,7 +1230,7 @@ async def delete_kick(self, ctx: Context, kick_id: int):
         """
         delete a kick
         get the kick id from the users user log
-         """
+        """
 
         kick = await db.get(Kick, id=kick_id)
         if kick is None:
@@ -1226,9 +1240,7 @@ async def delete_kick(self, ctx: Context, kick_id: int):
             raise CommandError(tg.permission_denied)
 
         conf_embed = Embed(
-            title=t.confirmation,
-            description=t.confirm_kick_delete(kick.member_name, kick.id),
-            color=Colors.ModTools
+            title=t.confirmation, description=t.confirm_kick_delete(kick.member_name, kick.id), color=Colors.ModTools
         )
 
         async with confirm(ctx, conf_embed) as (result, msg):
@@ -1325,13 +1337,17 @@ async def ban(
                 False,
             )
             if evidence:
-                user_embed.description = t.banned.evidence(ctx.author.mention, ctx.guild.name, time_to_units(minutes),
-                                                           reason, t.image_link(evidence.filename, evidence_url)
-                                                           )
+                user_embed.description = t.banned.evidence(
+                    ctx.author.mention,
+                    ctx.guild.name,
+                    time_to_units(minutes),
+                    reason,
+                    t.image_link(evidence.filename, evidence_url),
+                )
             else:
-                user_embed.description = t.banned.no_evidence(ctx.author.mention, ctx.guild.name,
-                                                              time_to_units(minutes), reason
-                                                              )
+                user_embed.description = t.banned.no_evidence(
+                    ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason
+                )
             await send_to_changelog_mod(
                 ctx.guild,
                 ctx.message,
@@ -1354,9 +1370,9 @@ async def ban(
                 False,
             )
             if evidence:
-                user_embed.description = t.banned_inf.evidence(ctx.author.mention, ctx.guild.name, reason,
-                                                           t.image_link(evidence.filename, evidence_url)
-                                                           )
+                user_embed.description = t.banned_inf.evidence(
+                    ctx.author.mention, ctx.guild.name, reason, t.image_link(evidence.filename, evidence_url)
+                )
             else:
                 user_embed.description = t.banned_inf.evidence(ctx.author.mention, ctx.guild.name, reason)
 
@@ -1368,7 +1384,7 @@ async def ban(
                 user,
                 reason,
                 duration=t.log_field.infinity,
-                evidence=evidence
+                evidence=evidence,
             )
 
         try:
@@ -1411,9 +1427,7 @@ async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
             raise CommandError(t.reason_too_long)
 
         conf_embed = Embed(
-            title=t.confirmation,
-            description=t.confirm_ban_edit.reason(ban.reason, reason),
-            color=Colors.ModTools
+            title=t.confirmation, description=t.confirm_ban_edit.reason(ban.reason, reason), color=Colors.ModTools
         )
 
         async with confirm(ctx, conf_embed) as (result, msg):
@@ -1562,7 +1576,7 @@ async def delete_ban(self, ctx: Context, ban_id: int):
         """
         delete a ban
         get the ban id from the users user log
-         """
+        """
 
         ban = await db.get(Ban, id=ban_id)
         if ban is None:
@@ -1572,9 +1586,7 @@ async def delete_ban(self, ctx: Context, ban_id: int):
             raise CommandError(tg.permission_denied)
 
         conf_embed = Embed(
-            title=t.confirmation,
-            description=t.confirm_ban_delete(ban.member_name, ban.id),
-            color=Colors.ModTools
+            title=t.confirmation, description=t.confirm_ban_delete(ban.member_name, ban.id), color=Colors.ModTools
         )
 
         async with confirm(ctx, conf_embed) as (result, msg):
diff --git a/moderation/mod/models.py b/moderation/mod/models.py
index 26b0da50e..d62ab835c 100644
--- a/moderation/mod/models.py
+++ b/moderation/mod/models.py
@@ -46,16 +46,18 @@ class Warn(db.Base):
     evidence: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
 
     @staticmethod
-    async def create(member: int, member_name: str, mod: int, mod_level: int, reason: str,
-                     evidence: Optional[str]) -> Warn:
-        row = Warn(member=member,
-                   member_name=member_name,
-                   mod=mod,
-                   mod_level=mod_level,
-                   timestamp=datetime.utcnow(),
-                   reason=reason,
-                   evidence=evidence,
-                   )
+    async def create(
+        member: int, member_name: str, mod: int, mod_level: int, reason: str, evidence: Optional[str]
+    ) -> Warn:
+        row = Warn(
+            member=member,
+            member_name=member_name,
+            mod=mod,
+            mod_level=mod_level,
+            timestamp=datetime.utcnow(),
+            reason=reason,
+            evidence=evidence,
+        )
         await db.add(row)
         return row
 
@@ -92,8 +94,16 @@ class Mute(db.Base):
     is_update: Union[Column, bool] = Column(Boolean)
 
     @staticmethod
-    async def create(member: int, member_name: str, mod: int, mod_level: int, minutes: int, reason: str,
-                     evidence: Optional[str], is_update: bool = False) -> Mute:
+    async def create(
+            member: int,
+            member_name: str,
+            mod: int,
+            mod_level: int,
+            minutes: int,
+            reason: str,
+            evidence: Optional[str],
+            is_update: bool = False
+    ) -> Mute:
         row = Mute(
             member=member,
             member_name=member_name,
@@ -152,16 +162,23 @@ class Kick(db.Base):
     evidence: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
 
     @staticmethod
-    async def create(member: int, member_name: str, mod: Optional[int], mod_level: Optional[int],
-                     reason: Optional[str], evidence: Optional[str]) -> Kick:
-        row = Kick(member=member,
-                   member_name=member_name,
-                   mod=mod,
-                   mod_level=mod_level,
-                   timestamp=datetime.utcnow(),
-                   reason=reason,
-                   evidence=evidence,
-                   )
+    async def create(
+            member: int,
+            member_name: str,
+            mod: Optional[int],
+            mod_level: Optional[int],
+            reason: Optional[str],
+            evidence: Optional[str]
+    ) -> Kick:
+        row = Kick(
+            member=member,
+            member_name=member_name,
+            mod=mod,
+            mod_level=mod_level,
+            timestamp=datetime.utcnow(),
+            reason=reason,
+            evidence=evidence,
+        )
         await db.add(row)
         return row
 
@@ -198,8 +215,16 @@ class Ban(db.Base):
     is_update: Union[Column, bool] = Column(Boolean)
 
     @staticmethod
-    async def create(member: int, member_name: str, mod: int, mod_level: int, minutes: int, reason: str,
-                     evidence: Optional[str], is_update: bool = False) -> Ban:
+    async def create(
+            member: int,
+            member_name: str,
+            mod: int,
+            mod_level: int,
+            minutes: int,
+            reason: str,
+            evidence: Optional[str],
+            is_update: bool = False
+    ) -> Ban:
         row = Ban(
             member=member,
             member_name=member_name,

From fe60c02c31be5f5181283e99dc30374756a2feb6 Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Mon, 19 Jul 2021 14:45:10 +0200
Subject: [PATCH 037/120] Fixed linter

---
 moderation/mod/cog.py    | 63 +++++++++++++++++++++-------------------
 moderation/mod/models.py | 44 ++++++++++++++--------------
 2 files changed, 55 insertions(+), 52 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 4be154b8d..0c94477ea 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -87,7 +87,7 @@ def convert(years: int, months: int, weeks: int, days: int, hours: int, minutes:
 
 def time_to_units(minutes: Union[int, float]) -> str:
     rd = relativedelta(
-        datetime.fromtimestamp(0) + timedelta(minutes=minutes),datetime.fromtimestamp(0)
+        datetime.fromtimestamp(0) + timedelta(minutes=minutes), datetime.fromtimestamp(0)
     )  # Workaround that should be improved later
 
     def generator() -> Generator:
@@ -290,16 +290,16 @@ async def handle_get_userlog_entries(self, user_id: int, show_ids: bool) -> list
                     (
                         report.timestamp,
                         t.ulog.reported.id_on(
-                            f"<@{report.reporter}>", report.reason, report.id, show_evidence(report.evidence)
+                            f"<@{report.reporter}>", report.reason, report.id, show_evidence(report.evidence),
                         ),
-                    )
+                    ),
                 )
             else:
                 out.append(
                     (
                         report.timestamp,
                         t.ulog.reported.id_off(f"<@{report.reporter}>", report.reason, show_evidence(report.evidence)),
-                    )
+                    ),
                 )
 
         warn: Warn
@@ -309,12 +309,12 @@ async def handle_get_userlog_entries(self, user_id: int, show_ids: bool) -> list
                     (
                         warn.timestamp,
                         t.ulog.warned.id_on(f"<@{warn.mod}>", warn.reason, warn.id, show_evidence(warn.evidence)),
-                    )
+                    ),
                 )
             else:
                 out.append(
                     (warn.timestamp, t.ulog.warned.id_off(f"<@{warn.mod}>", warn.reason, show_evidence(warn.evidence)))
-                )
+                ),
 
         mute: Mute
         async for mute in await db.stream(filter_by(Mute, member=user_id)):
@@ -330,11 +330,11 @@ async def handle_get_userlog_entries(self, user_id: int, show_ids: bool) -> list
                         (
                             mute.timestamp,
                             text.inf.id_on(f"<@{mute.mod}>", mute.reason, mute.id, show_evidence(mute.evidence)),
-                        )
+                        ),
                     )
                 else:
                     out.append(
-                        (mute.timestamp, text.inf.id_off(f"<@{mute.mod}>", mute.reason, show_evidence(mute.evidence)))
+                        (mute.timestamp, text.inf.id_off(f"<@{mute.mod}>", mute.reason, show_evidence(mute.evidence))),
                     )
             else:
                 if show_ids:
@@ -348,16 +348,19 @@ async def handle_get_userlog_entries(self, user_id: int, show_ids: bool) -> list
                                 mute.id,
                                 show_evidence(mute.evidence),
                             ),
-                        )
+                        ),
                     )
                 else:
                     out.append(
                         (
                             mute.timestamp,
                             text.temp.id_off(
-                                f"<@{mute.mod}>", time_to_units(mute.minutes), mute.reason, show_evidence(mute.evidence)
+                                f"<@{mute.mod}>",
+                                time_to_units(mute.minutes),
+                                mute.reason,
+                                show_evidence(mute.evidence),
                             ),
-                        )
+                        ),
                     )
 
             if not mute.active and not mute.updated:
@@ -387,14 +390,14 @@ async def handle_get_userlog_entries(self, user_id: int, show_ids: bool) -> list
                         (
                             kick.timestamp,
                             t.ulog.kicked.id_on(f"<@{kick.mod}>", kick.reason, kick.id, show_evidence(kick.evidence)),
-                        )
+                        ),
                     )
                 else:
                     out.append(
                         (
                             kick.timestamp,
                             t.ulog.kicked.id_off(f"<@{kick.mod}>", kick.reason, show_evidence(kick.evidence)),
-                        )
+                        ),
                     )
             else:
                 out.append((kick.timestamp, t.ulog.autokicked))
@@ -413,11 +416,11 @@ async def handle_get_userlog_entries(self, user_id: int, show_ids: bool) -> list
                         (
                             ban.timestamp,
                             text.inf.id_on(f"<@{ban.mod}>", ban.reason, ban.id, show_evidence(ban.evidence)),
-                        )
+                        ),
                     )
                 else:
                     out.append(
-                        (ban.timestamp, text.inf.id_off(f"<@{ban.mod}>", ban.reason, show_evidence(ban.evidence)))
+                        (ban.timestamp, text.inf.id_off(f"<@{ban.mod}>", ban.reason, show_evidence(ban.evidence))),
                     )
             else:
                 if show_ids:
@@ -431,16 +434,16 @@ async def handle_get_userlog_entries(self, user_id: int, show_ids: bool) -> list
                                 ban.id,
                                 show_evidence(ban.evidence),
                             ),
-                        )
+                        ),
                     )
                 else:
                     out.append(
                         (
                             ban.timestamp,
                             text.temp.id_off(
-                                f"<@{ban.mod}>", time_to_units(ban.minutes), ban.reason, show_evidence(ban.evidence)
+                                f"<@{ban.mod}>", time_to_units(ban.minutes), ban.reason, show_evidence(ban.evidence),
                             ),
-                        )
+                        ),
                     )
 
             if not ban.active and not ban.updated:
@@ -547,7 +550,7 @@ async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         server_embed.set_author(name=str(user), icon_url=user.avatar_url)
         await reply(ctx, embed=server_embed)
         await send_to_changelog_mod(
-            ctx.guild, ctx.message, Colors.report, t.log_reported, user, reason, evidence=evidence
+            ctx.guild, ctx.message, Colors.report, t.log_reported, user, reason, evidence=evidence,
         )
 
     @commands.command()
@@ -618,7 +621,7 @@ async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
             raise CommandError(t.reason_too_long)
 
         conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_warn_edit(warn.reason, reason), color=Colors.ModTools
+            title=t.confirmation, description=t.confirm_warn_edit(warn.reason, reason), color=Colors.ModTools,
         )
 
         async with confirm(ctx, conf_embed) as (result, msg):
@@ -667,7 +670,7 @@ async def delete_warn(self, ctx: Context, warn_id: int):
             raise CommandError(tg.permission_denied)
 
         conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_warn_delete(warn.member_name, warn.id), color=Colors.ModTools
+            title=t.confirmation, description=t.confirm_warn_delete(warn.member_name, warn.id), color=Colors.ModTools,
         )
 
         async with confirm(ctx, conf_embed) as (result, msg):
@@ -847,7 +850,7 @@ async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
             raise CommandError(t.reason_too_long)
 
         conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_mute_edit.reason(mute.reason, reason), color=Colors.ModTools
+            title=t.confirmation, description=t.confirm_mute_edit.reason(mute.reason, reason), color=Colors.ModTools,
         )
 
         async with confirm(ctx, conf_embed) as (result, msg):
@@ -1006,7 +1009,7 @@ async def delete_mute(self, ctx: Context, mute_id: int):
             raise CommandError(tg.permission_denied)
 
         conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_mute_delete(mute.member_name, mute.id), color=Colors.ModTools
+            title=t.confirmation, description=t.confirm_mute_delete(mute.member_name, mute.id), color=Colors.ModTools,
         )
 
         async with confirm(ctx, conf_embed) as (result, msg):
@@ -1136,7 +1139,7 @@ async def kick(self, ctx: Context, member: Member, *, reason: str):
 
         await Kick.create(member.id, str(member), ctx.author.id, await get_mod_level(ctx.author), reason, evidence_url)
         await send_to_changelog_mod(
-            ctx.guild, ctx.message, Colors.kick, t.log_kicked, member, reason, evidence=evidence
+            ctx.guild, ctx.message, Colors.kick, t.log_kicked, member, reason, evidence=evidence,
         )
 
         user_embed = Embed(
@@ -1191,7 +1194,7 @@ async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
             raise CommandError(t.reason_too_long)
 
         conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_kick_edit(kick.reason, reason), color=Colors.ModTools
+            title=t.confirmation, description=t.confirm_kick_edit(kick.reason, reason), color=Colors.ModTools,
         )
 
         async with confirm(ctx, conf_embed) as (result, msg):
@@ -1240,7 +1243,7 @@ async def delete_kick(self, ctx: Context, kick_id: int):
             raise CommandError(tg.permission_denied)
 
         conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_kick_delete(kick.member_name, kick.id), color=Colors.ModTools
+            title=t.confirmation, description=t.confirm_kick_delete(kick.member_name, kick.id), color=Colors.ModTools,
         )
 
         async with confirm(ctx, conf_embed) as (result, msg):
@@ -1346,7 +1349,7 @@ async def ban(
                 )
             else:
                 user_embed.description = t.banned.no_evidence(
-                    ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason
+                    ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason,
                 )
             await send_to_changelog_mod(
                 ctx.guild,
@@ -1371,7 +1374,7 @@ async def ban(
             )
             if evidence:
                 user_embed.description = t.banned_inf.evidence(
-                    ctx.author.mention, ctx.guild.name, reason, t.image_link(evidence.filename, evidence_url)
+                    ctx.author.mention, ctx.guild.name, reason, t.image_link(evidence.filename, evidence_url),
                 )
             else:
                 user_embed.description = t.banned_inf.evidence(ctx.author.mention, ctx.guild.name, reason)
@@ -1427,7 +1430,7 @@ async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
             raise CommandError(t.reason_too_long)
 
         conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_ban_edit.reason(ban.reason, reason), color=Colors.ModTools
+            title=t.confirmation, description=t.confirm_ban_edit.reason(ban.reason, reason), color=Colors.ModTools,
         )
 
         async with confirm(ctx, conf_embed) as (result, msg):
@@ -1586,7 +1589,7 @@ async def delete_ban(self, ctx: Context, ban_id: int):
             raise CommandError(tg.permission_denied)
 
         conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_ban_delete(ban.member_name, ban.id), color=Colors.ModTools
+            title=t.confirmation, description=t.confirm_ban_delete(ban.member_name, ban.id), color=Colors.ModTools,
         )
 
         async with confirm(ctx, conf_embed) as (result, msg):
diff --git a/moderation/mod/models.py b/moderation/mod/models.py
index d62ab835c..76eca817e 100644
--- a/moderation/mod/models.py
+++ b/moderation/mod/models.py
@@ -95,14 +95,14 @@ class Mute(db.Base):
 
     @staticmethod
     async def create(
-            member: int,
-            member_name: str,
-            mod: int,
-            mod_level: int,
-            minutes: int,
-            reason: str,
-            evidence: Optional[str],
-            is_update: bool = False
+        member: int,
+        member_name: str,
+        mod: int,
+        mod_level: int,
+        minutes: int,
+        reason: str,
+        evidence: Optional[str],
+        is_update: bool = False,
     ) -> Mute:
         row = Mute(
             member=member,
@@ -163,12 +163,12 @@ class Kick(db.Base):
 
     @staticmethod
     async def create(
-            member: int,
-            member_name: str,
-            mod: Optional[int],
-            mod_level: Optional[int],
-            reason: Optional[str],
-            evidence: Optional[str]
+        member: int,
+        member_name: str,
+        mod: Optional[int],
+        mod_level: Optional[int],
+        reason: Optional[str],
+        evidence: Optional[str],
     ) -> Kick:
         row = Kick(
             member=member,
@@ -216,14 +216,14 @@ class Ban(db.Base):
 
     @staticmethod
     async def create(
-            member: int,
-            member_name: str,
-            mod: int,
-            mod_level: int,
-            minutes: int,
-            reason: str,
-            evidence: Optional[str],
-            is_update: bool = False
+        member: int,
+        member_name: str,
+        mod: int,
+        mod_level: int,
+        minutes: int,
+        reason: str,
+        evidence: Optional[str],
+        is_update: bool = False,
     ) -> Ban:
         row = Ban(
             member=member,

From c84a256e0fece4065247516a2fa62a67867f4839 Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Mon, 19 Jul 2021 14:53:55 +0200
Subject: [PATCH 038/120] Fixed codestyle again

---
 moderation/mod/cog.py | 68 ++++++++++++++++++++++++++++++++++---------
 1 file changed, 54 insertions(+), 14 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 0c94477ea..0415b8431 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -290,7 +290,10 @@ async def handle_get_userlog_entries(self, user_id: int, show_ids: bool) -> list
                     (
                         report.timestamp,
                         t.ulog.reported.id_on(
-                            f"<@{report.reporter}>", report.reason, report.id, show_evidence(report.evidence),
+                            f"<@{report.reporter}>",
+                            report.reason,
+                            report.id,
+                            show_evidence(report.evidence),
                         ),
                     ),
                 )
@@ -441,7 +444,10 @@ async def handle_get_userlog_entries(self, user_id: int, show_ids: bool) -> list
                         (
                             ban.timestamp,
                             text.temp.id_off(
-                                f"<@{ban.mod}>", time_to_units(ban.minutes), ban.reason, show_evidence(ban.evidence),
+                                f"<@{ban.mod}>",
+                                time_to_units(ban.minutes),
+                                ban.reason,
+                                show_evidence(ban.evidence),
                             ),
                         ),
                     )
@@ -550,7 +556,13 @@ async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         server_embed.set_author(name=str(user), icon_url=user.avatar_url)
         await reply(ctx, embed=server_embed)
         await send_to_changelog_mod(
-            ctx.guild, ctx.message, Colors.report, t.log_reported, user, reason, evidence=evidence,
+            ctx.guild,
+            ctx.message,
+            Colors.report,
+            t.log_reported,
+            user,
+            reason,
+            evidence=evidence,
         )
 
     @commands.command()
@@ -621,7 +633,9 @@ async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
             raise CommandError(t.reason_too_long)
 
         conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_warn_edit(warn.reason, reason), color=Colors.ModTools,
+            title=t.confirmation,
+            description=t.confirm_warn_edit(warn.reason, reason),
+            color=Colors.ModTools,
         )
 
         async with confirm(ctx, conf_embed) as (result, msg):
@@ -670,7 +684,9 @@ async def delete_warn(self, ctx: Context, warn_id: int):
             raise CommandError(tg.permission_denied)
 
         conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_warn_delete(warn.member_name, warn.id), color=Colors.ModTools,
+            title=t.confirmation,
+            description=t.confirm_warn_delete(warn.member_name, warn.id),
+            color=Colors.ModTools,
         )
 
         async with confirm(ctx, conf_embed) as (result, msg):
@@ -850,7 +866,9 @@ async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
             raise CommandError(t.reason_too_long)
 
         conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_mute_edit.reason(mute.reason, reason), color=Colors.ModTools,
+            title=t.confirmation,
+            description=t.confirm_mute_edit.reason(mute.reason, reason),
+            color=Colors.ModTools,
         )
 
         async with confirm(ctx, conf_embed) as (result, msg):
@@ -1009,7 +1027,9 @@ async def delete_mute(self, ctx: Context, mute_id: int):
             raise CommandError(tg.permission_denied)
 
         conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_mute_delete(mute.member_name, mute.id), color=Colors.ModTools,
+            title=t.confirmation,
+            description=t.confirm_mute_delete(mute.member_name, mute.id),
+            color=Colors.ModTools,
         )
 
         async with confirm(ctx, conf_embed) as (result, msg):
@@ -1139,7 +1159,13 @@ async def kick(self, ctx: Context, member: Member, *, reason: str):
 
         await Kick.create(member.id, str(member), ctx.author.id, await get_mod_level(ctx.author), reason, evidence_url)
         await send_to_changelog_mod(
-            ctx.guild, ctx.message, Colors.kick, t.log_kicked, member, reason, evidence=evidence,
+            ctx.guild,
+            ctx.message,
+            Colors.kick,
+            t.log_kicked,
+            member,
+            reason,
+            evidence=evidence,
         )
 
         user_embed = Embed(
@@ -1194,7 +1220,9 @@ async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
             raise CommandError(t.reason_too_long)
 
         conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_kick_edit(kick.reason, reason), color=Colors.ModTools,
+            title=t.confirmation,
+            description=t.confirm_kick_edit(kick.reason, reason),
+            color=Colors.ModTools,
         )
 
         async with confirm(ctx, conf_embed) as (result, msg):
@@ -1243,7 +1271,9 @@ async def delete_kick(self, ctx: Context, kick_id: int):
             raise CommandError(tg.permission_denied)
 
         conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_kick_delete(kick.member_name, kick.id), color=Colors.ModTools,
+            title=t.confirmation,
+            description=t.confirm_kick_delete(kick.member_name, kick.id),
+            color=Colors.ModTools,
         )
 
         async with confirm(ctx, conf_embed) as (result, msg):
@@ -1349,7 +1379,10 @@ async def ban(
                 )
             else:
                 user_embed.description = t.banned.no_evidence(
-                    ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason,
+                    ctx.author.mention,
+                    ctx.guild.name,
+                    time_to_units(minutes),
+                    reason,
                 )
             await send_to_changelog_mod(
                 ctx.guild,
@@ -1374,7 +1407,10 @@ async def ban(
             )
             if evidence:
                 user_embed.description = t.banned_inf.evidence(
-                    ctx.author.mention, ctx.guild.name, reason, t.image_link(evidence.filename, evidence_url),
+                    ctx.author.mention,
+                    ctx.guild.name,
+                    reason,
+                    t.image_link(evidence.filename, evidence_url),
                 )
             else:
                 user_embed.description = t.banned_inf.evidence(ctx.author.mention, ctx.guild.name, reason)
@@ -1430,7 +1466,9 @@ async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
             raise CommandError(t.reason_too_long)
 
         conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_ban_edit.reason(ban.reason, reason), color=Colors.ModTools,
+            title=t.confirmation,
+            description=t.confirm_ban_edit.reason(ban.reason, reason),
+            color=Colors.ModTools,
         )
 
         async with confirm(ctx, conf_embed) as (result, msg):
@@ -1589,7 +1627,9 @@ async def delete_ban(self, ctx: Context, ban_id: int):
             raise CommandError(tg.permission_denied)
 
         conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_ban_delete(ban.member_name, ban.id), color=Colors.ModTools,
+            title=t.confirmation,
+            description=t.confirm_ban_delete(ban.member_name, ban.id),
+            color=Colors.ModTools,
         )
 
         async with confirm(ctx, conf_embed) as (result, msg):

From af854785f15be16533742d3950bd553ec758be95 Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Mon, 19 Jul 2021 14:58:05 +0200
Subject: [PATCH 039/120] Fixed linter again

---
 moderation/mod/cog.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 0415b8431..5ea5a90cf 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -87,7 +87,7 @@ def convert(years: int, months: int, weeks: int, days: int, hours: int, minutes:
 
 def time_to_units(minutes: Union[int, float]) -> str:
     rd = relativedelta(
-        datetime.fromtimestamp(0) + timedelta(minutes=minutes), datetime.fromtimestamp(0)
+        datetime.fromtimestamp(0) + timedelta(minutes=minutes), datetime.fromtimestamp(0),
     )  # Workaround that should be improved later
 
     def generator() -> Generator:
@@ -316,8 +316,8 @@ async def handle_get_userlog_entries(self, user_id: int, show_ids: bool) -> list
                 )
             else:
                 out.append(
-                    (warn.timestamp, t.ulog.warned.id_off(f"<@{warn.mod}>", warn.reason, show_evidence(warn.evidence)))
-                ),
+                    (warn.timestamp, t.ulog.warned.id_off(f"<@{warn.mod}>", warn.reason, show_evidence(warn.evidence))),
+                )
 
         mute: Mute
         async for mute in await db.stream(filter_by(Mute, member=user_id)):

From fb069da90b59ed18987e9efe579375b4d521751b Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Mon, 19 Jul 2021 15:02:09 +0200
Subject: [PATCH 040/120] Fixed codestyle and linter again

---
 moderation/mod/cog.py    | 3 ++-
 moderation/mod/models.py | 7 ++++++-
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 5ea5a90cf..4433f5b51 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -87,7 +87,8 @@ def convert(years: int, months: int, weeks: int, days: int, hours: int, minutes:
 
 def time_to_units(minutes: Union[int, float]) -> str:
     rd = relativedelta(
-        datetime.fromtimestamp(0) + timedelta(minutes=minutes), datetime.fromtimestamp(0),
+        datetime.fromtimestamp(0) + timedelta(minutes=minutes),
+        datetime.fromtimestamp(0),
     )  # Workaround that should be improved later
 
     def generator() -> Generator:
diff --git a/moderation/mod/models.py b/moderation/mod/models.py
index 76eca817e..781563922 100644
--- a/moderation/mod/models.py
+++ b/moderation/mod/models.py
@@ -47,7 +47,12 @@ class Warn(db.Base):
 
     @staticmethod
     async def create(
-        member: int, member_name: str, mod: int, mod_level: int, reason: str, evidence: Optional[str]
+        member: int,
+        member_name: str,
+        mod: int,
+        mod_level: int,
+        reason: str,
+        evidence: Optional[str],
     ) -> Warn:
         row = Warn(
             member=member,

From 85afe318f147d9960697b08d5daaa223637c2228 Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Mon, 19 Jul 2021 15:07:12 +0200
Subject: [PATCH 041/120] Fixed documentation linter

---
 moderation/mod/documentation.md | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/moderation/mod/documentation.md b/moderation/mod/documentation.md
index 621944f1c..81931324b 100644
--- a/moderation/mod/documentation.md
+++ b/moderation/mod/documentation.md
@@ -2,6 +2,7 @@
 
 This cog contains commands for server moderation purposes.
 
+
 ## `send_delete_message`
 
 The .send_delete_message command can be used to configure whether to send a warn/mute/kick/ban deletion message to the concerned user.
@@ -10,6 +11,7 @@ The .send_delete_message command can be used to configure whether to send a warn
 |:------:|:------:|:----------|
 |`send`|:heavy_check_mark:|Whether to send a deletion message or not|
 
+
 ## `report`
 
 The .report command can be used to report misbehaviour of other server members.
@@ -25,6 +27,7 @@ The .report command can be used to report misbehaviour of other server members.
 
 The reason cannot be longer than 900 characters.
 
+
 ## `warn`
 
 The .warn command can be used to warn a member because of his misbehaviour.
@@ -58,6 +61,7 @@ You can obtain the warn id from a users user log.
 The reason cannot be longer than 900 characters.
 To perform these changes, you need to be the moderator who created the original warn, have a higher moderation level or be the server owner.
 
+
 ## `delete_warn`
 
 The .delete_warn command can be used to delete warns from the database.
@@ -73,6 +77,7 @@ The .delete_warn command can be used to delete warns from the database.
 You can obtain the warn id from a users user log.
 To perform these changes, you need to be the moderator who created the original warn, have a higher moderation level or be the server owner.
 
+
 ## `mute`
 
 The .mute command can be used to give a member a formerly configured mute role.
@@ -91,10 +96,12 @@ The time must be provided as `[years]y[months]m[weeks]w[days]d[hours]h[minutes]n
 Set the duration to `inf` to mute a user permanently.
 The reason cannot be longer than 900 characters.
 
+
 ## `edit_mute`
 
 The edit_mute command can be used to edit a mute. There are two subcommands:
 
+
 ### `reason`
 
 You can edit a mute reason by using:
@@ -112,6 +119,7 @@ You can obtain the mute id from a users user log.
 To perform these changes, you need to be the moderator who created the original mute, have a higher moderation level or be the server owner.
 The reason cannot be longer than 900 characters.
 
+
 ### `duration`
 
 You can edit a mute duration by using:
@@ -129,6 +137,7 @@ The time format required is the same as before.
 To perform these changes, you need to be the moderator who created the original mute, have a higher moderation level or be the server owner.
 You can only edit the duration of active mutes.
 
+
 ## `delete_mute`
 
 The .delete_mute command can be used to delete a mute from the database.
@@ -145,6 +154,7 @@ You can obtain a mute id from a users user log.
 To perform these changes, you need to be the moderator who created the mute, have a higher moderation level or be the server owner.
 If the mute id is linked to an active mute, the mute role will be removed from the user.
 
+
 ## `unmute`
 
 The .unmute command can be used to unmute a user.
@@ -161,6 +171,7 @@ The .unmute command can be used to unmute a user.
 To perform these changes, you need to be the moderator who created the mute, have a higher moderation level or be the server owner.
 The mute role will be removed from the user instantly.
 
+
 ## `kick`
 
 The .kick command can be used to kick a user from the server.
@@ -194,6 +205,7 @@ You can obtain the kick id from a users user log.
 The reason cannot be longer than 900 characters.
 To perform these changes, you need to be the moderator who created the original kick, have a higher moderation level or be the server owner.
 
+
 ## `delete_kick`
 
 The .delete_kick command can be used to delete warns from the database.
@@ -209,6 +221,7 @@ The .delete_kick command can be used to delete warns from the database.
 You can obtain the kick id from a users user log.
 To perform these changes, you need to be the moderator who created the original kick, have a higher moderation level or be the server owner.
 
+
 ## `ban`
 
 The .ban command can be used to ban a user from the server.
@@ -229,10 +242,12 @@ Set the duration to `inf` to ban a user permanently.
 The amount of delete days must be between zero and seven.
 The reason cannot be longer than 900 characters.
 
+
 ## `edit_ban`
 
 The .edit_ban command can be used to edit a ban. There are two subcommands:
 
+
 ### `reason`
 
 You can edit a ban reason by using:
@@ -250,6 +265,7 @@ You can obtain the ban id from a users user log.
 To perform these changes, you need to be the moderator who created the original ban, have a higher moderation level or be the server owner.
 The reason cannot be longer than 900 characters.
 
+
 ### `duration`
 
 You can edit a ban duration by using:
@@ -267,6 +283,7 @@ The time format required is the same as before.
 To perform these changes, you need to be the moderator who created the original ban, have a higher moderation level or be the server owner.
 You can only edit the duration of active bans.
 
+
 ## `delete_ban`
 
 The .delete_ban command can be used to delete a ban from the database.
@@ -283,6 +300,7 @@ You can obtain a ban id from a users user log.
 To perform these changes, you need to be the moderator who created the ban, have a higher moderation level or be the server owner.
 If the ban id is linked to an active ban, the user will be unbanned.
 
+
 ## `unban`
 
 The .unban command can be used to unban a user.

From b858edff014af46a593cd3821814dba66b60ed74 Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Mon, 19 Jul 2021 21:30:51 +0200
Subject: [PATCH 042/120] Fixed issue #83: reports will be send to alert
 channel instead of changelog channel

---
 moderation/mod/cog.py              | 30 ++++++++++++++++++++++--------
 moderation/mod/translations/en.yml |  2 +-
 2 files changed, 23 insertions(+), 9 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 4433f5b51..1dd54c0cc 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -16,6 +16,7 @@
     Attachment,
     AuditLogAction,
     AuditLogEntry,
+    TextChannel,
 )
 from discord.ext import commands, tasks
 from discord.ext.commands import (
@@ -556,16 +557,29 @@ async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         server_embed = Embed(title=t.report, description=t.reported_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.avatar_url)
         await reply(ctx, embed=server_embed)
-        await send_to_changelog_mod(
-            ctx.guild,
-            ctx.message,
-            Colors.report,
-            t.log_reported,
-            user,
-            reason,
-            evidence=evidence,
+
+        alert_embed = Embed(
+            title=t.report,
+            description=t.alert_report(ctx.author.mention, user.mention, reason),
+            color=Colors.report,
+            timestamp=datetime.utcnow(),
         )
 
+        if type(ctx.channel) is TextChannel:
+            alert_embed.add_field(
+                name=t.log_field.channel,
+                value=t.jump_url(ctx.channel.mention, ctx.message.jump_url),
+                inline=True,
+            )
+        if evidence:
+            alert_embed.add_field(
+                name=t.log_field.evidence,
+                value=t.image_link(evidence.filename, evidence_url),
+                inline=True,
+            )
+
+        await send_alert(self.bot.guilds[0], alert_embed)
+
     @commands.command()
     @ModPermission.warn.check
     @guild_only()
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index 89d10dc9f..39bdf5121 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -51,7 +51,7 @@ report: ":speech_balloon: Report"
 cannot_report: This member cannot be reported.
 no_self_report: You cannot report yourself.
 reported_response: "User reported successfully :white_check_mark:"
-log_reported: ":speech_balloon: Member reported"
+alert_report: "{} reported {} because of ```\n{}\n```"
 
 # warns
 warn: ":warning: Warn"

From 2b63fe183d49eb966835ed9450e32cdee2e1d89d Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Mon, 19 Jul 2021 21:44:31 +0200
Subject: [PATCH 043/120] Added permissions to mod tools documentation

---
 moderation/mod/documentation.md | 68 ++++++++++++++++++++++++++++++++-
 1 file changed, 66 insertions(+), 2 deletions(-)

diff --git a/moderation/mod/documentation.md b/moderation/mod/documentation.md
index 81931324b..3b4323843 100644
--- a/moderation/mod/documentation.md
+++ b/moderation/mod/documentation.md
@@ -5,6 +5,14 @@ This cog contains commands for server moderation purposes.
 
 ## `send_delete_message`
 
+```css
+.send_delete_message <send>
+```
+
+Required Permissions:
+
+- `modtools_write`
+
 The .send_delete_message command can be used to configure whether to send a warn/mute/kick/ban deletion message to the concerned user.
 
 |Argument|Required|Description|
@@ -36,6 +44,10 @@ The .warn command can be used to warn a member because of his misbehaviour.
 .warn <user> <reason>
 ```
 
+Required Permissions:
+
+- `warn`
+
 |Argument|Required|Description|
 |:------:|:------:|:----------|
 |`user`|:heavy_check_mark:|The user who should be warned|
@@ -52,6 +64,10 @@ The .edit_warn command can be used to edit a warns reason.
 .[edit_warn|warn_edit] <warn_id> <reason>
 ```
 
+Required Permissions:
+
+- `warn`
+
 |Argument|Required|Description|
 |:------:|:------:|:----------|
 |`user`|:heavy_check_mark:|The id of the warn whose reason should be changed|
@@ -70,6 +86,10 @@ The .delete_warn command can be used to delete warns from the database.
 .[delete_warn|warn_delete] <warn_id>
 ```
 
+Required Permissions:
+
+- `warn`
+
 |Argument|Required|Description|
 |:------:|:------:|:----------|
 |`user`|:heavy_check_mark:|The id of the warn which should be deleted|
@@ -86,6 +106,10 @@ The .mute command can be used to give a member a formerly configured mute role.
 .mute <user> <time> <reason>
 ```
 
+Required Permissions:
+
+- `mute`
+
 |Argument|Required|Description|
 |:------:|:------:|:----------|
 |`user`|:heavy_check_mark:|The user who should be warned|
@@ -99,7 +123,11 @@ The reason cannot be longer than 900 characters.
 
 ## `edit_mute`
 
-The edit_mute command can be used to edit a mute. There are two subcommands:
+The edit_mute command can be used to edit a mute. There are two subcommands.
+
+Required Permissions:
+
+- `mute`
 
 
 ### `reason`
@@ -146,6 +174,10 @@ The .delete_mute command can be used to delete a mute from the database.
 .[delete_mute|mute_delete] <mute_id>
 ```
 
+Required Permissions:
+
+- `mute`
+
 |Argument|Required|Description|
 |:------:|:------:|:----------|
 |`mute_id`|:heavy_check_mark:|The id of the mute which should be deleted|
@@ -163,6 +195,10 @@ The .unmute command can be used to unmute a user.
 .unmute <user> <reason
 ```
 
+Required Permissions:
+
+- `mute`
+
 |Argument|Required|Description|
 |:------:|:------:|:----------|
 |`user`|:heavy_check_mark:|The user who should be unmuted|
@@ -180,6 +216,10 @@ The .kick command can be used to kick a user from the server.
 .kick <user> <reason>
 ```
 
+Required Permissions:
+
+- `kick`
+
 |Argument|Required|Description|
 |:------:|:------:|:----------|
 |`user`|:heavy_check_mark:|The user who should be kicked|
@@ -196,6 +236,10 @@ The .edit_kick command can be used to edit a kick reason.
 .[edit_kick|kick_edit] <kick_id> <reason>
 ```
 
+Required Permissions:
+
+- `kick`
+
 |Argument|Required|Description|
 |:------:|:------:|:----------|
 |`kick_id`|:heavy_check_mark:|The id of the kick whose reason should be changed|
@@ -214,6 +258,10 @@ The .delete_kick command can be used to delete warns from the database.
 .[delete_kick|kick_delete] <kick_id>
 ```
 
+Required Permissions:
+
+- `kick`
+
 |Argument|Required|Description|
 |:------:|:------:|:----------|
 |`user`|:heavy_check_mark:|The id of the kick which should be deleted|
@@ -230,6 +278,10 @@ The .ban command can be used to ban a user from the server.
 .ban <user> <time> <delete_days> <reason>
 ```
 
+Required Permissions:
+
+- `ban`
+
 |Argument|Required|Description|
 |:------:|:------:|:----------|
 |`user`|:heavy_check_mark:|The user who should be banned|
@@ -245,7 +297,11 @@ The reason cannot be longer than 900 characters.
 
 ## `edit_ban`
 
-The .edit_ban command can be used to edit a ban. There are two subcommands:
+The .edit_ban command can be used to edit a ban. There are two subcommands.
+
+Required Permissions:
+
+- `ban`
 
 
 ### `reason`
@@ -292,6 +348,10 @@ The .delete_ban command can be used to delete a ban from the database.
 .[delete_ban|ban_delete] <ban_id>
 ```
 
+Required Permissions:
+
+- `ban`
+
 |Argument|Required|Description|
 |:------:|:------:|:----------|
 |`ban_id`|:heavy_check_mark:|The id of the ban which should be deleted|
@@ -309,6 +369,10 @@ The .unban command can be used to unban a user.
 .unban <user> <reason
 ```
 
+Required Permissions:
+
+- `ban`
+
 |Argument|Required|Description|
 |:------:|:------:|:----------|
 |`user`|:heavy_check_mark:|The user who should be unbanned|

From 2dbe36d6a94196a9c35fcd5c166908c3896dde8a Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Tue, 20 Jul 2021 13:45:01 +0200
Subject: [PATCH 044/120] Improved mod cog documentation

---
 moderation/mod/documentation.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/moderation/mod/documentation.md b/moderation/mod/documentation.md
index 3b4323843..dffd8eca2 100644
--- a/moderation/mod/documentation.md
+++ b/moderation/mod/documentation.md
@@ -1,4 +1,4 @@
-# Mod Tools
+# Mod tools
 
 This cog contains commands for server moderation purposes.
 
@@ -135,7 +135,7 @@ Required Permissions:
 You can edit a mute reason by using:
 
 ```css
-.[edit_mute|mute_edit] [reason|r] <mute_id> <reason>
+.edit_mute [reason|r] <mute_id> <reason>
 ```
 
 |Argument|Required|Description|
@@ -153,7 +153,7 @@ The reason cannot be longer than 900 characters.
 You can edit a mute duration by using:
 
 ```css
-.[edit_mute|mute_edit] [duration|d] <user> <time>
+.edit_mute [duration|d] <user> <time>
 ```
 
 |Argument|Required|Description|
@@ -309,7 +309,7 @@ Required Permissions:
 You can edit a ban reason by using:
 
 ```css
-.[edit_ban|ban_edit] [reason|r] <ban_id> <reason>
+.edit_ban [reason|r] <ban_id> <reason>
 ```
 
 |Argument|Required|Description|
@@ -327,7 +327,7 @@ The reason cannot be longer than 900 characters.
 You can edit a ban duration by using:
 
 ```css
-.[edit_ban|ban_edit] [duration|d] <user> <time>
+.edit_ban [duration|d] <user> <time>
 ```
 
 |Argument|Required|Description|

From e0f9c1cf7c78b9dbcff962272ac32fc74955226b Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Tue, 20 Jul 2021 20:25:03 +0200
Subject: [PATCH 045/120] Added confirmation request to reports (issue #70)

---
 moderation/mod/cog.py              | 15 +++++++++++++++
 moderation/mod/translations/en.yml | 13 +++++++------
 2 files changed, 22 insertions(+), 6 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 1dd54c0cc..32128e68c 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -546,6 +546,21 @@ async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         if user == ctx.author:
             raise UserCommandError(user, t.no_self_report)
 
+        conf_embed = Embed(
+            title=t.confirmation,
+            description=t.confirm_report(user.mention, reason),
+            color=Colors.ModTools,
+        )
+
+        async with confirm(ctx, conf_embed) as (result, msg):
+            if not result:
+                conf_embed.description += "\n\n" + t.edit_canceled
+                return
+
+            conf_embed.description += "\n\n" + t.edit_confirmed
+            if msg:
+                await msg.delete(delay=5)
+
         if attachments := ctx.message.attachments:
             evidence = attachments[0]
             evidence_url = evidence.url
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index 39bdf5121..b2db446a5 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -50,6 +50,7 @@ cannot_fetch_audit_logs: A ban initiated through the server couldn't be added to
 report: ":speech_balloon: Report"
 cannot_report: This member cannot be reported.
 no_self_report: You cannot report yourself.
+confirm_report: "Are you sure you want to report {} for ```\n{}```\n"
 reported_response: "User reported successfully :white_check_mark:"
 alert_report: "{} reported {} because of ```\n{}\n```"
 
@@ -62,7 +63,7 @@ warned:
 warned_response: "User warned successfully :white_check_mark:"
 log_warned: ":warning: Member warned"
 no_warn: No warn with this ID could be found
-confirm_warn_edit: "Are you sure you want to change this warns reason from ```\n{}\n```to```\n{}\n```?"
+confirm_warn_edit: "Are you sure you want to change this warns reason from ```\n{}\n```to```\n{}\n```"
 warn_edited: "The warn reason has been changed from ```\n{}\n```to```\n{}\n```"
 warn_edited_response: ":white_check_mark: The warn reason has been edited"
 log_warn_edited: ":warning: Warn edited"
@@ -91,8 +92,8 @@ log_unmuted: ":loud_sound: Member unmuted"
 not_muted: User is not muted.
 no_mute: No mute with this ID could be found
 confirm_mute_edit:
-  reason: "Are you sure you want to change this mutes reason from ```\n{}\n```to```\n{}\n```?"
-  duration: "Are you sure you want to change the mute duration from ```\n{}\n```to```\n{}\n```?"
+  reason: "Are you sure you want to change this mutes reason from ```\n{}\n```to```\n{}\n```"
+  duration: "Are you sure you want to change the mute duration from ```\n{}\n```to```\n{}\n```"
 mute_edited:
   reason: "The mute reason has been changed from ```\n{}\n```to```\n{}\n```"
   duration: "The mute duration has been changed from ```\n{}\n```to```\n{}\n```"
@@ -115,7 +116,7 @@ log_kicked: ":x: Member kicked"
 cannot_kick: This member cannot be kicked.
 cannot_kick_permissions: User could not be kicked because I don't have `kick_members` permission on this server.
 no_kick: No kick with this ID could be found
-confirm_kick_edit: "Are you sure you want to change this kicks reason from ```\n{}\n```to```\n{}\n```?"
+confirm_kick_edit: "Are you sure you want to change this kicks reason from ```\n{}\n```to```\n{}\n```"
 kick_edited: "The kick reason has been changed from ```\n{}\n```to```\n{}\n```"
 kick_edited_reponse: ":white_check_mark: The kick reason has been edited"
 log_kick_edited: ":x: Kick edited"
@@ -145,8 +146,8 @@ log_unbanned: ":white_check_mark: Member Unbanned"
 cannot_unban_permissions: User could not be unbanned because I don't have `ban_members` permission on this server.
 no_ban: No ban with this ID could be found
 confirm_ban_edit:
-  reason: "Are you sure you want to change this bans reason from ```\n{}\n```to```\n{}\n```?"
-  duration: "Are you sure you want to change the bans duration from ```\n{}\n```to```\n{}\n```?"
+  reason: "Are you sure you want to change this bans reason from ```\n{}\n```to```\n{}\n```"
+  duration: "Are you sure you want to change the bans duration from ```\n{}\n```to```\n{}\n```"
 ban_edited:
   reason: "The ban reason has been changed from ```\n{}\n```to```\n{}\n```"
   duration: "The ban duration has been changed from ```\n{}\n```to```\n{}\n```"

From 0d4dc500a3366380a9b43305521f1721e98d7284 Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Sun, 22 Aug 2021 12:38:47 +0200
Subject: [PATCH 046/120] Improved code style

---
 moderation/mod/cog.py              | 183 ++++++++++-------------------
 moderation/mod/translations/en.yml |  10 +-
 2 files changed, 68 insertions(+), 125 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 32128e68c..74669d752 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -1,7 +1,7 @@
 import re
 from datetime import datetime, timedelta
 from dateutil.relativedelta import relativedelta
-from typing import Optional, Union, List, Tuple, Generator
+from typing import Optional, Union, List, Tuple
 
 from discord import (
     Role,
@@ -62,48 +62,42 @@ async def convert(self, ctx, argument: str) -> Optional[int]:
         if (match := re.match(r"^(\d+y)?(\d+m)?(\d+w)?(\d+d)?(\d+h)?(\d+n)?$", argument)) is None:
             raise BadArgument(tg.invalid_duration)
 
-        minutes = ToMinutes.convert(*[ToMinutes.toint(match.group(i)) for i in range(1, 7)])
+        years, months, weeks, days, hours, minutes = [
+            0 if (value := match.group(i)) is None else int(value[:-1])
+            for i in range(1, 7)
+        ]
 
-        if minutes <= 0:
-            raise BadArgument(tg.invalid_duration)
-        if minutes >= (1 << 31):
-            raise BadArgument(t.invalid_duration_inf)
-        return minutes
-
-
-class ToMinutes:
-    @staticmethod
-    def toint(value: str) -> int:
-        return 0 if value is None else int(value[:-1])
-
-    @staticmethod
-    def convert(years: int, months: int, weeks: int, days: int, hours: int, minutes: int) -> int:
         days += years * 365
         days += months * 30
         days += weeks * 7
 
         td = timedelta(days=days, hours=hours, minutes=minutes)
-        return int(td.total_seconds() / 60)
+        duration = int(td.total_seconds() / 60)
+
+        if duration <= 0:
+            raise BadArgument(tg.invalid_duration)
+        if duration >= (1 << 31):
+            raise BadArgument(t.invalid_duration_inf)
+        return duration
 
 
 def time_to_units(minutes: Union[int, float]) -> str:
+    _keys = ("years", "months", "days", "minutes")
+
     rd = relativedelta(
         datetime.fromtimestamp(0) + timedelta(minutes=minutes),
         datetime.fromtimestamp(0),
     )  # Workaround that should be improved later
 
-    def generator() -> Generator:
-        for unit in [
-            t.times.years(cnt=rd.years),
-            t.times.months(cnt=rd.months),
-            t.times.days(cnt=rd.days),
-            t.times.hours(cnt=rd.hours),
-            t.times.minutes(cnt=rd.minutes),
-        ]:
-            if not str(unit).startswith("0"):
-                yield str(unit)
+    def get_func(key, value):
+        func = getattr(t.times, key)
+        return func(cnt=value)
 
-    return ", ".join(generator())
+    return ", ".join(
+        get_func(key, time)
+        for key in _keys
+        if (time := getattr(rd, key)) != 0
+    )
 
 
 async def get_mute_role(guild: Guild) -> Role:
@@ -114,20 +108,28 @@ async def get_mute_role(guild: Guild) -> Role:
 
 
 def show_evidence(evidence: Optional[str]) -> str:
-    if evidence:
-        return t.ulog.evidence(evidence)
-    return ""
+    return t.ulog.evidence(evidence) if evidence else ""
 
 
-async def get_mod_level(mod: Member):
-    lvl = await Config.PERMISSION_LEVELS.get_permission_level(mod)
-    return lvl.level
+async def get_mod_level(mod: Member) -> int:
+    return (await Config.PERMISSION_LEVELS.get_permission_level(mod)).level
 
 
 async def compare_mod_level(mod: Member, mod_level: int) -> bool:
     return await get_mod_level(mod) > mod_level or mod == mod.guild.owner
 
 
+async def get_and_compare_entry(entry_format: db.Base, entry_id: int, mod: Member):
+    entry = await db.get(Warn, id=entry_id)
+    if entry is None:
+        raise CommandError(getattr(t.not_found, entry_format.__tablename__))
+
+    if not await compare_mod_level(mod, entry.mod_level) or not mod.id == entry.mod:
+        raise CommandError(tg.permission_denied)
+
+    return entry
+
+
 async def send_to_changelog_mod(
     guild: Guild,
     message: Optional[Message],
@@ -561,12 +563,9 @@ async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
             if msg:
                 await msg.delete(delay=5)
 
-        if attachments := ctx.message.attachments:
-            evidence = attachments[0]
-            evidence_url = evidence.url
-        else:
-            evidence = None
-            evidence_url = None
+        attachments = ctx.message.attachments
+        evidence = attachments[0] if attachments else None
+        evidence_url = evidence.url if attachments else None
 
         await Report.create(user.id, str(user), ctx.author.id, reason, evidence_url)
         server_embed = Embed(title=t.report, description=t.reported_response, colour=Colors.ModTools)
@@ -611,12 +610,9 @@ async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         if user == self.bot.user:
             raise UserCommandError(user, t.cannot_warn)
 
-        if attachments := ctx.message.attachments:
-            evidence = attachments[0]
-            evidence_url = evidence.url
-        else:
-            evidence = None
-            evidence_url = None
+        attachments = ctx.message.attachments
+        evidence = attachments[0] if attachments else None
+        evidence_url = evidence.url if attachments else None
 
         user_embed = Embed(
             title=t.warn,
@@ -639,7 +635,7 @@ async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         except (Forbidden, HTTPException):
             server_embed.description = t.no_dm + "\n\n" + server_embed.description
             server_embed.colour = Colors.error
-        await Warn.create(user.id, str(user), ctx.author.id, await get_mod_level(ctx.author), reason, evidence.url)
+        await Warn.create(user.id, str(user), ctx.author.id, await get_mod_level(ctx.author), reason, evidence_url)
         await reply(ctx, embed=server_embed)
         await send_to_changelog_mod(ctx.guild, ctx.message, Colors.warn, t.log_warned, user, reason, evidence=evidence)
 
@@ -652,12 +648,7 @@ async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
         get the warn id from the users user log
         """
 
-        warn = await db.get(Warn, id=warn_id)
-        if warn is None:
-            raise CommandError(t.no_warn)
-
-        if not await compare_mod_level(ctx.author, warn.mod_level) or not ctx.author.id == warn.mod:
-            raise CommandError(tg.permission_denied)
+        warn = await get_and_compare_entry(Warn, warn_id, ctx.author)
 
         if len(reason) > 900:
             raise CommandError(t.reason_too_long)
@@ -706,12 +697,7 @@ async def delete_warn(self, ctx: Context, warn_id: int):
         get the warn id from the users user log
         """
 
-        warn = await db.get(Warn, id=warn_id)
-        if warn is None:
-            raise CommandError(t.no_warn)
-
-        if not await compare_mod_level(ctx.author, warn.mod_level) or not ctx.author.id == warn.mod:
-            raise CommandError(tg.permission_denied)
+        warn = await get_and_compare_entry(Warn, warn_id, ctx.author)
 
         conf_embed = Embed(
             title=t.confirmation,
@@ -781,12 +767,9 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
         if active_mutes:
             raise UserCommandError(user, t.already_muted)
 
-        if attachments := ctx.message.attachments:
-            evidence = attachments[0]
-            evidence_url = evidence.url
-        else:
-            evidence = None
-            evidence_url = None
+        attachments = ctx.message.attachments
+        evidence = attachments[0] if attachments else None
+        evidence_url = evidence.url if attachments else None
 
         user_embed = Embed(title=t.mute, colour=Colors.ModTools)
         server_embed = Embed(title=t.mute, description=t.muted_response, colour=Colors.ModTools)
@@ -885,12 +868,7 @@ async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
         get the mute id from the users user log
         """
 
-        mute = await db.get(Mute, id=mute_id)
-        if mute is None:
-            raise CommandError(t.no_mute)
-
-        if not await compare_mod_level(ctx.author, mute.mod_level) or not ctx.author.id == mute.mod:
-            raise CommandError(tg.permission_denied)
+        mute = await get_and_compare_entry(Mute, mute_id, ctx.author)
 
         if len(reason) > 900:
             raise CommandError(t.reason_too_long)
@@ -960,10 +938,7 @@ async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time
             color=Colors.ModTools,
         )
 
-        if mute.minutes == -1:
-            old_mute_minutes = t.infinity
-        else:
-            old_mute_minutes = time_to_units(mute.minutes)
+        old_mute_minutes = t.infinity if mute.minutes == -1 else time_to_units(mute.minutes)
 
         if minutes is None:
             conf_embed.description = t.confirm_mute_edit.duration(old_mute_minutes, t.infinity)
@@ -1049,12 +1024,7 @@ async def delete_mute(self, ctx: Context, mute_id: int):
         get the mute id from the users user log
         """
 
-        mute = await db.get(Mute, id=mute_id)
-        if mute is None:
-            raise CommandError(t.no_mute)
-
-        if not await compare_mod_level(ctx.author, mute.mod_level) or not ctx.author.id == mute.mod:
-            raise CommandError(tg.permission_denied)
+        mute = await get_and_compare_entry(Mute, mute_id, ctx.author)
 
         conf_embed = Embed(
             title=t.confirmation,
@@ -1180,12 +1150,9 @@ async def kick(self, ctx: Context, member: Member, *, reason: str):
         if member.top_role >= ctx.guild.me.top_role or member.id == ctx.guild.owner_id:
             raise UserCommandError(member, t.cannot_kick)
 
-        if attachments := ctx.message.attachments:
-            evidence = attachments[0]
-            evidence_url = evidence.url
-        else:
-            evidence = None
-            evidence_url = None
+        attachments = ctx.message.attachments
+        evidence = attachments[0] if attachments else None
+        evidence_url = evidence.url if attachments else None
 
         await Kick.create(member.id, str(member), ctx.author.id, await get_mod_level(ctx.author), reason, evidence_url)
         await send_to_changelog_mod(
@@ -1239,12 +1206,7 @@ async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
         get the kick id from the users user log
         """
 
-        kick = await db.get(Kick, id=kick_id)
-        if kick is None:
-            raise CommandError(t.no_kick)
-
-        if not await compare_mod_level(ctx.author, kick.mod_level) or not ctx.author.id == kick.mod:
-            raise CommandError(tg.permission_denied)
+        kick = await get_and_compare_entry(Kick, kick_id, ctx.author)
 
         if len(reason) > 900:
             raise CommandError(t.reason_too_long)
@@ -1293,12 +1255,7 @@ async def delete_kick(self, ctx: Context, kick_id: int):
         get the kick id from the users user log
         """
 
-        kick = await db.get(Kick, id=kick_id)
-        if kick is None:
-            raise CommandError(t.no_kick)
-
-        if not await compare_mod_level(ctx.author, kick.mod_level) or not ctx.author.id == kick.mod:
-            raise CommandError(tg.permission_denied)
+        kick = await get_and_compare_entry(Kick, kick_id, ctx.author)
 
         conf_embed = Embed(
             title=t.confirmation,
@@ -1377,12 +1334,9 @@ async def ban(
         if active_bans:
             raise UserCommandError(user, t.already_banned)
 
-        if attachments := ctx.message.attachments:
-            evidence = attachments[0]
-            evidence_url = evidence.url
-        else:
-            evidence = None
-            evidence_url = None
+        attachments = ctx.message.attachments
+        evidence = attachments[0] if attachments else None
+        evidence_url = evidence.url if attachments else None
 
         user_embed = Embed(title=t.ban, colour=Colors.ModTools)
         server_embed = Embed(title=t.ban, description=t.banned_response, colour=Colors.ModTools)
@@ -1485,12 +1439,7 @@ async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
         get the ban id from the users user log
         """
 
-        ban = await db.get(Ban, id=ban_id)
-        if ban is None:
-            raise CommandError(t.no_ban)
-
-        if not await compare_mod_level(ctx.author, ban.mod_level) or not ctx.author.id == ban.mod:
-            raise CommandError(tg.permission_denied)
+        ban = await get_and_compare_entry(Ban, ban_id, ctx.author)
 
         if len(reason) > 900:
             raise CommandError(t.reason_too_long)
@@ -1560,10 +1509,7 @@ async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time:
             color=Colors.ModTools,
         )
 
-        if ban.minutes == -1:
-            old_ban_minutes = t.infinity
-        else:
-            old_ban_minutes = time_to_units(ban.minutes)
+        old_ban_minutes = t.infinity if ban.minutes == -1 else time_to_units(ban.minutes)
 
         if minutes is None:
             conf_embed.description = t.confirm_ban_edit.duration(old_ban_minutes, t.infinity)
@@ -1649,12 +1595,7 @@ async def delete_ban(self, ctx: Context, ban_id: int):
         get the ban id from the users user log
         """
 
-        ban = await db.get(Ban, id=ban_id)
-        if ban is None:
-            raise CommandError(t.no_ban)
-
-        if not await compare_mod_level(ctx.author, ban.mod_level) or not ctx.author.id == ban.mod:
-            raise CommandError(tg.permission_denied)
+        ban = await get_and_compare_entry(Ban, ban_id, ctx.author)
 
         conf_embed = Embed(
             title=t.confirmation,
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index b2db446a5..4004b5670 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -31,6 +31,12 @@ log_field:
   infinity: "*Permanent*"
   evidence: ":file_cabinet: Evidence image"
 
+not_found:
+  warn: No warn with this ID could be found
+  mute: No mute with this ID could be found
+  kick: No kick with this ID could be found
+  ban: No ban with this ID could be found
+
 modtools: Mod tools
 configured_send_delete_message:
   off: "Sending a message to a user after a warn/mute/kick/ban concerning him has been set to `off`"
@@ -62,7 +68,6 @@ warned:
   no_evidence: "{} just warned you on {}:```\n{}\n```"
 warned_response: "User warned successfully :white_check_mark:"
 log_warned: ":warning: Member warned"
-no_warn: No warn with this ID could be found
 confirm_warn_edit: "Are you sure you want to change this warns reason from ```\n{}\n```to```\n{}\n```"
 warn_edited: "The warn reason has been changed from ```\n{}\n```to```\n{}\n```"
 warn_edited_response: ":white_check_mark: The warn reason has been edited"
@@ -90,7 +95,6 @@ log_unmuted_expired: "Unmuted automatically because the mute time for this user
 unmuted_response: "User unmuted successfully :white_check_mark:"
 log_unmuted: ":loud_sound: Member unmuted"
 not_muted: User is not muted.
-no_mute: No mute with this ID could be found
 confirm_mute_edit:
   reason: "Are you sure you want to change this mutes reason from ```\n{}\n```to```\n{}\n```"
   duration: "Are you sure you want to change the mute duration from ```\n{}\n```to```\n{}\n```"
@@ -115,7 +119,6 @@ kicked_response: "User kicked successfully :white_check_mark:"
 log_kicked: ":x: Member kicked"
 cannot_kick: This member cannot be kicked.
 cannot_kick_permissions: User could not be kicked because I don't have `kick_members` permission on this server.
-no_kick: No kick with this ID could be found
 confirm_kick_edit: "Are you sure you want to change this kicks reason from ```\n{}\n```to```\n{}\n```"
 kick_edited: "The kick reason has been changed from ```\n{}\n```to```\n{}\n```"
 kick_edited_reponse: ":white_check_mark: The kick reason has been edited"
@@ -144,7 +147,6 @@ not_banned: This member is not banned.
 unbanned_response: "User unbanned. :white_check_mark:"
 log_unbanned: ":white_check_mark: Member Unbanned"
 cannot_unban_permissions: User could not be unbanned because I don't have `ban_members` permission on this server.
-no_ban: No ban with this ID could be found
 confirm_ban_edit:
   reason: "Are you sure you want to change this bans reason from ```\n{}\n```to```\n{}\n```"
   duration: "Are you sure you want to change the bans duration from ```\n{}\n```to```\n{}\n```"

From cf05dc37c1111de74695da6fcacd3e2c8827ebe7 Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Sun, 22 Aug 2021 12:43:27 +0200
Subject: [PATCH 047/120] Fixed codestyle check

---
 moderation/mod/cog.py | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 74669d752..91e0888d6 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -63,9 +63,7 @@ async def convert(self, ctx, argument: str) -> Optional[int]:
             raise BadArgument(tg.invalid_duration)
 
         years, months, weeks, days, hours, minutes = [
-            0 if (value := match.group(i)) is None else int(value[:-1])
-            for i in range(1, 7)
-        ]
+            0 if (value := match.group(i)) is None else int(value[:-1]) for i in range(1, 7)]
 
         days += years * 365
         days += months * 30
@@ -93,11 +91,7 @@ def get_func(key, value):
         func = getattr(t.times, key)
         return func(cnt=value)
 
-    return ", ".join(
-        get_func(key, time)
-        for key in _keys
-        if (time := getattr(rd, key)) != 0
-    )
+    return ", ".join(get_func(key, time) for key in _keys if (time := getattr(rd, key)) != 0)
 
 
 async def get_mute_role(guild: Guild) -> Role:

From e4ede0212d8202f4ec478731b876c839a9d7c343 Mon Sep 17 00:00:00 2001
From: LoC <locrealloc@gmail.com>
Date: Sun, 22 Aug 2021 12:46:38 +0200
Subject: [PATCH 048/120] Why does codestyle hate me so much?

---
 moderation/mod/cog.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 91e0888d6..8ce56874c 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -63,7 +63,8 @@ async def convert(self, ctx, argument: str) -> Optional[int]:
             raise BadArgument(tg.invalid_duration)
 
         years, months, weeks, days, hours, minutes = [
-            0 if (value := match.group(i)) is None else int(value[:-1]) for i in range(1, 7)]
+            0 if (value := match.group(i)) is None else int(value[:-1]) for i in range(1, 7)
+        ]
 
         days += years * 365
         days += months * 30

From ef2e0120df9bea48f311829b1a5364fe7f87e098 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Fri, 22 Oct 2021 22:24:29 +0200
Subject: [PATCH 049/120] Updated mod_rewrite for pycord and fixed various bugs

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py              | 81 +++++++++++++++---------------
 moderation/mod/models.py           | 36 ++++++-------
 moderation/mod/translations/en.yml |  8 +--
 3 files changed, 64 insertions(+), 61 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 8ce56874c..d61cef6bd 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -18,6 +18,7 @@
     AuditLogEntry,
     TextChannel,
 )
+from discord.utils import utcnow
 from discord.ext import commands, tasks
 from discord.ext.commands import (
     guild_only,
@@ -81,7 +82,7 @@ async def convert(self, ctx, argument: str) -> Optional[int]:
 
 
 def time_to_units(minutes: Union[int, float]) -> str:
-    _keys = ("years", "months", "days", "minutes")
+    _keys = ("years", "months", "days", "hours", "minutes")
 
     rd = relativedelta(
         datetime.fromtimestamp(0) + timedelta(minutes=minutes),
@@ -115,7 +116,7 @@ async def compare_mod_level(mod: Member, mod_level: int) -> bool:
 
 
 async def get_and_compare_entry(entry_format: db.Base, entry_id: int, mod: Member):
-    entry = await db.get(Warn, id=entry_id)
+    entry = await db.get(entry_format, id=entry_id)
     if entry is None:
         raise CommandError(getattr(t.not_found, entry_format.__tablename__))
 
@@ -136,7 +137,7 @@ async def send_to_changelog_mod(
     duration: Optional[str] = None,
     evidence: Optional[Attachment] = None,
 ):
-    embed = Embed(title=title, colour=colour, timestamp=datetime.utcnow())
+    embed = Embed(title=title, colour=colour, timestamp=utcnow())
 
     if isinstance(member, tuple):
         member_id, member_name = member
@@ -144,13 +145,13 @@ async def send_to_changelog_mod(
     else:
         member_id: int = member.id
         member_name: str = str(member)
-        embed.set_author(name=member_name, icon_url=member.avatar_url)
+        embed.set_author(name=member_name, icon_url=member.display_avatar.url)
 
     embed.add_field(name=t.log_field.member, value=f"<@{member_id}>", inline=True)
     embed.add_field(name=t.log_field.member_id, value=str(member_id), inline=True)
 
     if message:
-        embed.set_footer(text=str(message.author), icon_url=message.author.avatar_url)
+        embed.set_footer(text=str(message.author), icon_url=message.author.display_avatar.url)
         embed.add_field(
             name=t.log_field.channel,
             value=t.jump_url(message.channel.mention, message.jump_url),
@@ -191,7 +192,7 @@ async def mod_loop(self):
         guild: Guild = self.bot.guilds[0]
 
         async for ban in await db.stream(filter_by(Ban, active=True)):
-            if ban.minutes != -1 and datetime.utcnow() >= ban.timestamp + timedelta(minutes=ban.minutes):
+            if ban.minutes != -1 and utcnow() >= ban.timestamp + timedelta(minutes=ban.minutes):
                 await Ban.deactivate(ban.id)
 
                 try:
@@ -213,7 +214,7 @@ async def mod_loop(self):
             return
 
         async for mute in await db.stream(filter_by(Mute, active=True)):
-            if mute.minutes != -1 and datetime.utcnow() >= mute.timestamp + timedelta(minutes=mute.minutes):
+            if mute.minutes != -1 and utcnow() >= mute.timestamp + timedelta(minutes=mute.minutes):
                 if member := guild.get_member(mute.member):
                     await member.remove_roles(mute_role)
                 else:
@@ -265,14 +266,14 @@ async def handle_get_user_status_entries(self, user_id: int) -> list[tuple[str,
         if (ban := await db.get(Ban, member=user_id, active=True)) is not None:
             if ban.minutes != -1:
                 expiry_date: datetime = ban.timestamp + timedelta(minutes=ban.minutes)
-                time_left = time_to_units((expiry_date - datetime.utcnow()).total_seconds() / 60 + 1)
+                time_left = time_to_units((expiry_date - utcnow()).total_seconds() / 60 + 1)
                 status = t.status_banned_time(time_to_units(ban.minutes), time_left)
             else:
                 status = t.status_banned
         elif (mute := await db.get(Mute, member=user_id, active=True)) is not None:
             if mute.minutes != -1:
                 expiry_date: datetime = mute.timestamp + timedelta(minutes=mute.minutes)
-                time_left = time_to_units((expiry_date - datetime.utcnow()).total_seconds() / 60 + 1)
+                time_left = time_to_units((expiry_date - utcnow()).total_seconds() / 60 + 1)
                 status = t.status_muted_time(time_to_units(mute.minutes), time_left)
             else:
                 status = t.status_muted
@@ -551,10 +552,10 @@ async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
 
         async with confirm(ctx, conf_embed) as (result, msg):
             if not result:
-                conf_embed.description += "\n\n" + t.edit_canceled
+                conf_embed.description += "\n\n" + t.report_canceled
                 return
 
-            conf_embed.description += "\n\n" + t.edit_confirmed
+            conf_embed.description += "\n\n" + t.report_confirmed
             if msg:
                 await msg.delete(delay=5)
 
@@ -564,14 +565,14 @@ async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
 
         await Report.create(user.id, str(user), ctx.author.id, reason, evidence_url)
         server_embed = Embed(title=t.report, description=t.reported_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.avatar_url)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
         await reply(ctx, embed=server_embed)
 
         alert_embed = Embed(
             title=t.report,
             description=t.alert_report(ctx.author.mention, user.mention, reason),
             color=Colors.report,
-            timestamp=datetime.utcnow(),
+            timestamp=utcnow(),
         )
 
         if type(ctx.channel) is TextChannel:
@@ -624,7 +625,7 @@ async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
             user_embed.description = t.warned.no_evidence(ctx.author.mention, ctx.guild.name, reason)
 
         server_embed = Embed(title=t.warn, description=t.warned_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.avatar_url)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
         try:
             await user.send(embed=user_embed)
         except (Forbidden, HTTPException):
@@ -663,8 +664,6 @@ async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
             if msg:
                 await msg.delete(delay=5)
 
-        await Warn.edit(warn_id, ctx.author.id, await get_mod_level(ctx.author), reason)
-
         user = self.bot.get_user(warn.member)
 
         user_embed = Embed(
@@ -673,7 +672,9 @@ async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
             colour=Colors.ModTools,
         )
         server_embed = Embed(title=t.warn, description=t.warn_edited_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.avatar_url)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+
+        await Warn.edit(warn_id, ctx.author.id, await get_mod_level(ctx.author), reason)
 
         try:
             await user.send(embed=user_embed)
@@ -711,9 +712,9 @@ async def delete_warn(self, ctx: Context, warn_id: int):
 
         await Warn.delete(warn_id)
 
-        user = self.bot.get_user(warn.member)
+        user = await self.bot.fetch_user(warn.member)
         server_embed = Embed(title=t.warn, description=t.warn_deleted_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.avatar_url)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
         if await ModSettings.send_delete_user_message.get():
             user_embed = Embed(
@@ -768,7 +769,7 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
 
         user_embed = Embed(title=t.mute, colour=Colors.ModTools)
         server_embed = Embed(title=t.mute, description=t.muted_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.avatar_url)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
         if minutes is not None:
             await Mute.create(
@@ -891,7 +892,7 @@ async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
             colour=Colors.ModTools,
         )
         server_embed = Embed(title=t.mute, description=t.mute_edited_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.avatar_url)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
         await Mute.edit(mute_id, ctx.author.id, await get_mod_level(ctx.author), reason)
 
@@ -957,7 +958,7 @@ async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time
             colour=Colors.ModTools,
         )
         server_embed = Embed(title=t.mute, description=t.mute_edited_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.avatar_url)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
         if minutes is not None:
             await Mute.create(
@@ -1041,15 +1042,15 @@ async def delete_mute(self, ctx: Context, mute_id: int):
         if len(active_mutes) == 1 and mute in active_mutes:
             user = ctx.guild.get_member(mute.member)
             if user is not None:
-                if (mute_role := get_mute_role(ctx.guild)) in user.roles:
+                if (mute_role := await get_mute_role(ctx.guild)) in user.roles:
                     await user.remove_roles(mute_role)
 
-        user = self.bot.get_user(mute.member)
+        user = await self.bot.fetch_user(mute.member)
 
         await Mute.delete(mute_id)
 
         server_embed = Embed(title=t.mute, description=t.mute_deleted_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.avatar_url)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
         if await ModSettings.send_delete_user_message.get():
             user_embed = Embed(
@@ -1121,7 +1122,7 @@ async def unmute(self, ctx: Context, user: UserMemberConverter, *, reason: str):
             raise UserCommandError(user, t.not_muted)
 
         server_embed = Embed(title=t.unmute, description=t.unmuted_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.avatar_url)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
         await reply(ctx, embed=server_embed)
         await send_to_changelog_mod(ctx.guild, ctx.message, Colors.unmute, t.log_unmuted, user, reason)
 
@@ -1176,10 +1177,7 @@ async def kick(self, ctx: Context, member: Member, *, reason: str):
             user_embed.description = t.kicked.no_evidence(ctx.author.mention, ctx.guild.name, reason)
 
         server_embed = Embed(title=t.kick, description=t.kicked_response, colour=Colors.ModTools)
-        server_embed.set_author(
-            name=str(member),
-            icon_url=member.avatar_url_as(format=("gif" if member.is_avatar_animated() else "png")),
-        )
+        server_embed.set_author(name=str(member), icon_url=member.display_avatar.url)
 
         try:
             await member.send(embed=user_embed)
@@ -1221,8 +1219,6 @@ async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
             if msg:
                 await msg.delete(delay=5)
 
-        await Kick.edit(kick_id, ctx.author.id, await get_mod_level(ctx.author), reason)
-
         user = self.bot.get_user(kick.member)
 
         user_embed = Embed(
@@ -1231,7 +1227,9 @@ async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
             colour=Colors.ModTools,
         )
         server_embed = Embed(title=t.kick, description=t.kick_edited_reponse, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.avatar_url)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+
+        await Kick.edit(kick_id, ctx.author.id, await get_mod_level(ctx.author), reason)
 
         try:
             await user.send(embed=user_embed)
@@ -1269,9 +1267,9 @@ async def delete_kick(self, ctx: Context, kick_id: int):
 
         await Kick.delete(kick_id)
 
-        user = self.bot.get_user(kick.member)
+        user = await self.bot.fetch_user(kick.member)
         server_embed = Embed(title=t.warn, description=t.kick_deleted_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.avatar_url)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
         if await ModSettings.send_delete_user_message.get():
             user_embed = Embed(
@@ -1335,7 +1333,7 @@ async def ban(
 
         user_embed = Embed(title=t.ban, colour=Colors.ModTools)
         server_embed = Embed(title=t.ban, description=t.banned_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.avatar_url)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
         if minutes is not None:
             await Ban.create(
@@ -1462,7 +1460,7 @@ async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
             colour=Colors.ModTools,
         )
         server_embed = Embed(title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.avatar_url)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
         await Ban.edit(ban_id, ctx.author.id, await get_mod_level(ctx.author), reason)
 
@@ -1528,7 +1526,7 @@ async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time:
             colour=Colors.ModTools,
         )
         server_embed = Embed(title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.avatar_url)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
         if minutes is not None:
             await Ban.create(
@@ -1617,12 +1615,13 @@ async def delete_ban(self, ctx: Context, ban_id: int):
                 except HTTPException:
                     pass
 
-        user = self.bot.get_user(ban.member)
+        user = await self.bot.fetch_user(ban.member)
 
         await Ban.delete(ban_id)
 
         server_embed = Embed(title=t.mute, description=t.ban_deleted_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.avatar_url)
+
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
         if await ModSettings.send_delete_user_message.get():
             user_embed = Embed(
@@ -1696,6 +1695,6 @@ async def unban(self, ctx: Context, user: UserMemberConverter, *, reason: str):
             raise UserCommandError(user, t.not_banned)
 
         server_embed = Embed(title=t.unban, description=t.unbanned_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.avatar_url)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
         await reply(ctx, embed=server_embed)
         await send_to_changelog_mod(ctx.guild, ctx.message, Colors.unban, t.log_unbanned, user, reason)
diff --git a/moderation/mod/models.py b/moderation/mod/models.py
index 781563922..db5a8066b 100644
--- a/moderation/mod/models.py
+++ b/moderation/mod/models.py
@@ -1,11 +1,13 @@
 from __future__ import annotations
 
-from datetime import datetime
 from typing import Union, Optional
+from datetime import datetime
+
+from sqlalchemy import Column, Integer, BigInteger, Text, Boolean
 
-from sqlalchemy import Column, Integer, BigInteger, DateTime, Text, Boolean
+from PyDrocsid.database import db, UTCDateTime
 
-from PyDrocsid.database import db
+from discord.utils import utcnow
 
 
 class Report(db.Base):
@@ -15,7 +17,7 @@ class Report(db.Base):
     member: Union[Column, int] = Column(BigInteger)
     member_name: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
     reporter: Union[Column, int] = Column(BigInteger)
-    timestamp: Union[Column, datetime] = Column(DateTime)
+    timestamp: Union[Column, datetime] = Column(UTCDateTime)
     reason: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
     evidence: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
 
@@ -25,7 +27,7 @@ async def create(member: int, member_name: str, reporter: int, reason: str, evid
             member=member,
             member_name=member_name,
             reporter=reporter,
-            timestamp=datetime.utcnow(),
+            timestamp=utcnow(),
             reason=reason,
             evidence=evidence,
         )
@@ -41,7 +43,7 @@ class Warn(db.Base):
     member_name: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
     mod: Union[Column, int] = Column(BigInteger)
     mod_level: Union[Column, int] = Column(Integer)
-    timestamp: Union[Column, datetime] = Column(DateTime)
+    timestamp: Union[Column, datetime] = Column(UTCDateTime)
     reason: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
     evidence: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
 
@@ -59,7 +61,7 @@ async def create(
             member_name=member_name,
             mod=mod,
             mod_level=mod_level,
-            timestamp=datetime.utcnow(),
+            timestamp=utcnow(),
             reason=reason,
             evidence=evidence,
         )
@@ -87,12 +89,12 @@ class Mute(db.Base):
     member_name: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
     mod: Union[Column, int] = Column(BigInteger)
     mod_level: Union[Column, int] = Column(Integer)
-    timestamp: Union[Column, datetime] = Column(DateTime)
+    timestamp: Union[Column, datetime] = Column(UTCDateTime)
     minutes: Union[Column, int] = Column(Integer)
     reason: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
     evidence: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
     active: Union[Column, bool] = Column(Boolean)
-    deactivation_timestamp: Union[Column, Optional[datetime]] = Column(DateTime, nullable=True)
+    deactivation_timestamp: Union[Column, Optional[datetime]] = Column(UTCDateTime, nullable=True)
     unmute_mod: Union[Column, Optional[int]] = Column(BigInteger, nullable=True)
     unmute_reason: Union[Column, Optional[str]] = Column(Text(collation="utf8mb4_bin"), nullable=True)
     updated: Union[Column, bool] = Column(Boolean, default=False)
@@ -114,7 +116,7 @@ async def create(
             member_name=member_name,
             mod=mod,
             mod_level=mod_level,
-            timestamp=datetime.utcnow(),
+            timestamp=utcnow(),
             minutes=minutes,
             reason=reason,
             evidence=evidence,
@@ -131,7 +133,7 @@ async def create(
     async def deactivate(mute_id: int, unmute_mod: int = None, reason: str = None) -> "Mute":
         row: Mute = await db.get(Mute, id=mute_id)
         row.active = False
-        row.deactivation_timestamp = datetime.utcnow()
+        row.deactivation_timestamp = utcnow()
         row.unmute_mod = unmute_mod
         row.unmute_reason = reason
         return row
@@ -162,7 +164,7 @@ class Kick(db.Base):
     member_name: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
     mod: Union[Column, int] = Column(BigInteger)
     mod_level: Union[Column, int] = Column(Integer)
-    timestamp: Union[Column, datetime] = Column(DateTime)
+    timestamp: Union[Column, datetime] = Column(UTCDateTime)
     reason: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
     evidence: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
 
@@ -180,7 +182,7 @@ async def create(
             member_name=member_name,
             mod=mod,
             mod_level=mod_level,
-            timestamp=datetime.utcnow(),
+            timestamp=utcnow(),
             reason=reason,
             evidence=evidence,
         )
@@ -208,12 +210,12 @@ class Ban(db.Base):
     member_name: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
     mod: Union[Column, int] = Column(BigInteger)
     mod_level: Union[Column, int] = Column(Integer)
-    timestamp: Union[Column, datetime] = Column(DateTime)
+    timestamp: Union[Column, datetime] = Column(UTCDateTime)
     minutes: Union[Column, int] = Column(Integer)
     reason: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
     evidence: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
     active: Union[Column, bool] = Column(Boolean)
-    deactivation_timestamp: Union[Column, Optional[datetime]] = Column(DateTime, nullable=True)
+    deactivation_timestamp: Union[Column, Optional[datetime]] = Column(UTCDateTime, nullable=True)
     unban_reason: Union[Column, Optional[str]] = Column(Text(collation="utf8mb4_bin"), nullable=True)
     unban_mod: Union[Column, Optional[int]] = Column(BigInteger, nullable=True)
     updated: Union[Column, bool] = Column(Boolean, default=False)
@@ -235,7 +237,7 @@ async def create(
             member_name=member_name,
             mod=mod,
             mod_level=mod_level,
-            timestamp=datetime.utcnow(),
+            timestamp=utcnow(),
             minutes=minutes,
             reason=reason,
             evidence=evidence,
@@ -252,7 +254,7 @@ async def create(
     async def deactivate(ban_id: int, unban_mod: int = None, unban_reason: str = None) -> Ban:
         row: Ban = await db.get(Ban, id=ban_id)
         row.active = False
-        row.deactivation_timestamp = datetime.utcnow()
+        row.deactivation_timestamp = utcnow()
         row.unban_mod = unban_mod
         row.unban_reason = unban_reason
         return row
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index 4004b5670..be284367a 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -54,6 +54,8 @@ cannot_fetch_audit_logs: A ban initiated through the server couldn't be added to
 
 # reports
 report: ":speech_balloon: Report"
+report_canceled: ":x: Report canceled"
+report_confirmed: ":white_check_mark: Report confirmed"
 cannot_report: This member cannot be reported.
 no_self_report: You cannot report yourself.
 confirm_report: "Are you sure you want to report {} for ```\n{}```\n"
@@ -69,7 +71,7 @@ warned:
 warned_response: "User warned successfully :white_check_mark:"
 log_warned: ":warning: Member warned"
 confirm_warn_edit: "Are you sure you want to change this warns reason from ```\n{}\n```to```\n{}\n```"
-warn_edited: "The warn reason has been changed from ```\n{}\n```to```\n{}\n```"
+warn_edited: "The warn reasonhas been changed from ```\n{}\n```to```\n{}\n```"
 warn_edited_response: ":white_check_mark: The warn reason has been edited"
 log_warn_edited: ":warning: Warn edited"
 confirm_warn_delete: "Are you sure you want to delete this warning for *{}*?\n`(ID: {})`"
@@ -101,7 +103,7 @@ confirm_mute_edit:
 mute_edited:
   reason: "The mute reason has been changed from ```\n{}\n```to```\n{}\n```"
   duration: "The mute duration has been changed from ```\n{}\n```to```\n{}\n```"
-mute_edited_response: ":white_check_mark: The mute reason has been edited"
+mute_edited_response: ":white_check_mark: The mute has been edited"
 log_mute_edited: ":mute: Mute edited"
 confirm_mute_delete: "Are you sure you want to delete this mute for *{}*?\n`(ID: {})`"
 mute_deleted:
@@ -153,7 +155,7 @@ confirm_ban_edit:
 ban_edited:
   reason: "The ban reason has been changed from ```\n{}\n```to```\n{}\n```"
   duration: "The ban duration has been changed from ```\n{}\n```to```\n{}\n```"
-ban_edited_response: ":white_check_mark: The ban reason has been edited"
+ban_edited_response: ":white_check_mark: The ban has been edited"
 log_ban_edited: ":no_entry: Ban edited"
 confirm_ban_delete: "Are you sure you want to delete this ban of *{}*?\n`(ID: {})`"
 ban_deleted:

From cde97364546a4e7d120083f9324f085e7aff94d1 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Sat, 23 Oct 2021 21:43:50 +0200
Subject: [PATCH 050/120] Improved code style as requested by the reviewers

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 337 ++++++++++++++----------------------------
 1 file changed, 112 insertions(+), 225 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index d61cef6bd..39cbfba3c 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -126,6 +126,23 @@ async def get_and_compare_entry(entry_format: db.Base, entry_id: int, mod: Membe
     return entry
 
 
+async def confirm_action(
+        ctx: Context,
+        embed: Embed,
+        message_confirmed: str = t.edit_confirmed,
+        message_canceled: str = t.edit_canceled
+) -> bool:
+    async with confirm(ctx, embed) as (result, msg):
+        if not result:
+            embed.description += f"\n\n{message_canceled}"
+            return result
+
+        embed.description += f"\n\n{message_confirmed}"
+        if msg:
+            await msg.delete(delay=5)
+        return result
+
+
 async def send_to_changelog_mod(
     guild: Guild,
     message: Optional[Message],
@@ -550,14 +567,8 @@ async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
             color=Colors.ModTools,
         )
 
-        async with confirm(ctx, conf_embed) as (result, msg):
-            if not result:
-                conf_embed.description += "\n\n" + t.report_canceled
-                return
-
-            conf_embed.description += "\n\n" + t.report_confirmed
-            if msg:
-                await msg.delete(delay=5)
+        if not await confirm_action(ctx, conf_embed, t.report_confirmed, t.report_canceled):
+            return
 
         attachments = ctx.message.attachments
         evidence = attachments[0] if attachments else None
@@ -629,7 +640,7 @@ async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         try:
             await user.send(embed=user_embed)
         except (Forbidden, HTTPException):
-            server_embed.description = t.no_dm + "\n\n" + server_embed.description
+            server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
             server_embed.colour = Colors.error
         await Warn.create(user.id, str(user), ctx.author.id, await get_mod_level(ctx.author), reason, evidence_url)
         await reply(ctx, embed=server_embed)
@@ -655,14 +666,8 @@ async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
             color=Colors.ModTools,
         )
 
-        async with confirm(ctx, conf_embed) as (result, msg):
-            if not result:
-                conf_embed.description += "\n\n" + t.edit_canceled
-                return
-
-            conf_embed.description += "\n\n" + t.edit_confirmed
-            if msg:
-                await msg.delete(delay=5)
+        if not await confirm_action(ctx, conf_embed):
+            return
 
         user = self.bot.get_user(warn.member)
 
@@ -679,7 +684,7 @@ async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
         try:
             await user.send(embed=user_embed)
         except (Forbidden, HTTPException):
-            server_embed.description = t.no_dm + "\n\n" + server_embed.description
+            server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
             server_embed.colour = Colors.error
         await reply(ctx, embed=server_embed)
         await send_to_changelog_mod(ctx.guild, ctx.message, Colors.warn, t.log_warn_edited, user, reason)
@@ -701,14 +706,8 @@ async def delete_warn(self, ctx: Context, warn_id: int):
             color=Colors.ModTools,
         )
 
-        async with confirm(ctx, conf_embed) as (result, msg):
-            if not result:
-                conf_embed.description += "\n\n" + t.edit_canceled
-                return
-
-            conf_embed.description += "\n\n" + t.edit_confirmed
-            if msg:
-                await msg.delete(delay=5)
+        if not await confirm_action(ctx, conf_embed):
+            return
 
         await Warn.delete(warn_id)
 
@@ -726,7 +725,7 @@ async def delete_warn(self, ctx: Context, warn_id: int):
             try:
                 await user.send(embed=user_embed)
             except (Forbidden, HTTPException):
-                server_embed.description = t.no_dm + "\n\n" + server_embed.description
+                server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
                 server_embed.colour = Colors.error
 
         await reply(ctx, embed=server_embed)
@@ -841,7 +840,7 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
         try:
             await user.send(embed=user_embed)
         except (Forbidden, HTTPException):
-            server_embed.description = t.no_dm + "\n\n" + server_embed.description
+            server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
             server_embed.colour = Colors.error
 
         await reply(ctx, embed=server_embed)
@@ -875,14 +874,8 @@ async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
             color=Colors.ModTools,
         )
 
-        async with confirm(ctx, conf_embed) as (result, msg):
-            if not result:
-                conf_embed.description += "\n\n" + t.edit_canceled
-                return
-
-            conf_embed.description += "\n\n" + t.edit_confirmed
-            if msg:
-                await msg.delete(delay=5)
+        if not await confirm_action(ctx, conf_embed):
+            return
 
         user = self.bot.get_user(mute.member)
 
@@ -899,7 +892,7 @@ async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
         try:
             await user.send(embed=user_embed)
         except (Forbidden, HTTPException):
-            server_embed.description = t.no_dm + "\n\n" + server_embed.description
+            server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
             server_embed.colour = Colors.error
         await reply(ctx, embed=server_embed)
         await send_to_changelog_mod(ctx.guild, ctx.message, Colors.mute, t.log_mute_edited, user, reason)
@@ -941,14 +934,8 @@ async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time
         else:
             conf_embed.description = t.confirm_mute_edit.duration(old_mute_minutes, time_to_units(minutes))
 
-        async with confirm(ctx, conf_embed) as (result, msg):
-            if not result:
-                conf_embed.description += "\n\n" + t.edit_canceled
-                return
-
-            conf_embed.description += "\n\n" + t.edit_confirmed
-            if msg:
-                await msg.delete(delay=5)
+        if not await confirm_action(ctx, conf_embed):
+            return
 
         for mute in active_mutes:
             await Mute.update(mute.id, ctx.author.id)
@@ -960,54 +947,34 @@ async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time
         server_embed = Embed(title=t.mute, description=t.mute_edited_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-        if minutes is not None:
-            await Mute.create(
-                user.id,
-                str(user),
-                ctx.author.id,
-                await get_mod_level(ctx.author),
-                minutes,
-                mute.reason,
-                mute.evidence,
-                True,
-            )
-            user_embed.description = t.mute_edited.duration(time_to_units(mute.minutes), time_to_units(minutes))
-            await send_to_changelog_mod(
-                ctx.guild,
-                ctx.message,
-                Colors.mute,
-                t.log_mute_edited,
-                user,
-                mute.reason,
-                duration=time_to_units(minutes),
-            )
-
-        else:
-            await Mute.create(
-                user.id,
-                str(user),
-                ctx.author.id,
-                await get_mod_level(ctx.author),
-                -1,
-                mute.reason,
-                mute.evidence,
-                True,
-            )
-            user_embed.description = t.mute_edited.duration(time_to_units(mute.minutes), t.infinity)
-            await send_to_changelog_mod(
-                ctx.guild,
-                ctx.message,
-                Colors.mute,
-                t.log_mute_edited,
-                user,
-                mute.reason,
-                duration=t.log_field.infinity,
-            )
+        await Mute.create(
+            user.id,
+            str(user),
+            ctx.author.id,
+            await get_mod_level(ctx.author),
+            -1 if minutes is None else minutes,
+            mute.reason,
+            mute.evidence,
+            True,
+        )
+        user_embed.description = t.mute_edited.duration(
+            time_to_units(mute.minutes),
+            t.infinity if minutes is None else time_to_units(minutes),
+        )
+        await send_to_changelog_mod(
+            ctx.guild,
+            ctx.message,
+            Colors.mute,
+            t.log_mute_edited,
+            user,
+            Mute.reason,
+            duration=t.log_field.infinity if minutes is None else time_to_units(minutes),
+        )
 
         try:
             await user.send(embed=user_embed)
         except (Forbidden, HTTPException):
-            server_embed.description = t.no_dm + "\n\n" + server_embed.description
+            server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
             server_embed.colour = Colors.error
         await reply(ctx, embed=server_embed)
 
@@ -1028,14 +995,8 @@ async def delete_mute(self, ctx: Context, mute_id: int):
             color=Colors.ModTools,
         )
 
-        async with confirm(ctx, conf_embed) as (result, msg):
-            if not result:
-                conf_embed.description += "\n\n" + t.edit_canceled
-                return
-
-            conf_embed.description += "\n\n" + t.edit_confirmed
-            if msg:
-                await msg.delete(delay=5)
+        if not await confirm_action(ctx, conf_embed):
+            return
 
         active_mutes: List[Mute] = await db.all(filter_by(Mute, active=True, member=mute.member))
 
@@ -1066,7 +1027,7 @@ async def delete_mute(self, ctx: Context, mute_id: int):
             try:
                 await user.send(embed=user_embed)
             except (Forbidden, HTTPException):
-                server_embed.description = t.no_dm + "\n\n" + server_embed.description
+                server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
                 server_embed.colour = Colors.error
 
         await reply(ctx, embed=server_embed)
@@ -1182,7 +1143,7 @@ async def kick(self, ctx: Context, member: Member, *, reason: str):
         try:
             await member.send(embed=user_embed)
         except (Forbidden, HTTPException):
-            server_embed.description = t.no_dm + "\n\n" + server_embed.description
+            server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
             server_embed.colour = Colors.error
 
         await member.kick(reason=reason)
@@ -1210,14 +1171,8 @@ async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
             color=Colors.ModTools,
         )
 
-        async with confirm(ctx, conf_embed) as (result, msg):
-            if not result:
-                conf_embed.description += "\n\n" + t.edit_canceled
-                return
-
-            conf_embed.description += "\n\n" + t.edit_confirmed
-            if msg:
-                await msg.delete(delay=5)
+        if not await confirm_action(ctx, conf_embed):
+            return
 
         user = self.bot.get_user(kick.member)
 
@@ -1234,7 +1189,7 @@ async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
         try:
             await user.send(embed=user_embed)
         except (Forbidden, HTTPException):
-            server_embed.description = t.no_dm + "\n\n" + server_embed.description
+            server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
             server_embed.colour = Colors.error
         await reply(ctx, embed=server_embed)
         await send_to_changelog_mod(ctx.guild, ctx.message, Colors.kick, t.log_kick_edited, user, reason)
@@ -1256,14 +1211,8 @@ async def delete_kick(self, ctx: Context, kick_id: int):
             color=Colors.ModTools,
         )
 
-        async with confirm(ctx, conf_embed) as (result, msg):
-            if not result:
-                conf_embed.description += "\n\n" + t.edit_canceled
-                return
-
-            conf_embed.description += "\n\n" + t.edit_confirmed
-            if msg:
-                await msg.delete(delay=5)
+        if not await confirm_action(ctx, conf_embed):
+            return
 
         await Kick.delete(kick_id)
 
@@ -1281,7 +1230,7 @@ async def delete_kick(self, ctx: Context, kick_id: int):
             try:
                 await user.send(embed=user_embed)
             except (Forbidden, HTTPException):
-                server_embed.description = t.no_dm + "\n\n" + server_embed.description
+                server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
                 server_embed.colour = Colors.error
 
         await reply(ctx, embed=server_embed)
@@ -1406,7 +1355,7 @@ async def ban(
         try:
             await user.send(embed=user_embed)
         except (Forbidden, HTTPException):
-            server_embed.description = t.no_dm + "\n\n" + server_embed.description
+            server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
             server_embed.colour = Colors.error
 
         await ctx.guild.ban(user, delete_message_days=delete_days, reason=reason)
@@ -1443,22 +1392,12 @@ async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
             color=Colors.ModTools,
         )
 
-        async with confirm(ctx, conf_embed) as (result, msg):
-            if not result:
-                conf_embed.description += "\n\n" + t.edit_canceled
-                return
-
-            conf_embed.description += "\n\n" + t.edit_confirmed
-            if msg:
-                await msg.delete(delay=5)
+        if not await confirm_action(ctx, conf_embed):
+            return
 
         user = self.bot.get_user(ban.member)
 
-        user_embed = Embed(
-            title=t.ban,
-            description=t.ban_edited.reason(ban.reason, reason),
-            colour=Colors.ModTools,
-        )
+        user_embed = Embed(title=t.ban,  description=t.ban_edited.reason(ban.reason, reason), colour=Colors.ModTools)
         server_embed = Embed(title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
@@ -1467,7 +1406,7 @@ async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
         try:
             await user.send(embed=user_embed)
         except (Forbidden, HTTPException):
-            server_embed.description = t.no_dm + "\n\n" + server_embed.description
+            server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
             server_embed.colour = Colors.error
         await reply(ctx, embed=server_embed)
         await send_to_changelog_mod(ctx.guild, ctx.message, Colors.ban, t.log_ban_edited, user, reason)
@@ -1497,10 +1436,7 @@ async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time:
         if ban.minutes == minutes or (ban.minutes == -1 and minutes is None):
             raise CommandError(t.already_banned)
 
-        conf_embed = Embed(
-            title=t.confirmation,
-            color=Colors.ModTools,
-        )
+        conf_embed = Embed(title=t.confirmation, color=Colors.ModTools)
 
         old_ban_minutes = t.infinity if ban.minutes == -1 else time_to_units(ban.minutes)
 
@@ -1509,73 +1445,44 @@ async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time:
         else:
             conf_embed.description = t.confirm_ban_edit.duration(old_ban_minutes, time_to_units(minutes))
 
-        async with confirm(ctx, conf_embed) as (result, msg):
-            if not result:
-                conf_embed.description += "\n\n" + t.edit_canceled
-                return
-
-            conf_embed.description += "\n\n" + t.edit_confirmed
-            if msg:
-                await msg.delete(delay=5)
+        if not await confirm_action(ctx, conf_embed):
+            return
 
         for ban in active_bans:
             await ban.update(ban.id, ctx.author.id)
 
-        user_embed = Embed(
-            title=t.ban,
-            colour=Colors.ModTools,
-        )
+        user_embed = Embed(title=t.ban, colour=Colors.ModTools)
         server_embed = Embed(title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-        if minutes is not None:
-            await Ban.create(
-                user.id,
-                str(user),
-                ctx.author.id,
-                await get_mod_level(ctx.author),
-                minutes,
-                ban.reason,
-                ban.evidence,
-                True,
-            )
-            user_embed.description = t.ban_edited.duration(time_to_units(ban.minutes), time_to_units(minutes))
-            await send_to_changelog_mod(
-                ctx.guild,
-                ctx.message,
-                Colors.mute,
-                t.log_ban_edited,
-                user,
-                ban.reason,
-                duration=time_to_units(minutes),
-            )
-
-        else:
-            await Ban.create(
-                user.id,
-                str(user),
-                ctx.author.id,
-                await get_mod_level(ctx.author),
-                -1,
-                ban.reason,
-                ban.evidence,
-                True,
-            )
-            user_embed.description = t.ban_edited.duration(time_to_units(ban.minutes), t.infinity)
-            await send_to_changelog_mod(
-                ctx.guild,
-                ctx.message,
-                Colors.mute,
-                t.log_ban_edited,
-                user,
-                ban.reason,
-                duration=t.log_field.infinity,
-            )
+        await Ban.create(
+            user.id,
+            str(user),
+            ctx.author.id,
+            await get_mod_level(ctx.author),
+            -1 if minutes is None else minutes,
+            ban.reason,
+            ban.evidence,
+            True,
+        )
+        user_embed.description = t.ban_edited.duration(
+            time_to_units(ban.minutes),
+            t.infinity if minutes is None else time_to_units(minutes),
+        )
+        await send_to_changelog_mod(
+            ctx.guild,
+            ctx.message,
+            Colors.ban,
+            t.log_ban_edited,
+            user,
+            ban.reason,
+            duration=t.log_field.infinity if minutes is None else time_to_units(minutes),
+        )
 
         try:
             await user.send(embed=user_embed)
         except (Forbidden, HTTPException):
-            server_embed.description = t.no_dm + "\n\n" + server_embed.description
+            server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
             server_embed.colour = Colors.error
         await reply(ctx, embed=server_embed)
 
@@ -1596,14 +1503,8 @@ async def delete_ban(self, ctx: Context, ban_id: int):
             color=Colors.ModTools,
         )
 
-        async with confirm(ctx, conf_embed) as (result, msg):
-            if not result:
-                conf_embed.description += "\n\n" + t.edit_canceled
-                return
-
-            conf_embed.description += "\n\n" + t.edit_confirmed
-            if msg:
-                await msg.delete(delay=5)
+        if not await confirm_action(ctx, conf_embed):
+            return
 
         active_bans: List[Ban] = await db.all(filter_by(Ban, active=True, member=ban.member))
 
@@ -1624,10 +1525,7 @@ async def delete_ban(self, ctx: Context, ban_id: int):
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
         if await ModSettings.send_delete_user_message.get():
-            user_embed = Embed(
-                title=t.ban,
-                colour=Colors.ModTools,
-            )
+            user_embed = Embed(title=t.ban, colour=Colors.ModTools)
 
             if ban.minutes == -1:
                 user_embed.description = t.ban_deleted.inf(ban.reason)
@@ -1637,31 +1535,20 @@ async def delete_ban(self, ctx: Context, ban_id: int):
             try:
                 await user.send(embed=user_embed)
             except (Forbidden, HTTPException):
-                server_embed.description = t.no_dm + "\n\n" + server_embed.description
+                server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
                 server_embed.colour = Colors.error
 
         await reply(ctx, embed=server_embed)
 
-        if ban.minutes == -1:
-            await send_to_changelog_mod(
-                ctx.guild,
-                ctx.message,
-                Colors.ban,
-                t.log_ban_deleted,
-                user,
-                ban.reason,
-                duration=t.log_field_infinity,
-            )
-        else:
-            await send_to_changelog_mod(
-                ctx.guild,
-                ctx.message,
-                Colors.ban,
-                t.log_ban_deleted,
-                user,
-                ban.reason,
-                duration=time_to_units(ban.minutes),
-            )
+        await send_to_changelog_mod(
+            ctx.guild,
+            ctx.message,
+            Colors.ban,
+            t.log_ban_deleted,
+            user,
+            ban.reason,
+            duration=t.log_field_infinity if ban.minutes == -1 else time_to_units(ban.minutes),
+        )
 
     @commands.command()
     @ModPermission.ban.check

From e64e78fc0166230cc7c700898b5a9bfcbad95b23 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Sat, 23 Oct 2021 21:50:03 +0200
Subject: [PATCH 051/120] Improved code style as requested by GitHub

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 39cbfba3c..b6671b46f 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -127,10 +127,7 @@ async def get_and_compare_entry(entry_format: db.Base, entry_id: int, mod: Membe
 
 
 async def confirm_action(
-        ctx: Context,
-        embed: Embed,
-        message_confirmed: str = t.edit_confirmed,
-        message_canceled: str = t.edit_canceled
+        ctx: Context, embed: Embed, message_confirmed: str = t.edit_confirmed, message_canceled: str = t.edit_canceled
 ) -> bool:
     async with confirm(ctx, embed) as (result, msg):
         if not result:
@@ -1397,7 +1394,7 @@ async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
 
         user = self.bot.get_user(ban.member)
 
-        user_embed = Embed(title=t.ban,  description=t.ban_edited.reason(ban.reason, reason), colour=Colors.ModTools)
+        user_embed = Embed(title=t.ban, description=t.ban_edited.reason(ban.reason, reason), colour=Colors.ModTools)
         server_embed = Embed(title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 

From fd8cff5de6a4eb81476adf967d6971b622cf017f Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Sat, 23 Oct 2021 21:52:34 +0200
Subject: [PATCH 052/120] Improved code style as requested by GitHub, again

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index b6671b46f..4f8c99d8c 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -127,7 +127,7 @@ async def get_and_compare_entry(entry_format: db.Base, entry_id: int, mod: Membe
 
 
 async def confirm_action(
-        ctx: Context, embed: Embed, message_confirmed: str = t.edit_confirmed, message_canceled: str = t.edit_canceled
+    ctx: Context, embed: Embed, message_confirmed: str = t.edit_confirmed, message_canceled: str = t.edit_canceled,
 ) -> bool:
     async with confirm(ctx, embed) as (result, msg):
         if not result:

From 0a940398f08afb12c8948224ea62f42f501c6467 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Sat, 23 Oct 2021 21:55:22 +0200
Subject: [PATCH 053/120] Improved code style as requested by GitHub, because
 this linter simply hates me

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 4f8c99d8c..e24f40ef3 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -127,7 +127,10 @@ async def get_and_compare_entry(entry_format: db.Base, entry_id: int, mod: Membe
 
 
 async def confirm_action(
-    ctx: Context, embed: Embed, message_confirmed: str = t.edit_confirmed, message_canceled: str = t.edit_canceled,
+    ctx: Context,
+    embed: Embed,
+    message_confirmed: str = t.edit_confirmed,
+    message_canceled: str = t.edit_canceled,
 ) -> bool:
     async with confirm(ctx, embed) as (result, msg):
         if not result:

From 551be3ed9bfcbe4bbcbdfa8ba39b3043b3da90fe Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Fri, 26 Nov 2021 12:48:30 +0100
Subject: [PATCH 054/120] Removed years and months as possible durations for
 mutes/bans and changed the suffix for minutes from "n" to "m"

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py              | 19 ++++++++-----------
 moderation/mod/translations/en.yml |  6 ------
 2 files changed, 8 insertions(+), 17 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index e24f40ef3..43ded3358 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -60,17 +60,14 @@ class DurationConverter(Converter):
     async def convert(self, ctx, argument: str) -> Optional[int]:
         if argument.lower() in ("inf", "perm", "permanent", "-1", "∞"):
             return None
-        if (match := re.match(r"^(\d+y)?(\d+m)?(\d+w)?(\d+d)?(\d+h)?(\d+n)?$", argument)) is None:
+        if (match := re.match(r"^(\d+w)?(\d+d)?(\d+h)?(\d+m)?$", argument)) is None:
             raise BadArgument(tg.invalid_duration)
 
-        years, months, weeks, days, hours, minutes = [
-            0 if (value := match.group(i)) is None else int(value[:-1]) for i in range(1, 7)
+        weeks, days, hours, minutes = [
+            0 if (value := match.group(i)) is None else int(value[:-1]) for i in range(1, 5)
         ]
 
-        days += years * 365
-        days += months * 30
         days += weeks * 7
-
         td = timedelta(days=days, hours=hours, minutes=minutes)
         duration = int(td.total_seconds() / 60)
 
@@ -82,7 +79,7 @@ async def convert(self, ctx, argument: str) -> Optional[int]:
 
 
 def time_to_units(minutes: Union[int, float]) -> str:
-    _keys = ("years", "months", "days", "hours", "minutes")
+    _keys = ("days", "hours", "minutes")
 
     rd = relativedelta(
         datetime.fromtimestamp(0) + timedelta(minutes=minutes),
@@ -737,7 +734,7 @@ async def delete_warn(self, ctx: Context, warn_id: int):
     async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConverter, *, reason: str):
         """
         mute a user
-        time format: `ymwdhn`
+        time format: `wdhm`
         set time to `inf` for a permanent mute
         """
 
@@ -901,7 +898,7 @@ async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
     async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time: DurationConverter):
         """
         edit a mute duration
-        time format: `ymwdhn`
+        time format: `wdhm`
         set time to `inf` for a permanent mute
         """
 
@@ -1250,7 +1247,7 @@ async def ban(
     ):
         """
         ban a user
-        time format: `ymwdhn`
+        time format: `wdhm`
         set time to `inf` for a permanent ban
         """
 
@@ -1415,7 +1412,7 @@ async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
     async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time: DurationConverter):
         """
         edit a ban duration
-        time format: `ymwdhn`
+        time format: `wdhm`
         set time to `inf` for a permanent ban
         """
 
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index be284367a..1386b29c2 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -6,12 +6,6 @@ permissions:
   modtools_write: write mod tools configuration
 
 times:
-  years:
-    one: "{cnt} year"
-    many: "{cnt} years"
-  months:
-    one: "{cnt} month"
-    many: "{cnt} months"
   days:
     one: "{cnt} day"
     many: "{cnt} days"

From 17701b77260ecd94e1431b41f823762e67a20c52 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Sat, 4 Dec 2021 08:32:37 +0100
Subject: [PATCH 055/120] Added checks for permissions

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py              | 10 +++++++++-
 moderation/mod/translations/en.yml |  1 +
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 43ded3358..a7ec99364 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -35,7 +35,7 @@
 from PyDrocsid.database import db, filter_by, db_wrapper
 from PyDrocsid.settings import RoleSettings
 from PyDrocsid.translations import t
-from PyDrocsid.util import is_teamler
+from PyDrocsid.util import is_teamler, check_role_assignable
 from PyDrocsid.config import Config
 from .colors import Colors
 from .models import Mute, Ban, Report, Warn, Kick
@@ -213,6 +213,8 @@ async def mod_loop(self):
                     await guild.unban(user := await self.bot.fetch_user(ban.member))
                 except NotFound:
                     user = ban.member, ban.member_name
+                except Forbidden:
+                    await send_alert(guild, t.cannot_unban_permissions)
 
                 await send_to_changelog_mod(
                     guild,
@@ -227,6 +229,12 @@ async def mod_loop(self):
         if mute_role is None:
             return
 
+        try:
+            check_role_assignable(mute_role)
+        except CommandError:
+            await send_alert(guild, t.cannot_assign_mute_role(mute_role, mute_role.id))
+            return
+
         async for mute in await db.stream(filter_by(Mute, active=True)):
             if mute.minutes != -1 and utcnow() >= mute.timestamp + timedelta(minutes=mute.minutes):
                 if member := guild.get_member(mute.member):
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index 1386b29c2..3570285f7 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -91,6 +91,7 @@ log_unmuted_expired: "Unmuted automatically because the mute time for this user
 unmuted_response: "User unmuted successfully :white_check_mark:"
 log_unmuted: ":loud_sound: Member unmuted"
 not_muted: User is not muted.
+cannot_assign_mute_role: Cannot manage mute role `@{}` ({})
 confirm_mute_edit:
   reason: "Are you sure you want to change this mutes reason from ```\n{}\n```to```\n{}\n```"
   duration: "Are you sure you want to change the mute duration from ```\n{}\n```to```\n{}\n```"

From c69cb43a8b9d1717a887cfaf1b8fd3f996260a7b Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Sat, 4 Dec 2021 08:51:30 +0100
Subject: [PATCH 056/120] Made reports only visible for team members

Signed-off-by: LoC <loc@locrealloc.de>
---
 information/user_info/cog.py |  4 ++--
 moderation/invites/cog.py    |  2 +-
 moderation/mediaonly/cog.py  |  2 +-
 moderation/mod/cog.py        | 43 ++++++++++++++++++------------------
 pubsub.md                    |  3 ++-
 5 files changed, 28 insertions(+), 26 deletions(-)

diff --git a/information/user_info/cog.py b/information/user_info/cog.py
index 404cba26b..f716ddbe8 100644
--- a/information/user_info/cog.py
+++ b/information/user_info/cog.py
@@ -246,7 +246,7 @@ async def userinfo(self, ctx: Context, user: Optional[Union[User, int]] = None):
 
     @commands.command(aliases=["userlog", "ulog"])
     @optional_permissions(UserInfoPermission.view_userlog)
-    async def userlogs(self, ctx: Context, user: Optional[Union[User, int]] = None):
+    async def userlogs(self, ctx: Context, user: Optional[Union[User, int]] = None, show_ids: Optional[bool] = False):
         """
         show moderation log of a user
         """
@@ -285,7 +285,7 @@ async def userlogs(self, ctx: Context, user: Optional[Union[User, int]] = None):
                 else:
                     out.append((verification.timestamp, t.ulog.verification.revoked))
 
-        responses = await get_userlog_entries(user_id, ctx.author)
+        responses = await get_userlog_entries(user_id, show_ids, ctx.author)
         for response in responses:
             out += response
 
diff --git a/moderation/invites/cog.py b/moderation/invites/cog.py
index df79baf8b..08f40aed7 100644
--- a/moderation/invites/cog.py
+++ b/moderation/invites/cog.py
@@ -88,7 +88,7 @@ class InvitesCog(Cog, name="Allowed Discord Invites"):
     CONTRIBUTORS = [Contributor.Defelo, Contributor.wolflu, Contributor.TNT2k, Contributor.Florian]
 
     @get_userlog_entries.subscribe
-    async def handle_get_ulog_entries(self, user_id: int, _):
+    async def handle_get_ulog_entries(self, user_id: int, *_):
         out = []
 
         async for log in await db.stream(filter_by(InviteLog, applicant=user_id)):  # type: InviteLog
diff --git a/moderation/mediaonly/cog.py b/moderation/mediaonly/cog.py
index e399082ea..b706b41b2 100644
--- a/moderation/mediaonly/cog.py
+++ b/moderation/mediaonly/cog.py
@@ -81,7 +81,7 @@ async def handle_can_respond_on_reaction(self, channel: TextChannel) -> bool:
         return not await db.exists(filter_by(MediaOnlyChannel, channel=channel.id))
 
     @get_userlog_entries.subscribe
-    async def handle_get_userlog_entries(self, user_id: int, _) -> list[tuple[datetime, str]]:
+    async def handle_get_userlog_entries(self, user_id: int, *_) -> list[tuple[datetime, str]]:
         out: list[tuple[datetime, str]] = []
 
         deletion: MediaOnlyDeletion
diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index a7ec99364..170d8d985 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -302,30 +302,31 @@ async def handle_get_user_status_entries(self, user_id: int) -> list[tuple[str,
         return [(t.active_sanctions, status)]
 
     @get_userlog_entries.subscribe
-    async def handle_get_userlog_entries(self, user_id: int, show_ids: bool) -> list[tuple[datetime, str]]:
+    async def handle_get_userlog_entries(self, user_id: int, show_ids: bool, author: Member) -> list[tuple[datetime, str]]:
         out: list[tuple[datetime, str]] = []
 
-        report: Report
-        async for report in await db.stream(filter_by(Report, member=user_id)):
-            if show_ids:
-                out.append(
-                    (
-                        report.timestamp,
-                        t.ulog.reported.id_on(
-                            f"<@{report.reporter}>",
-                            report.reason,
-                            report.id,
-                            show_evidence(report.evidence),
+        if await is_teamler(author):
+            report: Report
+            async for report in await db.stream(filter_by(Report, member=user_id)):
+                if show_ids:
+                    out.append(
+                        (
+                            report.timestamp,
+                            t.ulog.reported.id_on(
+                                f"<@{report.reporter}>",
+                                report.reason,
+                                report.id,
+                                show_evidence(report.evidence),
+                            ),
                         ),
-                    ),
-                )
-            else:
-                out.append(
-                    (
-                        report.timestamp,
-                        t.ulog.reported.id_off(f"<@{report.reporter}>", report.reason, show_evidence(report.evidence)),
-                    ),
-                )
+                    )
+                else:
+                    out.append(
+                        (
+                            report.timestamp,
+                            t.ulog.reported.id_off(f"<@{report.reporter}>", report.reason, show_evidence(report.evidence)),
+                        ),
+                    )
 
         warn: Warn
         async for warn in await db.stream(filter_by(Warn, member=user_id)):
diff --git a/pubsub.md b/pubsub.md
index 5c79f5754..b709a3961 100644
--- a/pubsub.md
+++ b/pubsub.md
@@ -112,7 +112,8 @@ async def get_userlog_entries(user_id: int, show_ids: bool) -> list[list[tuple[d
 Arguments:
 
 - `user_id`: The user id
-- `show_ids`: whether to put ids from moderation events into the log entry (only relevant for the mod cog)
+- `show_ids`: Whether to put ids from moderation events into the log entry (only relevant for the mod cog)
+- `author`: The member who requested the user logs (only relevant for the mod cog)
 
 Returns: A list of `(datetime, log_entry)` tuples
 

From c9ef10c88903bed7f37859eeb29db65fdf717921 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Sat, 4 Dec 2021 08:58:34 +0100
Subject: [PATCH 057/120] Adjusted ban logging for bulk bans

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 170d8d985..e6931f35c 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -507,9 +507,12 @@ async def on_member_join(self, member: Member):
     async def on_member_ban(self, guild: Guild, member: Member):
         try:
             entry: AuditLogEntry
-            async for entry in guild.audit_logs(limit=1, action=AuditLogAction.ban):
+            async for entry in guild.audit_logs(limit=100, action=AuditLogAction.ban):
                 if entry.user == self.bot.user:
-                    return
+                    continue
+
+                if member.id != entry.target.id:
+                    continue
 
                 if entry.reason:
                     await Ban.create(
@@ -536,6 +539,8 @@ async def on_member_ban(self, guild: Guild, member: Member):
                 else:
                     await send_alert(guild, t.alert_member_banned(str(entry.target), str(entry.user)))
 
+                return
+
         except Forbidden:
             raise CommandError(t.cannot_fetch_audit_logs)
 

From 55c2db5f66fee88f5b92a80ffba80bf01c3df702 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Sat, 4 Dec 2021 09:10:31 +0100
Subject: [PATCH 058/120] It's time to fight the linter again...

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index e6931f35c..55623bab1 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -63,9 +63,7 @@ async def convert(self, ctx, argument: str) -> Optional[int]:
         if (match := re.match(r"^(\d+w)?(\d+d)?(\d+h)?(\d+m)?$", argument)) is None:
             raise BadArgument(tg.invalid_duration)
 
-        weeks, days, hours, minutes = [
-            0 if (value := match.group(i)) is None else int(value[:-1]) for i in range(1, 5)
-        ]
+        weeks, days, hours, minutes = [0 if (value := match.group(i)) is None else int(value[:-1]) for i in range(1, 5)]
 
         days += weeks * 7
         td = timedelta(days=days, hours=hours, minutes=minutes)
@@ -302,7 +300,9 @@ async def handle_get_user_status_entries(self, user_id: int) -> list[tuple[str,
         return [(t.active_sanctions, status)]
 
     @get_userlog_entries.subscribe
-    async def handle_get_userlog_entries(self, user_id: int, show_ids: bool, author: Member) -> list[tuple[datetime, str]]:
+    async def handle_get_userlog_entries(
+            self, user_id: int, show_ids: bool, author: Member
+    ) -> list[tuple[datetime, str]]:
         out: list[tuple[datetime, str]] = []
 
         if await is_teamler(author):
@@ -324,7 +324,9 @@ async def handle_get_userlog_entries(self, user_id: int, show_ids: bool, author:
                     out.append(
                         (
                             report.timestamp,
-                            t.ulog.reported.id_off(f"<@{report.reporter}>", report.reason, show_evidence(report.evidence)),
+                            t.ulog.reported.id_off(
+                                f"<@{report.reporter}>", report.reason, show_evidence(report.evidence)
+                            ),
                         ),
                     )
 

From 2454c1b5c50b8cfe0f30b8b0e7a240cd176a0fce Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Sat, 4 Dec 2021 09:15:11 +0100
Subject: [PATCH 059/120] Improved code style

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 55623bab1..2fcfc01f8 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -301,7 +301,7 @@ async def handle_get_user_status_entries(self, user_id: int) -> list[tuple[str,
 
     @get_userlog_entries.subscribe
     async def handle_get_userlog_entries(
-            self, user_id: int, show_ids: bool, author: Member
+            self, user_id: int, show_ids: bool, author: Member,
     ) -> list[tuple[datetime, str]]:
         out: list[tuple[datetime, str]] = []
 
@@ -325,7 +325,7 @@ async def handle_get_userlog_entries(
                         (
                             report.timestamp,
                             t.ulog.reported.id_off(
-                                f"<@{report.reporter}>", report.reason, show_evidence(report.evidence)
+                                f"<@{report.reporter}>", report.reason, show_evidence(report.evidence),
                             ),
                         ),
                     )

From 7ada140367c555b0a121f48293819d223a8b615f Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Sat, 4 Dec 2021 09:17:35 +0100
Subject: [PATCH 060/120] Codestyle, again (what else)

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 2fcfc01f8..738075c46 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -325,7 +325,9 @@ async def handle_get_userlog_entries(
                         (
                             report.timestamp,
                             t.ulog.reported.id_off(
-                                f"<@{report.reporter}>", report.reason, show_evidence(report.evidence),
+                                f"<@{report.reporter}>",
+                                report.reason,
+                                show_evidence(report.evidence),
                             ),
                         ),
                     )

From 44eda90280f25a5bd31bd86dc58f2359ab84be4c Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Sat, 4 Dec 2021 09:19:28 +0100
Subject: [PATCH 061/120] Do you like me now?

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 738075c46..542248f0c 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -301,7 +301,10 @@ async def handle_get_user_status_entries(self, user_id: int) -> list[tuple[str,
 
     @get_userlog_entries.subscribe
     async def handle_get_userlog_entries(
-            self, user_id: int, show_ids: bool, author: Member,
+            self,
+            user_id: int,
+            show_ids: bool,
+            author: Member,
     ) -> list[tuple[datetime, str]]:
         out: list[tuple[datetime, str]] = []
 

From 76a78c31caf76ef47966284000066f15f58e2d0c Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Sat, 4 Dec 2021 09:20:58 +0100
Subject: [PATCH 062/120] No, it does not

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 542248f0c..7a767e457 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -301,10 +301,10 @@ async def handle_get_user_status_entries(self, user_id: int) -> list[tuple[str,
 
     @get_userlog_entries.subscribe
     async def handle_get_userlog_entries(
-            self,
-            user_id: int,
-            show_ids: bool,
-            author: Member,
+        self,
+        user_id: int,
+        show_ids: bool,
+        author: Member,
     ) -> list[tuple[datetime, str]]:
         out: list[tuple[datetime, str]] = []
 

From 1058538667389ba3d5c387275eb0e07fcdfe6b8f Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Mon, 13 Dec 2021 20:50:41 +0100
Subject: [PATCH 063/120] Fixed typing

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 7a767e457..83f3e476e 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -1,7 +1,7 @@
 import re
 from datetime import datetime, timedelta
 from dateutil.relativedelta import relativedelta
-from typing import Optional, Union, List, Tuple
+from typing import Optional, Union, List, Tuple, Type
 
 from discord import (
     Role,
@@ -110,7 +110,7 @@ async def compare_mod_level(mod: Member, mod_level: int) -> bool:
     return await get_mod_level(mod) > mod_level or mod == mod.guild.owner
 
 
-async def get_and_compare_entry(entry_format: db.Base, entry_id: int, mod: Member):
+async def get_and_compare_entry(entry_format: Type[db.Base], entry_id: int, mod: Member):
     entry = await db.get(entry_format, id=entry_id)
     if entry is None:
         raise CommandError(getattr(t.not_found, entry_format.__tablename__))

From b9bfa207ef20ee1a9c0769f9c4298274e12966e3 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Mon, 13 Dec 2021 20:54:01 +0100
Subject: [PATCH 064/120] Fixed permission check

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 83f3e476e..fb227fe4d 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -115,7 +115,7 @@ async def get_and_compare_entry(entry_format: Type[db.Base], entry_id: int, mod:
     if entry is None:
         raise CommandError(getattr(t.not_found, entry_format.__tablename__))
 
-    if not await compare_mod_level(mod, entry.mod_level) or not mod.id == entry.mod:
+    if mod.id != entry.mod and not await compare_mod_level(mod, entry.mod_level):
         raise CommandError(tg.permission_denied)
 
     return entry

From d4801ad04af8ab04cc38fab8bca6614cb9655a2a Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Sun, 26 Dec 2021 20:43:39 +0100
Subject: [PATCH 065/120] Removed evidence from user message

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py              | 78 +++++-------------------------
 moderation/mod/translations/en.yml | 24 +++------
 2 files changed, 17 insertions(+), 85 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index fb227fe4d..243d693b3 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -642,16 +642,8 @@ async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         user_embed = Embed(
             title=t.warn,
             colour=Colors.ModTools,
+            description=t.warned(ctx.author.mention, ctx.guild.name, reason)
         )
-        if evidence:
-            user_embed.description = t.warned.evidence(
-                ctx.author.mention,
-                ctx.guild.name,
-                reason,
-                t.image_link(evidence.filename, evidence_url),
-            )
-        else:
-            user_embed.description = t.warned.no_evidence(ctx.author.mention, ctx.guild.name, reason)
 
         server_embed = Embed(title=t.warn, description=t.warned_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
@@ -798,21 +790,8 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
                 reason,
                 evidence_url,
             )
-            if evidence:
-                user_embed.description = t.muted.evidence(
-                    ctx.author.mention,
-                    ctx.guild.name,
-                    time_to_units(minutes),
-                    reason,
-                    t.image_link(evidence.filename, evidence_url),
-                )
-            else:
-                user_embed.description = t.muted.no_evidence(
-                    ctx.author.mention,
-                    ctx.guild.name,
-                    time_to_units(minutes),
-                    reason,
-                )
+
+            user_embed.description = t.muted(ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason)
 
             await send_to_changelog_mod(
                 ctx.guild,
@@ -834,15 +813,8 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
                 reason,
                 evidence_url,
             )
-            if evidence:
-                user_embed.description = t.muted_inf.evidence(
-                    ctx.author.mention,
-                    ctx.guild.name,
-                    reason,
-                    t.image_link(evidence.filename, evidence_url),
-                )
-            else:
-                user_embed.description = t.muted_inf.no_evidence(ctx.author.mention, ctx.guild.name, reason)
+
+            user_embed.description = t.muted_inf(ctx.author.mention, ctx.guild.name, reason)
 
             await send_to_changelog_mod(
                 ctx.guild,
@@ -1143,18 +1115,9 @@ async def kick(self, ctx: Context, member: Member, *, reason: str):
         user_embed = Embed(
             title=t.kick,
             colour=Colors.ModTools,
+            description=t.kicked.no_evidence(ctx.author.mention, ctx.guild.name, reason),
         )
 
-        if evidence:
-            user_embed.description = t.kicked.evidence(
-                ctx.author.mention,
-                ctx.guild.name,
-                reason,
-                t.image_link(evidence.filename, evidence_url),
-            )
-        else:
-            user_embed.description = t.kicked.no_evidence(ctx.author.mention, ctx.guild.name, reason)
-
         server_embed = Embed(title=t.kick, description=t.kicked_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(member), icon_url=member.display_avatar.url)
 
@@ -1313,21 +1276,9 @@ async def ban(
                 evidence_url,
                 False,
             )
-            if evidence:
-                user_embed.description = t.banned.evidence(
-                    ctx.author.mention,
-                    ctx.guild.name,
-                    time_to_units(minutes),
-                    reason,
-                    t.image_link(evidence.filename, evidence_url),
-                )
-            else:
-                user_embed.description = t.banned.no_evidence(
-                    ctx.author.mention,
-                    ctx.guild.name,
-                    time_to_units(minutes),
-                    reason,
-                )
+
+            user_embed.description = t.banned(ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason)
+
             await send_to_changelog_mod(
                 ctx.guild,
                 ctx.message,
@@ -1349,15 +1300,8 @@ async def ban(
                 evidence_url,
                 False,
             )
-            if evidence:
-                user_embed.description = t.banned_inf.evidence(
-                    ctx.author.mention,
-                    ctx.guild.name,
-                    reason,
-                    t.image_link(evidence.filename, evidence_url),
-                )
-            else:
-                user_embed.description = t.banned_inf.evidence(ctx.author.mention, ctx.guild.name, reason)
+
+            user_embed.description = t.banned_inf(ctx.author.mention, ctx.guild.name, reason)
 
             await send_to_changelog_mod(
                 ctx.guild,
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index 3570285f7..c9c456d60 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -59,9 +59,7 @@ alert_report: "{} reported {} because of ```\n{}\n```"
 # warns
 warn: ":warning: Warn"
 cannot_warn: This member cannot be warned.
-warned:
-  evidence: "{} just warned you on {}:```\n{}\n```Evidence: {}"
-  no_evidence: "{} just warned you on {}:```\n{}\n```"
+warned: "{} just warned you on {}:```\n{}\n```"
 warned_response: "User warned successfully :white_check_mark:"
 log_warned: ":warning: Member warned"
 confirm_warn_edit: "Are you sure you want to change this warns reason from ```\n{}\n```to```\n{}\n```"
@@ -79,12 +77,8 @@ unmute: ":loud_sound: Mute"
 mute_role_not_set: User could not be muted because no mute role is configured.
 cannot_mute: This member cannot be muted.
 already_muted: User is already muted for the given period of time.
-muted:
-  evidence: "{} just muted you on {} for {}:```\n{}\n```Evidence: {}"
-  no_evidence: "{} just muted you on {} for {}:```\n{}\n```"
-muted_inf:
-  evidence: "{} just muted you on {}:```\n{}\n```Evidence: {}"
-  no_evidence: "{} just muted you on {}:```\n{}\n```"
+muted: "{} just muted you on {} for {}:```\n{}\n```"
+muted_inf: "{} just muted you on {}:```\n{}\n```"
 muted_response: "User muted successfully :white_check_mark:"
 log_muted: ":mute: Member muted"
 log_unmuted_expired: "Unmuted automatically because the mute time for this user has expired."
@@ -109,9 +103,7 @@ log_mute_deleted: ":loud_sound: Mute deleted"
 
 # kicks
 kick: ":x: Kick"
-kicked:
-  evidence: "{} just kicked you from {}:```\n{}\n```Evidence: {}"
-  no_evidence: "{} just kicked you from {}:```\n{}\n```"
+kicked: "{} just kicked you from {}:```\n{}\n```"
 kicked_response: "User kicked successfully :white_check_mark:"
 log_kicked: ":x: Member kicked"
 cannot_kick: This member cannot be kicked.
@@ -131,12 +123,8 @@ unban: ":white_check_mark: Ban"
 cannot_ban: This member cannot be banned.
 already_banned: This member is already banned for the given period of time.
 cannot_ban_permissions: User could not be banned because I don't have `ban_members` permission on this server.
-banned:
-  evidence: "{} just banned you from {} for {}:```\n{}\n```Evidence: {}"
-  no_evidence: "{} just banned you from {} for {}:```\n{}\n```"
-banned_inf:
-  evidence: "{} just banned you from {}:```\n{}\n```Evidence: {}"
-  no_evidence: "{} just banned you from {}:```\n{}\n```"
+banned: "{} just banned you from {} for {}:```\n{}\n```"
+banned_inf: "{} just banned you from {}:```\n{}\n```"
 banned_response: "User banned successfully :white_check_mark:"
 log_banned: ":no_entry: Member Banned"
 log_unbanned_expired: "Unbanned automatically because the ban time for this user has expired."

From dbf80667e51dfbf70af117da58597beddd823906 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Sun, 26 Dec 2021 21:12:12 +0100
Subject: [PATCH 066/120] Replaced get_user calls with fetch_user queries

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 42 ++++++++++++++++++++++++++++++++++--------
 1 file changed, 34 insertions(+), 8 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 243d693b3..b657f6b23 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -679,7 +679,10 @@ async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
         if not await confirm_action(ctx, conf_embed):
             return
 
-        user = self.bot.get_user(warn.member)
+        try:
+            user = await self.bot.fetch_user(warn.member)
+        except (NotFound, HTTPException):
+            raise CommandError(t.user_not_found)
 
         user_embed = Embed(
             title=t.warn,
@@ -721,7 +724,11 @@ async def delete_warn(self, ctx: Context, warn_id: int):
 
         await Warn.delete(warn_id)
 
-        user = await self.bot.fetch_user(warn.member)
+        try:
+            user = await self.bot.fetch_user(warn.member)
+        except (NotFound, HTTPException):
+            raise CommandError(t.user_not_found)
+
         server_embed = Embed(title=t.warn, description=t.warn_deleted_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
@@ -867,7 +874,10 @@ async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
         if not await confirm_action(ctx, conf_embed):
             return
 
-        user = self.bot.get_user(mute.member)
+        try:
+            user = await self.bot.fetch_user(mute.member)
+        except (NotFound, HTTPException):
+            raise CommandError(t.user_not_found)
 
         user_embed = Embed(
             title=t.mute,
@@ -996,7 +1006,10 @@ async def delete_mute(self, ctx: Context, mute_id: int):
                 if (mute_role := await get_mute_role(ctx.guild)) in user.roles:
                     await user.remove_roles(mute_role)
 
-        user = await self.bot.fetch_user(mute.member)
+        try:
+            user = await self.bot.fetch_user(mute.member)
+        except (NotFound, HTTPException):
+            raise CommandError(t.user_not_found)
 
         await Mute.delete(mute_id)
 
@@ -1155,7 +1168,10 @@ async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
         if not await confirm_action(ctx, conf_embed):
             return
 
-        user = self.bot.get_user(kick.member)
+        try:
+            user = await self.bot.fetch_user(kick.member)
+        except (NotFound, HTTPException):
+            raise CommandError(t.user_not_found)
 
         user_embed = Embed(
             title=t.kick,
@@ -1197,7 +1213,11 @@ async def delete_kick(self, ctx: Context, kick_id: int):
 
         await Kick.delete(kick_id)
 
-        user = await self.bot.fetch_user(kick.member)
+        try:
+            user = await self.bot.fetch_user(kick.member)
+        except (NotFound, HTTPException):
+            raise CommandError(t.user_not_found)
+
         server_embed = Embed(title=t.warn, description=t.kick_deleted_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
@@ -1357,7 +1377,10 @@ async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
         if not await confirm_action(ctx, conf_embed):
             return
 
-        user = self.bot.get_user(ban.member)
+        try:
+            user = await self.bot.fetch_user(ban.member)
+        except (NotFound, HTTPException):
+            raise CommandError(t.user_not_found)
 
         user_embed = Embed(title=t.ban, description=t.ban_edited.reason(ban.reason, reason), colour=Colors.ModTools)
         server_embed = Embed(title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools)
@@ -1478,7 +1501,10 @@ async def delete_ban(self, ctx: Context, ban_id: int):
                 except HTTPException:
                     pass
 
-        user = await self.bot.fetch_user(ban.member)
+        try:
+            user = await self.bot.fetch_user(ban.member)
+        except (NotFound, HTTPException):
+            raise CommandError(t.user_not_found)
 
         await Ban.delete(ban_id)
 

From 1a21e5e46f051d150bb659776529af44f4ced48d Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Mon, 27 Dec 2021 19:23:26 +0100
Subject: [PATCH 067/120] Added report channel to alert embed if the channel is
 a thread

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index b657f6b23..5eb190b78 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -17,6 +17,7 @@
     AuditLogAction,
     AuditLogEntry,
     TextChannel,
+    Thread,
 )
 from discord.utils import utcnow
 from discord.ext import commands, tasks
@@ -604,7 +605,7 @@ async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
             timestamp=utcnow(),
         )
 
-        if type(ctx.channel) is TextChannel:
+        if type(ctx.channel) in (Thread, TextChannel):
             alert_embed.add_field(
                 name=t.log_field.channel,
                 value=t.jump_url(ctx.channel.mention, ctx.message.jump_url),

From f2a63fe6640ceb494de14439ef87c12489d893bc Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Mon, 27 Dec 2021 19:34:35 +0100
Subject: [PATCH 068/120] Removed duplicated code

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 129 ++++++++++++++----------------------------
 1 file changed, 44 insertions(+), 85 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 5eb190b78..56c9cdbbc 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -788,53 +788,32 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
         server_embed = Embed(title=t.mute, description=t.muted_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-        if minutes is not None:
-            await Mute.create(
-                user.id,
-                str(user),
-                ctx.author.id,
-                await get_mod_level(ctx.author),
-                minutes,
-                reason,
-                evidence_url,
-            )
+        await Mute.create(
+            user.id,
+            str(user),
+            ctx.author.id,
+            await get_mod_level(ctx.author),
+            minutes if minutes is not None else -1,
+            reason,
+            evidence_url,
+        )
 
-            user_embed.description = t.muted(ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason)
+        await send_to_changelog_mod(
+            ctx.guild,
+            ctx.message,
+            Colors.mute,
+            t.log_muted,
+            user,
+            reason,
+            duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
+            evidence=evidence,
+        )
 
-            await send_to_changelog_mod(
-                ctx.guild,
-                ctx.message,
-                Colors.mute,
-                t.log_muted,
-                user,
-                reason,
-                duration=time_to_units(minutes),
-                evidence=evidence,
-            )
+        if minutes is not None:
+            user_embed.description = t.muted(ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason)
         else:
-            await Mute.create(
-                user.id,
-                str(user),
-                ctx.author.id,
-                await get_mod_level(ctx.author),
-                -1,
-                reason,
-                evidence_url,
-            )
-
             user_embed.description = t.muted_inf(ctx.author.mention, ctx.guild.name, reason)
 
-            await send_to_changelog_mod(
-                ctx.guild,
-                ctx.message,
-                Colors.mute,
-                t.log_muted,
-                user,
-                reason,
-                duration=t.log_field.infinity,
-                evidence=evidence,
-            )
-
         try:
             await user.send(embed=user_embed)
         except (Forbidden, HTTPException):
@@ -1286,55 +1265,35 @@ async def ban(
         server_embed = Embed(title=t.ban, description=t.banned_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-        if minutes is not None:
-            await Ban.create(
-                user.id,
-                str(user),
-                ctx.author.id,
-                await get_mod_level(ctx.author),
-                minutes,
-                reason,
-                evidence_url,
-                False,
-            )
+        await Ban.create(
+            user.id,
+            str(user),
+            ctx.author.id,
+            await get_mod_level(ctx.author),
+            minutes if minutes is not None else -1,
+            reason,
+            evidence_url,
+            False,
+        )
+
+        await send_to_changelog_mod(
+            ctx.guild,
+            ctx.message,
+            Colors.ban,
+            t.log_banned,
+            user,
+            reason,
+            duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
+            evidence=evidence,
+        )
+
 
+        if minutes is not None:
             user_embed.description = t.banned(ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason)
 
-            await send_to_changelog_mod(
-                ctx.guild,
-                ctx.message,
-                Colors.ban,
-                t.log_banned,
-                user,
-                reason,
-                duration=time_to_units(minutes),
-                evidence=evidence,
-            )
         else:
-            await Ban.create(
-                user.id,
-                str(user),
-                ctx.author.id,
-                await get_mod_level(ctx.author),
-                -1,
-                reason,
-                evidence_url,
-                False,
-            )
-
             user_embed.description = t.banned_inf(ctx.author.mention, ctx.guild.name, reason)
 
-            await send_to_changelog_mod(
-                ctx.guild,
-                ctx.message,
-                Colors.ban,
-                t.log_banned,
-                user,
-                reason,
-                duration=t.log_field.infinity,
-                evidence=evidence,
-            )
-
         try:
             await user.send(embed=user_embed)
         except (Forbidden, HTTPException):

From 4955e50ffb8cebe35df9dda414526870d15d4b54 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Thu, 30 Dec 2021 10:03:18 +0100
Subject: [PATCH 069/120] Added alert message if bot can not fetch audit logs

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 56c9cdbbc..300430562 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -550,7 +550,7 @@ async def on_member_ban(self, guild: Guild, member: Member):
                 return
 
         except Forbidden:
-            raise CommandError(t.cannot_fetch_audit_logs)
+            await send_alert(guild, t.cannot_fetch_audit_logs)
 
     @commands.command()
     @ModPermission.modtools_write.check

From f22f5d5e1dfe5ff80a8dc17aada11fb91ddada26 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Thu, 30 Dec 2021 10:05:52 +0100
Subject: [PATCH 070/120] Added alert message if no mute role is configured

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 300430562..9650c16dd 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -95,7 +95,7 @@ def get_func(key, value):
 async def get_mute_role(guild: Guild) -> Role:
     mute_role: Optional[Role] = guild.get_role(await RoleSettings.get("mute"))
     if mute_role is None:
-        raise CommandError(t.mute_role_not_set)
+        await send_alert(guild, t.mute_role_not_set)
     return mute_role
 
 

From b6dab465ede705f232b88cc51af8457db18a0de3 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Thu, 30 Dec 2021 10:07:35 +0100
Subject: [PATCH 071/120] Replaced a warn check with a kick check

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 9650c16dd..ba9176e7e 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -1126,7 +1126,7 @@ async def kick(self, ctx: Context, member: Member, *, reason: str):
         await reply(ctx, embed=server_embed)
 
     @commands.command(aliases=["kick_edit"])
-    @ModPermission.warn.check
+    @ModPermission.kick.check
     @guild_only()
     async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
         """

From 79bd95803a4af09eee14bbc78891bef417dfaf31 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Sat, 1 Jan 2022 16:17:33 +0100
Subject: [PATCH 072/120] Made mute/ban duration changes just editing db
 entries instead of creating update entries

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py              | 95 +++++++++++-------------------
 moderation/mod/models.py           | 32 +++++-----
 moderation/mod/translations/en.yml | 46 ++++++---------
 3 files changed, 67 insertions(+), 106 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index ba9176e7e..992925eb5 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -78,7 +78,7 @@ async def convert(self, ctx, argument: str) -> Optional[int]:
 
 
 def time_to_units(minutes: Union[int, float]) -> str:
-    _keys = ("days", "hours", "minutes")
+    _keys = ("years", "months", "days", "hours", "minutes")
 
     rd = relativedelta(
         datetime.fromtimestamp(0) + timedelta(minutes=minutes),
@@ -352,30 +352,24 @@ async def handle_get_userlog_entries(
 
         mute: Mute
         async for mute in await db.stream(filter_by(Mute, member=user_id)):
-            if mute.is_update:
-                text = t.ulog.muted.update
-                mute.evidence = None
-            else:
-                text = t.ulog.muted.first
-
             if mute.minutes == -1:
                 if show_ids:
                     out.append(
                         (
                             mute.timestamp,
-                            text.inf.id_on(f"<@{mute.mod}>", mute.reason, mute.id, show_evidence(mute.evidence)),
+                            t.ulog.muted.inf.id_on(f"<@{mute.mod}>", mute.reason, mute.id, show_evidence(mute.evidence)),
                         ),
                     )
                 else:
                     out.append(
-                        (mute.timestamp, text.inf.id_off(f"<@{mute.mod}>", mute.reason, show_evidence(mute.evidence))),
+                        (mute.timestamp, t.ulog.muted.inf.id_off(f"<@{mute.mod}>", mute.reason, show_evidence(mute.evidence))),
                     )
             else:
                 if show_ids:
                     out.append(
                         (
                             mute.timestamp,
-                            text.temp.id_on(
+                            t.ulog.muted.temp.id_on(
                                 f"<@{mute.mod}>",
                                 time_to_units(mute.minutes),
                                 mute.reason,
@@ -388,7 +382,7 @@ async def handle_get_userlog_entries(
                     out.append(
                         (
                             mute.timestamp,
-                            text.temp.id_off(
+                            t.ulog.muted.temp.id_off(
                                 f"<@{mute.mod}>",
                                 time_to_units(mute.minutes),
                                 mute.reason,
@@ -397,7 +391,7 @@ async def handle_get_userlog_entries(
                         ),
                     )
 
-            if not mute.active and not mute.updated:
+            if not mute.active:
                 if mute.unmute_mod is None:
                     out.append((mute.deactivation_timestamp, t.ulog.unmuted_expired))
                 else:
@@ -438,30 +432,24 @@ async def handle_get_userlog_entries(
 
         ban: Ban
         async for ban in await db.stream(filter_by(Ban, member=user_id)):
-            if ban.is_update:
-                text = t.ulog.banned.update
-                ban.evidence = None
-            else:
-                text = t.ulog.banned.first
-
             if ban.minutes == -1:
                 if show_ids:
                     out.append(
                         (
                             ban.timestamp,
-                            text.inf.id_on(f"<@{ban.mod}>", ban.reason, ban.id, show_evidence(ban.evidence)),
+                            t.ulog.banned.inf.id_on(f"<@{ban.mod}>", ban.reason, ban.id, show_evidence(ban.evidence)),
                         ),
                     )
                 else:
                     out.append(
-                        (ban.timestamp, text.inf.id_off(f"<@{ban.mod}>", ban.reason, show_evidence(ban.evidence))),
+                        (ban.timestamp, t.ulog.banned.inf.id_off(f"<@{ban.mod}>", ban.reason, show_evidence(ban.evidence))),
                     )
             else:
                 if show_ids:
                     out.append(
                         (
                             ban.timestamp,
-                            text.temp.id_on(
+                            t.ulog.banned.temp.id_on(
                                 f"<@{ban.mod}>",
                                 time_to_units(ban.minutes),
                                 ban.reason,
@@ -474,7 +462,7 @@ async def handle_get_userlog_entries(
                     out.append(
                         (
                             ban.timestamp,
-                            text.temp.id_off(
+                            t.ulog.banned.temp.id_off(
                                 f"<@{ban.mod}>",
                                 time_to_units(ban.minutes),
                                 ban.reason,
@@ -483,7 +471,7 @@ async def handle_get_userlog_entries(
                         ),
                     )
 
-            if not ban.active and not ban.updated:
+            if not ban.active:
                 if ban.unban_mod is None:
                     out.append((ban.deactivation_timestamp, t.ulog.unbanned_expired))
                 else:
@@ -531,7 +519,6 @@ async def on_member_ban(self, guild: Guild, member: Member):
                         -1,
                         entry.reason,
                         None,
-                        False,
                     )
 
                     await send_to_changelog_mod(
@@ -889,12 +876,15 @@ async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time
         time: Optional[int]
         minutes = time
 
-        active_mutes: List[Mute] = await db.all(filter_by(Mute, active=True, member=user.id))
+        active_mutes: List[Mute] = sorted(
+            await db.all(filter_by(Mute, active=True, member=user.id)), key=lambda active_mute: active_mute.timestamp
+        )
+
 
         if not active_mutes:
             raise CommandError(t.not_muted)
 
-        mute = sorted(active_mutes, key=lambda active_mute: active_mute.timestamp)[0]
+        mute = active_mutes[0]
 
         if not await compare_mod_level(ctx.author, mute.mod_level) or not ctx.author.id == mute.mod:
             raise CommandError(tg.permission_denied)
@@ -907,18 +897,18 @@ async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time
             color=Colors.ModTools,
         )
 
-        old_mute_minutes = t.infinity if mute.minutes == -1 else time_to_units(mute.minutes)
+        old_time = t.infinity if mute.minutes == -1 else time_to_units(mute.minutes)
 
         if minutes is None:
-            conf_embed.description = t.confirm_mute_edit.duration(old_mute_minutes, t.infinity)
+            conf_embed.description = t.confirm_mute_edit.duration(old_time, t.infinity)
         else:
-            conf_embed.description = t.confirm_mute_edit.duration(old_mute_minutes, time_to_units(minutes))
+            conf_embed.description = t.confirm_mute_edit.duration(old_time, time_to_units(minutes))
 
         if not await confirm_action(ctx, conf_embed):
             return
 
-        for mute in active_mutes:
-            await Mute.update(mute.id, ctx.author.id)
+        for active_mute in active_mutes[1:]:
+            await Mute.delete(active_mute.id)
 
         user_embed = Embed(
             title=t.mute,
@@ -927,16 +917,8 @@ async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time
         server_embed = Embed(title=t.mute, description=t.mute_edited_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-        await Mute.create(
-            user.id,
-            str(user),
-            ctx.author.id,
-            await get_mod_level(ctx.author),
-            -1 if minutes is None else minutes,
-            mute.reason,
-            mute.evidence,
-            True,
-        )
+        await Mute.edit_duration(mute.id, ctx.author.id, await get_mod_level(ctx.author), minutes)
+
         user_embed.description = t.mute_edited.duration(
             time_to_units(mute.minutes),
             t.infinity if minutes is None else time_to_units(minutes),
@@ -1273,7 +1255,6 @@ async def ban(
             minutes if minutes is not None else -1,
             reason,
             evidence_url,
-            False,
         )
 
         await send_to_changelog_mod(
@@ -1368,12 +1349,14 @@ async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time:
         time: Optional[int]
         minutes = time
 
-        active_bans: List[Mute] = await db.all(filter_by(Ban, active=True, member=user.id))
+        active_bans: List[Ban] = sorted(
+            await db.all(filter_by(Ban, active=True, member=user.id)), key=lambda active_ban: active_ban.timestamp
+        )
 
         if not active_bans:
-            raise CommandError(t.not_muted)
+            raise CommandError(t.not_banned)
 
-        ban = sorted(active_bans, key=lambda active_ban: active_ban.timestamp)[0]
+        ban = active_bans[0]
 
         if not await compare_mod_level(ctx.author, ban.mod_level) or not ctx.author.id == ban.mod:
             raise CommandError(tg.permission_denied)
@@ -1383,33 +1366,25 @@ async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time:
 
         conf_embed = Embed(title=t.confirmation, color=Colors.ModTools)
 
-        old_ban_minutes = t.infinity if ban.minutes == -1 else time_to_units(ban.minutes)
+        old_time = t.infinity if ban.minutes == -1 else time_to_units(ban.minutes)
 
         if minutes is None:
-            conf_embed.description = t.confirm_ban_edit.duration(old_ban_minutes, t.infinity)
+            conf_embed.description = t.confirm_ban_edit.duration(old_time, t.infinity)
         else:
-            conf_embed.description = t.confirm_ban_edit.duration(old_ban_minutes, time_to_units(minutes))
+            conf_embed.description = t.confirm_ban_edit.duration(old_time, time_to_units(minutes))
 
         if not await confirm_action(ctx, conf_embed):
             return
 
-        for ban in active_bans:
-            await ban.update(ban.id, ctx.author.id)
+        for ban in active_bans[1:]:
+            await Ban.delete(ban.id)
 
         user_embed = Embed(title=t.ban, colour=Colors.ModTools)
         server_embed = Embed(title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-        await Ban.create(
-            user.id,
-            str(user),
-            ctx.author.id,
-            await get_mod_level(ctx.author),
-            -1 if minutes is None else minutes,
-            ban.reason,
-            ban.evidence,
-            True,
-        )
+        await Ban.edit_duration(ban.id, ctx.author.id, await get_mod_level(ctx.author), minutes)
+
         user_embed.description = t.ban_edited.duration(
             time_to_units(ban.minutes),
             t.infinity if minutes is None else time_to_units(minutes),
diff --git a/moderation/mod/models.py b/moderation/mod/models.py
index db5a8066b..aefc0b22c 100644
--- a/moderation/mod/models.py
+++ b/moderation/mod/models.py
@@ -97,8 +97,6 @@ class Mute(db.Base):
     deactivation_timestamp: Union[Column, Optional[datetime]] = Column(UTCDateTime, nullable=True)
     unmute_mod: Union[Column, Optional[int]] = Column(BigInteger, nullable=True)
     unmute_reason: Union[Column, Optional[str]] = Column(Text(collation="utf8mb4_bin"), nullable=True)
-    updated: Union[Column, bool] = Column(Boolean, default=False)
-    is_update: Union[Column, bool] = Column(Boolean)
 
     @staticmethod
     async def create(
@@ -109,7 +107,6 @@ async def create(
         minutes: int,
         reason: str,
         evidence: Optional[str],
-        is_update: bool = False,
     ) -> Mute:
         row = Mute(
             member=member,
@@ -124,7 +121,6 @@ async def create(
             deactivation_timestamp=None,
             unmute_mod=None,
             unmute_reason=None,
-            is_update=is_update,
         )
         await db.add(row)
         return row
@@ -139,16 +135,18 @@ async def deactivate(mute_id: int, unmute_mod: int = None, reason: str = None) -
         return row
 
     @staticmethod
-    async def update(ban_id: int, mod: int):
-        mute = await Mute.deactivate(ban_id, mod)
-        mute.updated = True
+    async def edit_reason(mute_id: int, mod: int, mod_level: int, new_reason: str):
+        row = await db.get(Mute, id=mute_id)
+        row.mod = mod
+        row.mod_level = mod_level
+        row.reason = new_reason
 
     @staticmethod
-    async def edit(mute_id: int, mod: int, mod_level: int, new_reason: str):
+    async def edit_duration(mute_id: int, mod: int, mod_level: int, new_duration: int):
         row = await db.get(Mute, id=mute_id)
         row.mod = mod
         row.mod_level = mod_level
-        row.reason = new_reason
+        row.minutes = new_duration
 
     @staticmethod
     async def delete(mute_id: int):
@@ -218,8 +216,6 @@ class Ban(db.Base):
     deactivation_timestamp: Union[Column, Optional[datetime]] = Column(UTCDateTime, nullable=True)
     unban_reason: Union[Column, Optional[str]] = Column(Text(collation="utf8mb4_bin"), nullable=True)
     unban_mod: Union[Column, Optional[int]] = Column(BigInteger, nullable=True)
-    updated: Union[Column, bool] = Column(Boolean, default=False)
-    is_update: Union[Column, bool] = Column(Boolean)
 
     @staticmethod
     async def create(
@@ -230,7 +226,6 @@ async def create(
         minutes: int,
         reason: str,
         evidence: Optional[str],
-        is_update: bool = False,
     ) -> Ban:
         row = Ban(
             member=member,
@@ -245,7 +240,6 @@ async def create(
             deactivation_timestamp=None,
             unban_reason=None,
             unban_mod=None,
-            is_update=is_update,
         )
         await db.add(row)
         return row
@@ -260,16 +254,18 @@ async def deactivate(ban_id: int, unban_mod: int = None, unban_reason: str = Non
         return row
 
     @staticmethod
-    async def update(ban_id: int, mod: int):
-        ban = await Ban.deactivate(ban_id, mod)
-        ban.updated = True
+    async def edit_reason(ban_id: int, mod: int, mod_level: int, new_reason: str):
+        row = await db.get(Ban, id=ban_id)
+        row.mod = mod
+        row.mod_level = mod_level
+        row.reason = new_reason
 
     @staticmethod
-    async def edit(ban_id: int, mod: int, mod_level: int, new_reason: str):
+    async def edit_duration(ban_id: int, mod: int, mod_level: int, new_duration: int):
         row = await db.get(Ban, id=ban_id)
         row.mod = mod
         row.mod_level = mod_level
-        row.reason = new_reason
+        row.minutes = new_duration
 
     @staticmethod
     async def delete(ban_id: int):
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index c9c456d60..25e306b20 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -15,6 +15,12 @@ times:
   minutes:
     one: "{cnt} minute"
     many: "{cnt} minutes"
+  months:
+    one: "{cnt} month"
+    many: "{cnt} months"
+  years:
+    one: "{cnt} year"
+    many: "{cnt} years"
 
 log_field:
   member: ":bust_in_silhouette: Member"
@@ -178,20 +184,12 @@ ulog:
     id_on: ":warning: **Warned** by {} because of `{}`\n`(ID: {})`{}"
 
   muted:
-    first:
-      temp:
-        id_off: ":mute: **Muted** by {} for {} because of `{}`{}"
-        id_on: ":mute: **Muted** by {} for {} because of `{}`\n`(ID: {})`{}"
-      inf:
-        id_off: ":mute: **Muted** permanently by {} because of `{}`{}"
-        id_on: ":mute: **Muted** permanently by {} because of `{}`\n`(ID: {})`{}"
-    update:
-      temp:
-        id_off: ":mute: **Mute updated** by {} to {} because of `{}`"
-        id_on: ":mute: **Mute updated** by {} to {} because of `{}`\n`(ID: {})`"
-      inf:
-        id_off: ":mute: **Mute updated** to permanent by {} because of `{}`"
-        id_on: ":mute: **Mute updated** to permanent by {} because of `{}`\n`(ID: {})`"
+    temp:
+      id_off: ":mute: **Muted** by {} for {} because of `{}`{}"
+      id_on: ":mute: **Muted** by {} for {} because of `{}`\n`(ID: {})`{}"
+    inf:
+      id_off: ":mute: **Muted** permanently by {} because of `{}`{}"
+      id_on: ":mute: **Muted** permanently by {} because of `{}`\n`(ID: {})`{}"
   unmuted:
     id_off: ":loud_sound: **Unmuted** by {} because of `{}`"
     id_on: ":loud_sound: **Unmuted** by {} because of `{}`\n`(ID: {})`"
@@ -203,20 +201,12 @@ ulog:
   autokicked: ":hourglass: **Kicked** automatically."
 
   banned:
-    first:
-      temp:
-        id_off: ":no_entry: **Banned** by {} for {} because of `{}`{}"
-        id_on: ":no_entry: **Banned** by {} for {} because of `{}`\n`(ID: {})`{}"
-      inf:
-        id_off: ":no_entry: **Banned** permanently by {} because of `{}`{}"
-        id_on: ":no_entry: **Banned** by permanently by {} because of `{}`\n`(ID: {})`{}"
-    update:
-      temp:
-        id_off: ":no_entry: **Ban updated** by {} to {} because of `{}`"
-        id_on: ":no_entry: **Ban updated** by {} to {} because of `{}`\n`(ID: {})`"
-      inf:
-        id_off: ":no_entry: **Ban updated** to permanent by {} because of `{}`"
-        id_on: ":no_entry: **Ban updated** to permanent by {} because of `{}`\n`(ID: {})`"
+    temp:
+      id_off: ":no_entry: **Banned** by {} for {} because of `{}`{}"
+      id_on: ":no_entry: **Banned** by {} for {} because of `{}`\n`(ID: {})`{}"
+    inf:
+      id_off: ":no_entry: **Banned** permanently by {} because of `{}`{}"
+      id_on: ":no_entry: **Banned** by permanently by {} because of `{}`\n`(ID: {})`{}"
   unbanned:
     id_off: ":white_check_mark: **Unbanned** by {} because of `{}`"
     id_on: ":white_check_mark: **Unbanned** by {} because of `{}`\n`(ID: {})`"

From 47d6d61f77cfa743856386fe0ef39923d5135319 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Sun, 2 Jan 2022 06:23:33 +0100
Subject: [PATCH 073/120] Renamed functions and fixed a bit of codestyle

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 992925eb5..df516b601 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -630,7 +630,7 @@ async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         user_embed = Embed(
             title=t.warn,
             colour=Colors.ModTools,
-            description=t.warned(ctx.author.mention, ctx.guild.name, reason)
+            description=t.warned(ctx.author.mention, ctx.guild.name, reason),
         )
 
         server_embed = Embed(title=t.warn, description=t.warned_response, colour=Colors.ModTools)
@@ -854,7 +854,7 @@ async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
         server_embed = Embed(title=t.mute, description=t.mute_edited_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-        await Mute.edit(mute_id, ctx.author.id, await get_mod_level(ctx.author), reason)
+        await Mute.edit_reason(mute_id, ctx.author.id, await get_mod_level(ctx.author), reason)
 
         try:
             await user.send(embed=user_embed)
@@ -877,10 +877,9 @@ async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time
         minutes = time
 
         active_mutes: List[Mute] = sorted(
-            await db.all(filter_by(Mute, active=True, member=user.id)), key=lambda active_mute: active_mute.timestamp
+            await db.all(filter_by(Mute, active=True, member=user.id)), key=lambda active_mute: active_mute.timestamp,
         )
 
-
         if not active_mutes:
             raise CommandError(t.not_muted)
 
@@ -1268,7 +1267,6 @@ async def ban(
             evidence=evidence,
         )
 
-
         if minutes is not None:
             user_embed.description = t.banned(ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason)
 
@@ -1327,7 +1325,7 @@ async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
         server_embed = Embed(title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-        await Ban.edit(ban_id, ctx.author.id, await get_mod_level(ctx.author), reason)
+        await Ban.edit_reason(ban_id, ctx.author.id, await get_mod_level(ctx.author), reason)
 
         try:
             await user.send(embed=user_embed)

From 1fe407dc33da40b926a72650668f62f432cf4225 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Sun, 2 Jan 2022 06:36:37 +0100
Subject: [PATCH 074/120] Added information about previous mutes when banning a
 member

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py              | 7 +++++++
 moderation/mod/translations/en.yml | 2 ++
 2 files changed, 9 insertions(+)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index df516b601..59ca9c52f 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -1238,6 +1238,10 @@ async def ban(
         if active_bans:
             raise UserCommandError(user, t.already_banned)
 
+        active_mutes: List[Mute] = await db.all(filter_by(Mute, active=True, member=user.id))
+        for mute in active_mutes:
+            await Mute.deactivate(mute.id, ctx.author.id, t.cancelled_by_ban)
+
         attachments = ctx.message.attachments
         evidence = attachments[0] if attachments else None
         evidence_url = evidence.url if attachments else None
@@ -1246,6 +1250,9 @@ async def ban(
         server_embed = Embed(title=t.ban, description=t.banned_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
+        if active_mutes:
+            server_embed.description += f"\n\n{t.previously_muted}"
+
         await Ban.create(
             user.id,
             str(user),
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index 25e306b20..3776f3039 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -153,6 +153,8 @@ ban_deleted:
 ban_deleted_response: ":white_check_mark: The ban has been deleted"
 log_ban_deleted: ":white_check_mark: Ban deleted"
 alert_member_banned: "The member {} has been banned through discords ban system by {}"
+cancelled_by_ban: The mute was cancelled because the member has been banned
+previously_muted: The member was prevoiously muted. This mute has now been cancelled.
 
 reported_cnt: ":speech_balloon:  Reported"
 warned_cnt: ":warning:  Warned"

From 0f45012c310eb2e931c3669aab765dce0aa1cb27 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Sun, 2 Jan 2022 06:53:23 +0100
Subject: [PATCH 075/120] Made send_delete_message command return the current
 settings when no parameter is given

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py              | 13 ++++++++++---
 moderation/mod/translations/en.yml |  3 +++
 2 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 59ca9c52f..4d699b1eb 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -541,13 +541,20 @@ async def on_member_ban(self, guild: Guild, member: Member):
 
     @commands.command()
     @ModPermission.modtools_write.check
-    async def send_delete_message(self, ctx: Context, send: bool):
+    async def send_delete_message(self, ctx: Context, send: Optional[bool] = None):
         """
         configure whether to send a warn/mute/kick/ban delete message to the concerned user
         """
 
-        await ModSettings.send_delete_user_message.set(send)
-        embed = Embed(title=t.modtools, description=t.configured_send_delete_message[send], color=Colors.ModTools)
+        embed = Embed(title=t.modtools, color=Colors.ModTools)
+
+        if send is None:
+            send = await ModSettings.send_delete_user_message.get()
+            embed.description = t.current_send_delete_message[send]
+        else:
+            await ModSettings.send_delete_user_message.set(send)
+            embed.description = t.configured_send_delete_message[send]
+
         await reply(ctx, embed=embed)
         await send_to_changelog(ctx.guild, t.configured_send_delete_message[send])
 
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index 3776f3039..b46d61e4c 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -41,6 +41,9 @@ modtools: Mod tools
 configured_send_delete_message:
   off: "Sending a message to a user after a warn/mute/kick/ban concerning him has been set to `off`"
   on: "Sending a message to a user after a warn/mute/kick/ban concerning him has been set to `on`"
+current_send_delete_message:
+  off: "Sending a message to a user after a warn/mute/kick/ban concerning him is currently `off`"
+  on: "Sending a message to a user after a warn/mute/kick/ban concerning him is currently `on`"
 jump_url: "{} [[Jump]]({})"
 image_link: "{} [[Go to image]]({})"
 no_dm: ":warning: User does not allow direct messages."

From bcb70a1a3cebe759ebf377412ed049b8b858c217 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Sun, 2 Jan 2022 07:05:53 +0100
Subject: [PATCH 076/120] Added confirmation when no evidence is given

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py              | 26 ++++++++++++++++++++++++++
 moderation/mod/translations/en.yml |  3 +++
 2 files changed, 29 insertions(+)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 4d699b1eb..ed9e9ccf3 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -139,6 +139,16 @@ async def confirm_action(
         return result
 
 
+async def confirm_no_evidence(ctx: Context):
+    conf_embed = Embed(
+        title=t.confirmation,
+        description=t.no_evidence,
+        color=Colors.ModTools,
+    )
+
+    return confirm_action(ctx, conf_embed, t.action_confirmed, t.action_cancelled)
+
+
 async def send_to_changelog_mod(
     guild: Guild,
     message: Optional[Message],
@@ -634,6 +644,10 @@ async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         evidence = attachments[0] if attachments else None
         evidence_url = evidence.url if attachments else None
 
+        if not evidence:
+            if not confirm_no_evidence(ctx):
+                return
+
         user_embed = Embed(
             title=t.warn,
             colour=Colors.ModTools,
@@ -778,6 +792,10 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
         evidence = attachments[0] if attachments else None
         evidence_url = evidence.url if attachments else None
 
+        if not evidence:
+            if not confirm_no_evidence(ctx):
+                return
+
         user_embed = Embed(title=t.mute, colour=Colors.ModTools)
         server_embed = Embed(title=t.mute, description=t.muted_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
@@ -1082,6 +1100,10 @@ async def kick(self, ctx: Context, member: Member, *, reason: str):
         evidence = attachments[0] if attachments else None
         evidence_url = evidence.url if attachments else None
 
+        if not evidence:
+            if not confirm_no_evidence(ctx):
+                return
+
         await Kick.create(member.id, str(member), ctx.author.id, await get_mod_level(ctx.author), reason, evidence_url)
         await send_to_changelog_mod(
             ctx.guild,
@@ -1253,6 +1275,10 @@ async def ban(
         evidence = attachments[0] if attachments else None
         evidence_url = evidence.url if attachments else None
 
+        if not evidence:
+            if not confirm_no_evidence(ctx):
+                return
+
         user_embed = Embed(title=t.ban, colour=Colors.ModTools)
         server_embed = Embed(title=t.ban, description=t.banned_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index b46d61e4c..4731325ed 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -54,6 +54,9 @@ edit_canceled: ":x: Edit canceled"
 edit_confirmed: ":white_check_mark: Edit confirmed"
 infinity: Permanent
 cannot_fetch_audit_logs: A ban initiated through the server couldn't be added to the database because I don't have `view_audit_log` permissions on this server.
+no_evidence: You did not attach an evidence to your message, are you sure you want to continue?
+action_cancelled: ":x: Action canceled"
+action_confirmed: ":white_check_mark: Action confirmed"
 
 # reports
 report: ":speech_balloon: Report"

From 9ffcce8dac722f2e761cf575423e0bb0ad0c39cc Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Sun, 2 Jan 2022 07:19:20 +0100
Subject: [PATCH 077/120] Replaced db query

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index ed9e9ccf3..b667ab7f6 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -784,8 +784,7 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
             await user.add_roles(mute_role)
             await user.move_to(None)
 
-        active_mutes: List[Mute] = await db.all(filter_by(Mute, active=True, member=user.id))
-        if active_mutes:
+        if await db.exists(filter_by(Mute, active=True, member=user.id)):
             raise UserCommandError(user, t.already_muted)
 
         attachments = ctx.message.attachments

From cb44a5844352a31eec82a3e1067a54e17168cb8b Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Sun, 2 Jan 2022 07:24:09 +0100
Subject: [PATCH 078/120] Improved check for banning permissions

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index b667ab7f6..792b61185 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -216,14 +216,15 @@ async def mod_loop(self):
 
         async for ban in await db.stream(filter_by(Ban, active=True)):
             if ban.minutes != -1 and utcnow() >= ban.timestamp + timedelta(minutes=ban.minutes):
-                await Ban.deactivate(ban.id)
-
                 try:
                     await guild.unban(user := await self.bot.fetch_user(ban.member))
                 except NotFound:
                     user = ban.member, ban.member_name
                 except Forbidden:
                     await send_alert(guild, t.cannot_unban_permissions)
+                    continue
+
+                await Ban.deactivate(ban.id)
 
                 await send_to_changelog_mod(
                     guild,

From e4cf75974b9ce48dc630460575fc980e59de8fa9 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Mon, 3 Jan 2022 07:34:00 +0100
Subject: [PATCH 079/120] Added docs decorator

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py              | 122 ++++++-----------------------
 moderation/mod/translations/en.yml |  22 ++++++
 2 files changed, 45 insertions(+), 99 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 792b61185..dc9bc7c73 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -31,9 +31,9 @@
 )
 
 from PyDrocsid.cog import Cog
-from PyDrocsid.command import reply, UserCommandError, confirm
+from PyDrocsid.command import reply, UserCommandError, confirm, docs
 from PyDrocsid.converter import UserMemberConverter
-from PyDrocsid.database import db, filter_by, db_wrapper
+from PyDrocsid.database import db, filter_by, db_wrapper, Base
 from PyDrocsid.settings import RoleSettings
 from PyDrocsid.translations import t
 from PyDrocsid.util import is_teamler, check_role_assignable
@@ -111,7 +111,7 @@ async def compare_mod_level(mod: Member, mod_level: int) -> bool:
     return await get_mod_level(mod) > mod_level or mod == mod.guild.owner
 
 
-async def get_and_compare_entry(entry_format: Type[db.Base], entry_id: int, mod: Member):
+async def get_and_compare_entry(entry_format: Type[Base], entry_id: int, mod: Member):
     entry = await db.get(entry_format, id=entry_id)
     if entry is None:
         raise CommandError(getattr(t.not_found, entry_format.__tablename__))
@@ -552,11 +552,8 @@ async def on_member_ban(self, guild: Guild, member: Member):
 
     @commands.command()
     @ModPermission.modtools_write.check
+    @docs(t.commands.send_delete_message)
     async def send_delete_message(self, ctx: Context, send: Optional[bool] = None):
-        """
-        configure whether to send a warn/mute/kick/ban delete message to the concerned user
-        """
-
         embed = Embed(title=t.modtools, color=Colors.ModTools)
 
         if send is None:
@@ -570,11 +567,8 @@ async def send_delete_message(self, ctx: Context, send: Optional[bool] = None):
         await send_to_changelog(ctx.guild, t.configured_send_delete_message[send])
 
     @commands.command()
+    @docs(t.commands.report)
     async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
-        """
-        report a user
-        """
-
         user: Union[Member, User]
 
         if len(reason) > 900:
@@ -628,11 +622,8 @@ async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
     @commands.command()
     @ModPermission.warn.check
     @guild_only()
+    @docs(t.commands.warn)
     async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
-        """
-        warn a user
-        """
-
         user: Union[Member, User]
 
         if len(reason) > 900:
@@ -669,12 +660,8 @@ async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
     @commands.command(aliases=["warn_edit"])
     @ModPermission.warn.check
     @guild_only()
+    @docs(t.commands.edit_warn)
     async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
-        """
-        edit a warn
-        get the warn id from the users user log
-        """
-
         warn = await get_and_compare_entry(Warn, warn_id, ctx.author)
 
         if len(reason) > 900:
@@ -715,12 +702,8 @@ async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
     @commands.command(aliases=["warn_delete"])
     @ModPermission.warn.check
     @guild_only()
+    @docs(t.commands.delete_warn)
     async def delete_warn(self, ctx: Context, warn_id: int):
-        """
-        delete a warn
-        get the warn id from the users user log
-        """
-
         warn = await get_and_compare_entry(Warn, warn_id, ctx.author)
 
         conf_embed = Embed(
@@ -761,13 +744,8 @@ async def delete_warn(self, ctx: Context, warn_id: int):
     @commands.command()
     @ModPermission.mute.check
     @guild_only()
+    @docs(t.commands.mute)
     async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConverter, *, reason: str):
-        """
-        mute a user
-        time format: `wdhm`
-        set time to `inf` for a permanent mute
-        """
-
         user: Union[Member, User]
 
         time: Optional[int]
@@ -837,21 +815,14 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
     @commands.group(aliases=["mute_edit"])
     @ModPermission.mute.check
     @guild_only()
+    @docs(t.commands.edit_mute)
     async def edit_mute(self, ctx):
-        """
-        edit a mute
-        """
-
         if ctx.invoked_subcommand is None:
             raise UserInputError
 
     @edit_mute.command(name="reason", aliases=["r"])
+    @docs(t.commands.edit_mute_reason)
     async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
-        """
-        edit a mute reason
-        get the mute id from the users user log
-        """
-
         mute = await get_and_compare_entry(Mute, mute_id, ctx.author)
 
         if len(reason) > 900:
@@ -890,13 +861,8 @@ async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
         await send_to_changelog_mod(ctx.guild, ctx.message, Colors.mute, t.log_mute_edited, user, reason)
 
     @edit_mute.command(name="duration", aliases=["d"])
+    @docs(t.commands.edit_mute_duration)
     async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time: DurationConverter):
-        """
-        edit a mute duration
-        time format: `wdhm`
-        set time to `inf` for a permanent mute
-        """
-
         user: Union[Member, User]
         time: Optional[int]
         minutes = time
@@ -967,12 +933,8 @@ async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time
     @commands.command(aliases=["mute_delete"])
     @ModPermission.mute.check
     @guild_only()
+    @docs(t.commands.delete_mute)
     async def delete_mute(self, ctx: Context, mute_id: int):
-        """
-        delete a mute
-        get the mute id from the users user log
-        """
-
         mute = await get_and_compare_entry(Mute, mute_id, ctx.author)
 
         conf_embed = Embed(
@@ -1045,11 +1007,8 @@ async def delete_mute(self, ctx: Context, mute_id: int):
     @commands.command()
     @ModPermission.mute.check
     @guild_only()
+    @docs(t.commands.unmute)
     async def unmute(self, ctx: Context, user: UserMemberConverter, *, reason: str):
-        """
-        unmute a user
-        """
-
         user: Union[Member, User]
 
         if len(reason) > 900:
@@ -1079,11 +1038,8 @@ async def unmute(self, ctx: Context, user: UserMemberConverter, *, reason: str):
     @commands.command()
     @ModPermission.kick.check
     @guild_only()
+    @docs(t.commands.kick)
     async def kick(self, ctx: Context, member: Member, *, reason: str):
-        """
-        kick a member
-        """
-
         if len(reason) > 900:
             raise CommandError(t.reason_too_long)
 
@@ -1138,12 +1094,8 @@ async def kick(self, ctx: Context, member: Member, *, reason: str):
     @commands.command(aliases=["kick_edit"])
     @ModPermission.kick.check
     @guild_only()
+    @docs(t.commands.edit_kick)
     async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
-        """
-        edit a kick
-        get the kick id from the users user log
-        """
-
         kick = await get_and_compare_entry(Kick, kick_id, ctx.author)
 
         if len(reason) > 900:
@@ -1184,12 +1136,8 @@ async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
     @commands.command(aliases=["kick_delete"])
     @ModPermission.kick.check
     @guild_only()
+    @docs(t.commands.delete_kick)
     async def delete_kick(self, ctx: Context, kick_id: int):
-        """
-        delete a kick
-        get the kick id from the users user log
-        """
-
         kick = await get_and_compare_entry(Kick, kick_id, ctx.author)
 
         conf_embed = Embed(
@@ -1230,6 +1178,7 @@ async def delete_kick(self, ctx: Context, kick_id: int):
     @commands.command()
     @ModPermission.ban.check
     @guild_only()
+    @docs(t.commands.ban)
     async def ban(
         self,
         ctx: Context,
@@ -1239,12 +1188,6 @@ async def ban(
         *,
         reason: str,
     ):
-        """
-        ban a user
-        time format: `wdhm`
-        set time to `inf` for a permanent ban
-        """
-
         time: Optional[int]
         minutes = time
 
@@ -1327,21 +1270,14 @@ async def ban(
     @commands.group(aliases=["ban_edit"])
     @ModPermission.mute.check
     @guild_only()
+    @docs(t.commands.edit_ban)
     async def edit_ban(self, ctx):
-        """
-        edit a ban
-        """
-
         if ctx.invoked_subcommand is None:
             raise UserInputError
 
     @edit_ban.command(name="reason", aliases=["r"])
+    @docs(t.commands.edit_ban_reason)
     async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
-        """
-        edit a ban reason
-        get the ban id from the users user log
-        """
-
         ban = await get_and_compare_entry(Ban, ban_id, ctx.author)
 
         if len(reason) > 900:
@@ -1376,13 +1312,8 @@ async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
         await send_to_changelog_mod(ctx.guild, ctx.message, Colors.ban, t.log_ban_edited, user, reason)
 
     @edit_ban.command(name="duration", aliases=["d"])
+    @docs(t.commands.edit_ban_duration)
     async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time: DurationConverter):
-        """
-        edit a ban duration
-        time format: `wdhm`
-        set time to `inf` for a permanent ban
-        """
-
         user: Union[Member, User]
         time: Optional[int]
         minutes = time
@@ -1447,12 +1378,8 @@ async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time:
     @commands.command(aliases=["ban_delete"])
     @ModPermission.ban.check
     @guild_only()
+    @docs(t.commands.delete_ban)
     async def delete_ban(self, ctx: Context, ban_id: int):
-        """
-        delete a ban
-        get the ban id from the users user log
-        """
-
         ban = await get_and_compare_entry(Ban, ban_id, ctx.author)
 
         conf_embed = Embed(
@@ -1514,11 +1441,8 @@ async def delete_ban(self, ctx: Context, ban_id: int):
     @commands.command()
     @ModPermission.ban.check
     @guild_only()
+    @docs(t.commands.unban)
     async def unban(self, ctx: Context, user: UserMemberConverter, *, reason: str):
-        """
-        unban a user
-        """
-
         user: Union[Member, User]
 
         if len(reason) > 900:
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index 4731325ed..093e720b2 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -5,6 +5,28 @@ permissions:
   ban: ban a user
   modtools_write: write mod tools configuration
 
+commands:
+  send_delete_message: configure whether to send a warn/mute/kick/ban delete message to the concerned user
+  report: report a user
+  warn: warn a user
+  edit_warn: edit a warn\nget the warn id from the users user log
+  delete_warn: delete a warn\nget the warn id from the users user log
+  mute: "mute a user\ntime format: `wdhm`\nset time to `inf` for a permanent mute"
+  edit_mute: edit a mute
+  edit_mute_reason: edit a mute reason\nget the mute id from the users user log
+  edit_mute_duration: "edit a mute duration\ntime format: `wdhm`\nset time to `inf` for a permanent mute"
+  delete_mute: delete a mute\nget the mute id from the users user log
+  unmute: unmute a user
+  kick: kick a member
+  edit_kick: edit a kick\nget the kick id from the users user log
+  delete_kick: delete a kick\nget the kick id from the users user log
+  ban: "ban a user\ntime format: `wdhm`\nset time to `inf` for a permanent ban"
+  edit_ban: edit a ban
+  edit_ban_reason: edit a ban reason\nget the ban id from the users user log
+  edit_ban_duration: "edit a ban duration\ntime format: `wdhm`\nset time to `inf` for a permanent ban"
+  delete_ban: delete a ban\nget the ban id from the users user log
+  unban: unban a user
+
 times:
   days:
     one: "{cnt} day"

From d21f728f659da7440d098ad981e91faa8127f5ef Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Mon, 3 Jan 2022 20:21:14 +0100
Subject: [PATCH 080/120] Added guild only check for setting

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index dc9bc7c73..fde74de2a 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -551,6 +551,7 @@ async def on_member_ban(self, guild: Guild, member: Member):
             await send_alert(guild, t.cannot_fetch_audit_logs)
 
     @commands.command()
+    @guild_only()
     @ModPermission.modtools_write.check
     @docs(t.commands.send_delete_message)
     async def send_delete_message(self, ctx: Context, send: Optional[bool] = None):

From ff19912b285a7f604fa29649a5d0e5829ae427d7 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Tue, 4 Jan 2022 07:47:00 +0100
Subject: [PATCH 081/120] Enhanced ban detection feature

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 69 ++++++++++++++++++++++++-------------------
 1 file changed, 38 insertions(+), 31 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index fde74de2a..d0be618bc 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -29,6 +29,7 @@
     BadArgument,
     UserInputError,
 )
+from asyncio import sleep
 
 from PyDrocsid.cog import Cog
 from PyDrocsid.command import reply, UserCommandError, confirm, docs
@@ -512,43 +513,49 @@ async def on_member_join(self, member: Member):
             await member.add_roles(mute_role)
 
     async def on_member_ban(self, guild: Guild, member: Member):
-        try:
-            entry: AuditLogEntry
-            async for entry in guild.audit_logs(limit=100, action=AuditLogAction.ban):
-                if entry.user == self.bot.user:
-                    continue
+        search_limit = 100
+        for i in range(10, 1, -1):
 
-                if member.id != entry.target.id:
-                    continue
+            try:
+                entry: AuditLogEntry
+                async for entry in guild.audit_logs(limit=search_limit, action=AuditLogAction.ban):
+                    if entry.user == self.bot.user:
+                        continue
+
+                    if member.id != entry.target.id:
+                        continue
+
+                    if entry.reason:
+                        await Ban.create(
+                            entry.target.id,
+                            str(entry.target),
+                            entry.user.id,
+                            await get_mod_level(entry.user),
+                            -1,
+                            entry.reason,
+                            None,
+                        )
 
-                if entry.reason:
-                    await Ban.create(
-                        entry.target.id,
-                        str(entry.target),
-                        entry.user.id,
-                        await get_mod_level(entry.user),
-                        -1,
-                        entry.reason,
-                        None,
-                    )
+                        await send_to_changelog_mod(
+                            guild,
+                            None,
+                            Colors.ban,
+                            t.log_banned,
+                            entry.target,
+                            entry.reason,
+                            duration=t.log_field.infinity,
+                        )
 
-                    await send_to_changelog_mod(
-                        guild,
-                        None,
-                        Colors.ban,
-                        t.log_banned,
-                        entry.target,
-                        entry.reason,
-                        duration=t.log_field.infinity,
-                    )
+                    else:
+                        await send_alert(guild, t.alert_member_banned(str(entry.target), str(entry.user)))
 
-                else:
-                    await send_alert(guild, t.alert_member_banned(str(entry.target), str(entry.user)))
+                    return
 
-                return
+            except Forbidden:
+                await send_alert(guild, t.cannot_fetch_audit_logs)
 
-        except Forbidden:
-            await send_alert(guild, t.cannot_fetch_audit_logs)
+            await sleep(delay=i*10)
+            search_limit -= i * 10
 
     @commands.command()
     @guild_only()

From 498ecf6ac101ef8f144b33f9058765d958ceb489 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Tue, 4 Jan 2022 07:47:52 +0100
Subject: [PATCH 082/120] Updated ulog pubsub function

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/user_notes/cog.py | 2 +-
 pubsub.md                    | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/moderation/user_notes/cog.py b/moderation/user_notes/cog.py
index eac77fea6..343eb268e 100644
--- a/moderation/user_notes/cog.py
+++ b/moderation/user_notes/cog.py
@@ -28,7 +28,7 @@ class UserNoteCog(Cog, name="User Notes"):
     CONTRIBUTORS = [Contributor.Florian, Contributor.Defelo]
 
     @get_userlog_entries.subscribe
-    async def handle_get_userlog_entries(self, user_id: int, author: Member) -> list[tuple[datetime, str]]:
+    async def handle_get_userlog_entries(self, user_id: int, _, author: Member) -> list[tuple[datetime, str]]:
         if not await is_teamler(author):
             return []
 
diff --git a/pubsub.md b/pubsub.md
index b709a3961..ec615bd3e 100644
--- a/pubsub.md
+++ b/pubsub.md
@@ -106,14 +106,14 @@ Subscriptions:
 Use this PubSub channel to get/provide log entries about a user for the user log command.
 
 ```python
-async def get_userlog_entries(user_id: int, show_ids: bool) -> list[list[tuple[datetime, str]]]
+async def get_userlog_entries(user_id: int, show_ids: bool, author: Member) -> list[list[tuple[datetime, str]]]
 ```
 
 Arguments:
 
 - `user_id`: The user id
 - `show_ids`: Whether to put ids from moderation events into the log entry (only relevant for the mod cog)
-- `author`: The member who requested the user logs (only relevant for the mod cog)
+- `author`: The member who requested the user logs (only relevant for the mod and user notes cog)
 
 Returns: A list of `(datetime, log_entry)` tuples
 

From cf7e683d9c7ebb6473cf52a8cd1ad7b29d4d6a44 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Tue, 4 Jan 2022 08:06:26 +0100
Subject: [PATCH 083/120] Added keyword arguments for changelog calls

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 219 ++++++++++++++++++++++++++----------------
 1 file changed, 136 insertions(+), 83 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index d0be618bc..ac8f9116a 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -228,12 +228,12 @@ async def mod_loop(self):
                 await Ban.deactivate(ban.id)
 
                 await send_to_changelog_mod(
-                    guild,
-                    None,
-                    Colors.unban,
-                    t.log_unbanned,
-                    user,
-                    t.log_unbanned_expired,
+                    guild=guild,
+                    message=None,
+                    colour=Colors.unban,
+                    title=t.log_unbanned,
+                    member=user,
+                    reason=t.log_unbanned_expired,
                 )
 
         mute_role: Optional[Role] = guild.get_role(await RoleSettings.get("mute"))
@@ -254,12 +254,12 @@ async def mod_loop(self):
                     member = mute.member, mute.member_name
 
                 await send_to_changelog_mod(
-                    guild,
-                    None,
-                    Colors.unmute,
-                    t.log_unmuted,
-                    member,
-                    t.log_unmuted_expired,
+                    guild=guild,
+                    message=None,
+                    colour=Colors.unmute,
+                    title=t.log_unmuted,
+                    member=member,
+                    reason=t.log_unmuted_expired,
                 )
                 await Mute.deactivate(mute.id)
 
@@ -537,12 +537,12 @@ async def on_member_ban(self, guild: Guild, member: Member):
                         )
 
                         await send_to_changelog_mod(
-                            guild,
-                            None,
-                            Colors.ban,
-                            t.log_banned,
-                            entry.target,
-                            entry.reason,
+                            guild=guild,
+                            message=None,
+                            colour=Colors.ban,
+                            title=t.log_banned,
+                            member=entry.target,
+                            reason=entry.reason,
                             duration=t.log_field.infinity,
                         )
 
@@ -663,7 +663,15 @@ async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
             server_embed.colour = Colors.error
         await Warn.create(user.id, str(user), ctx.author.id, await get_mod_level(ctx.author), reason, evidence_url)
         await reply(ctx, embed=server_embed)
-        await send_to_changelog_mod(ctx.guild, ctx.message, Colors.warn, t.log_warned, user, reason, evidence=evidence)
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.warn,
+            title=t.log_warned,
+            member=user,
+            reason=reason,
+            evidence=evidence
+        )
 
     @commands.command(aliases=["warn_edit"])
     @ModPermission.warn.check
@@ -705,7 +713,14 @@ async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
             server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
             server_embed.colour = Colors.error
         await reply(ctx, embed=server_embed)
-        await send_to_changelog_mod(ctx.guild, ctx.message, Colors.warn, t.log_warn_edited, user, reason)
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.warn,
+            title=t.log_warn_edited,
+            member=user,
+            reason=reason
+        )
 
     @commands.command(aliases=["warn_delete"])
     @ModPermission.warn.check
@@ -747,7 +762,14 @@ async def delete_warn(self, ctx: Context, warn_id: int):
                 server_embed.colour = Colors.error
 
         await reply(ctx, embed=server_embed)
-        await send_to_changelog_mod(ctx.guild, ctx.message, Colors.warn, t.log_warn_deleted, user, warn.reason)
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.warn,
+            title=t.log_warn_deleted,
+            member=user,
+            reason=warn.reason
+        )
 
     @commands.command()
     @ModPermission.mute.check
@@ -797,12 +819,12 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
         )
 
         await send_to_changelog_mod(
-            ctx.guild,
-            ctx.message,
-            Colors.mute,
-            t.log_muted,
-            user,
-            reason,
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.mute,
+            title=t.log_muted,
+            member=user,
+            reason=reason,
             duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
             evidence=evidence,
         )
@@ -866,7 +888,14 @@ async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
             server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
             server_embed.colour = Colors.error
         await reply(ctx, embed=server_embed)
-        await send_to_changelog_mod(ctx.guild, ctx.message, Colors.mute, t.log_mute_edited, user, reason)
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.mute,
+            title=t.log_mute_edited,
+            member=user,
+            reason=reason
+        )
 
     @edit_mute.command(name="duration", aliases=["d"])
     @docs(t.commands.edit_mute_duration)
@@ -922,12 +951,12 @@ async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time
             t.infinity if minutes is None else time_to_units(minutes),
         )
         await send_to_changelog_mod(
-            ctx.guild,
-            ctx.message,
-            Colors.mute,
-            t.log_mute_edited,
-            user,
-            Mute.reason,
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.mute,
+            title=t.log_mute_edited,
+            member=user,
+            reason=Mute.reason,
             duration=t.log_field.infinity if minutes is None else time_to_units(minutes),
         )
 
@@ -991,26 +1020,15 @@ async def delete_mute(self, ctx: Context, mute_id: int):
 
         await reply(ctx, embed=server_embed)
 
-        if mute.minutes == -1:
-            await send_to_changelog_mod(
-                ctx.guild,
-                ctx.message,
-                Colors.mute,
-                t.log_mute_deleted,
-                user,
-                mute.reason,
-                duration=t.log_field_infinity,
-            )
-        else:
-            await send_to_changelog_mod(
-                ctx.guild,
-                ctx.message,
-                Colors.mute,
-                t.log_mute_deleted,
-                user,
-                mute.reason,
-                duration=time_to_units(mute.minutes),
-            )
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.mute,
+            title=t.log_mute_deleted,
+            member=user,
+            reason=mute.reason,
+            duration=t.log_field_infinity if mute.minutes == -1 else time_to_units(mute.minutes),
+        )
 
     @commands.command()
     @ModPermission.mute.check
@@ -1041,7 +1059,14 @@ async def unmute(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         server_embed = Embed(title=t.unmute, description=t.unmuted_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
         await reply(ctx, embed=server_embed)
-        await send_to_changelog_mod(ctx.guild, ctx.message, Colors.unmute, t.log_unmuted, user, reason)
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.unmute,
+            title=t.log_unmuted,
+            member=user,
+            reason=reason
+        )
 
     @commands.command()
     @ModPermission.kick.check
@@ -1070,12 +1095,12 @@ async def kick(self, ctx: Context, member: Member, *, reason: str):
 
         await Kick.create(member.id, str(member), ctx.author.id, await get_mod_level(ctx.author), reason, evidence_url)
         await send_to_changelog_mod(
-            ctx.guild,
-            ctx.message,
-            Colors.kick,
-            t.log_kicked,
-            member,
-            reason,
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.kick,
+            title=t.log_kicked,
+            member=member,
+            reason=reason,
             evidence=evidence,
         )
 
@@ -1139,7 +1164,14 @@ async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
             server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
             server_embed.colour = Colors.error
         await reply(ctx, embed=server_embed)
-        await send_to_changelog_mod(ctx.guild, ctx.message, Colors.kick, t.log_kick_edited, user, reason)
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.kick,
+            title=t.log_kick_edited,
+            member=user,
+            reason=reason
+        )
 
     @commands.command(aliases=["kick_delete"])
     @ModPermission.kick.check
@@ -1181,7 +1213,14 @@ async def delete_kick(self, ctx: Context, kick_id: int):
                 server_embed.colour = Colors.error
 
         await reply(ctx, embed=server_embed)
-        await send_to_changelog_mod(ctx.guild, ctx.message, Colors.kick, t.log_kick_deleted, user, kick.reason)
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.kick,
+            title=t.log_kick_deleted,
+            member=user,
+            reason=kick.reason
+        )
 
     @commands.command()
     @ModPermission.ban.check
@@ -1248,12 +1287,12 @@ async def ban(
         )
 
         await send_to_changelog_mod(
-            ctx.guild,
-            ctx.message,
-            Colors.ban,
-            t.log_banned,
-            user,
-            reason,
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.ban,
+            title=t.log_banned,
+            member= user,
+            reason=reason,
             duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
             evidence=evidence,
         )
@@ -1317,7 +1356,14 @@ async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
             server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
             server_embed.colour = Colors.error
         await reply(ctx, embed=server_embed)
-        await send_to_changelog_mod(ctx.guild, ctx.message, Colors.ban, t.log_ban_edited, user, reason)
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.ban,
+            title=t.log_ban_edited,
+            member=user,
+            reason=reason
+        )
 
     @edit_ban.command(name="duration", aliases=["d"])
     @docs(t.commands.edit_ban_duration)
@@ -1367,12 +1413,12 @@ async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time:
             t.infinity if minutes is None else time_to_units(minutes),
         )
         await send_to_changelog_mod(
-            ctx.guild,
-            ctx.message,
-            Colors.ban,
-            t.log_ban_edited,
-            user,
-            ban.reason,
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.ban,
+            title=t.log_ban_edited,
+            member=user,
+            reason=ban.reason,
             duration=t.log_field.infinity if minutes is None else time_to_units(minutes),
         )
 
@@ -1437,12 +1483,12 @@ async def delete_ban(self, ctx: Context, ban_id: int):
         await reply(ctx, embed=server_embed)
 
         await send_to_changelog_mod(
-            ctx.guild,
-            ctx.message,
-            Colors.ban,
-            t.log_ban_deleted,
-            user,
-            ban.reason,
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.ban,
+            title=t.log_ban_deleted,
+            member=user,
+            reason=ban.reason,
             duration=t.log_field_infinity if ban.minutes == -1 else time_to_units(ban.minutes),
         )
 
@@ -1477,4 +1523,11 @@ async def unban(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         server_embed = Embed(title=t.unban, description=t.unbanned_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
         await reply(ctx, embed=server_embed)
-        await send_to_changelog_mod(ctx.guild, ctx.message, Colors.unban, t.log_unbanned, user, reason)
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.unban,
+            title=t.log_unbanned,
+            member=user,
+            reason=reason
+        )

From 30d1c4108ee4ead08b5a11bdc2fd3315f8691051 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Sat, 5 Mar 2022 12:06:23 +0100
Subject: [PATCH 084/120] Made mod loop run every minute

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py              | 88 ++++++++++++++++++++++++++----
 moderation/mod/translations/en.yml |  2 +-
 2 files changed, 77 insertions(+), 13 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index ac8f9116a..8006a44e9 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -33,12 +33,14 @@
 
 from PyDrocsid.cog import Cog
 from PyDrocsid.command import reply, UserCommandError, confirm, docs
+from PyDrocsid.config import Config
 from PyDrocsid.converter import UserMemberConverter
-from PyDrocsid.database import db, filter_by, db_wrapper, Base
+from PyDrocsid.database import db, filter_by, db_wrapper, Base, select
+from PyDrocsid.environment import CACHE_TTL
+from PyDrocsid.redis import redis
 from PyDrocsid.settings import RoleSettings
 from PyDrocsid.translations import t
 from PyDrocsid.util import is_teamler, check_role_assignable
-from PyDrocsid.config import Config
 from .colors import Colors
 from .models import Mute, Ban, Report, Warn, Kick
 from .permissions import ModPermission
@@ -78,6 +80,36 @@ async def convert(self, ctx, argument: str) -> Optional[int]:
         return duration
 
 
+async def load_entries():
+    async def fill(db_model: Type[Base]):
+        async with redis.pipeline() as pipe:
+            await pipe.delete(entry_key := f"mod_entries:{db_model.__tablename__}")
+
+            async for entry in await db.stream(filter_by(db_model, active=True)):
+                if entry.minutes == -1:
+                    continue
+
+                expiration_timestamp = entry.timestamp + timedelta(minutes=entry.minutes)
+
+                await pipe.hmset(entry_key, {str(entry.id): str(expiration_timestamp)})
+
+            await pipe.expire(entry_key, CACHE_TTL)
+            await pipe.execute()
+
+
+    if await redis.exists(load_key := "mod_entries_loaded"):
+        return
+
+    await fill(Ban)
+    await fill(Mute)
+
+    await redis.setex("mod_entries_loaded", CACHE_TTL, 1)
+
+
+async def invalidate_entry_cache():
+    await redis.delete("mod_entries_loaded")
+
+
 def time_to_units(minutes: Union[int, float]) -> str:
     _keys = ("years", "months", "days", "hours", "minutes")
 
@@ -147,7 +179,7 @@ async def confirm_no_evidence(ctx: Context):
         color=Colors.ModTools,
     )
 
-    return confirm_action(ctx, conf_embed, t.action_confirmed, t.action_cancelled)
+    return await confirm_action(ctx, conf_embed, t.action_confirmed, t.action_cancelled)
 
 
 async def send_to_changelog_mod(
@@ -210,13 +242,18 @@ async def on_ready(self):
         except RuntimeError:
             self.mod_loop.restart()
 
-    @tasks.loop(minutes=30)
+    @tasks.loop(minutes=1)
     @db_wrapper
     async def mod_loop(self):
         guild: Guild = self.bot.guilds[0]
+        await load_entries()
+
+        ban_keys = await redis.hkeys(ban_entries_key := f"mod_entries:{Ban.__tablename__}")
+
+        for key in ban_keys:
+            if utcnow() >= datetime.fromisoformat(await redis.hget(ban_entries_key, key)):
+                ban = await db.get(Ban, id=int(key))
 
-        async for ban in await db.stream(filter_by(Ban, active=True)):
-            if ban.minutes != -1 and utcnow() >= ban.timestamp + timedelta(minutes=ban.minutes):
                 try:
                     await guild.unban(user := await self.bot.fetch_user(ban.member))
                 except NotFound:
@@ -227,6 +264,8 @@ async def mod_loop(self):
 
                 await Ban.deactivate(ban.id)
 
+                await redis.hdel(ban_entries_key, key)
+
                 await send_to_changelog_mod(
                     guild=guild,
                     message=None,
@@ -246,8 +285,12 @@ async def mod_loop(self):
             await send_alert(guild, t.cannot_assign_mute_role(mute_role, mute_role.id))
             return
 
-        async for mute in await db.stream(filter_by(Mute, active=True)):
-            if mute.minutes != -1 and utcnow() >= mute.timestamp + timedelta(minutes=mute.minutes):
+        mute_keys = await redis.hkeys(mute_entries_key := f"mod_entries:{Mute.__tablename__}")
+
+        for key in mute_keys:
+            if utcnow() >= datetime.fromisoformat(await redis.hget(mute_entries_key, key)):
+                mute = await db.get(Mute, id=int(key))
+
                 if member := guild.get_member(mute.member):
                     await member.remove_roles(mute_role)
                 else:
@@ -261,8 +304,11 @@ async def mod_loop(self):
                     member=member,
                     reason=t.log_unmuted_expired,
                 )
+
                 await Mute.deactivate(mute.id)
 
+                await redis.hdel(mute_entries_key, key)
+
     @log_auto_kick.subscribe
     async def handle_log_auto_kick(self, member: Member):
         await Kick.create(member.id, str(member), None, None, None, None)
@@ -645,7 +691,7 @@ async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         evidence_url = evidence.url if attachments else None
 
         if not evidence:
-            if not confirm_no_evidence(ctx):
+            if not await confirm_no_evidence(ctx):
                 return
 
         user_embed = Embed(
@@ -801,7 +847,7 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
         evidence_url = evidence.url if attachments else None
 
         if not evidence:
-            if not confirm_no_evidence(ctx):
+            if not await confirm_no_evidence(ctx):
                 return
 
         user_embed = Embed(title=t.mute, colour=Colors.ModTools)
@@ -818,6 +864,8 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
             evidence_url,
         )
 
+        await invalidate_entry_cache()
+
         await send_to_changelog_mod(
             guild=ctx.guild,
             message=ctx.message,
@@ -946,6 +994,8 @@ async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time
 
         await Mute.edit_duration(mute.id, ctx.author.id, await get_mod_level(ctx.author), minutes)
 
+        await invalidate_entry_cache()
+
         user_embed.description = t.mute_edited.duration(
             time_to_units(mute.minutes),
             t.infinity if minutes is None else time_to_units(minutes),
@@ -998,6 +1048,8 @@ async def delete_mute(self, ctx: Context, mute_id: int):
 
         await Mute.delete(mute_id)
 
+        await invalidate_entry_cache()
+
         server_embed = Embed(title=t.mute, description=t.mute_deleted_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
@@ -1052,6 +1104,9 @@ async def unmute(self, ctx: Context, user: UserMemberConverter, *, reason: str):
                 raise CommandError(tg.permission_denied)
 
             await Mute.deactivate(mute.id, ctx.author.id, reason)
+
+            await invalidate_entry_cache()
+
             was_muted = True
         if not was_muted:
             raise UserCommandError(user, t.not_muted)
@@ -1090,7 +1145,7 @@ async def kick(self, ctx: Context, member: Member, *, reason: str):
         evidence_url = evidence.url if attachments else None
 
         if not evidence:
-            if not confirm_no_evidence(ctx):
+            if not await confirm_no_evidence(ctx):
                 return
 
         await Kick.create(member.id, str(member), ctx.author.id, await get_mod_level(ctx.author), reason, evidence_url)
@@ -1266,7 +1321,7 @@ async def ban(
         evidence_url = evidence.url if attachments else None
 
         if not evidence:
-            if not confirm_no_evidence(ctx):
+            if not await confirm_no_evidence(ctx):
                 return
 
         user_embed = Embed(title=t.ban, colour=Colors.ModTools)
@@ -1286,6 +1341,8 @@ async def ban(
             evidence_url,
         )
 
+        await invalidate_entry_cache()
+
         await send_to_changelog_mod(
             guild=ctx.guild,
             message=ctx.message,
@@ -1408,6 +1465,8 @@ async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time:
 
         await Ban.edit_duration(ban.id, ctx.author.id, await get_mod_level(ctx.author), minutes)
 
+        await invalidate_entry_cache()
+
         user_embed.description = t.ban_edited.duration(
             time_to_units(ban.minutes),
             t.infinity if minutes is None else time_to_units(minutes),
@@ -1462,6 +1521,8 @@ async def delete_ban(self, ctx: Context, ban_id: int):
 
         await Ban.delete(ban_id)
 
+        await invalidate_entry_cache()
+
         server_embed = Embed(title=t.mute, description=t.ban_deleted_response, colour=Colors.ModTools)
 
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
@@ -1516,6 +1577,9 @@ async def unban(self, ctx: Context, user: UserMemberConverter, *, reason: str):
                 raise CommandError(tg.permission_denied)
 
             await Ban.deactivate(ban.id, ctx.author.id, reason)
+
+            await invalidate_entry_cache()
+
             was_banned = True
         if not was_banned:
             raise UserCommandError(user, t.not_banned)
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index 093e720b2..bd62d6dbf 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -71,7 +71,7 @@ image_link: "{} [[Go to image]]({})"
 no_dm: ":warning: User does not allow direct messages."
 reason_too_long: "Reason is too long. :pencil:"
 invalid_duration_inf: Invalid duration. Try `inf` instead.
-confirmation: Edit confirmation
+confirmation: Confirmation
 edit_canceled: ":x: Edit canceled"
 edit_confirmed: ":white_check_mark: Edit confirmed"
 infinity: Permanent

From 882a44675de195cfedec62f8cb3a0e684672a970 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Sun, 6 Mar 2022 11:01:28 +0100
Subject: [PATCH 085/120] Improved code style

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 615 ++++++++++++++++++++++++++----------------
 1 file changed, 385 insertions(+), 230 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 8006a44e9..760faa5a1 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -67,7 +67,10 @@ async def convert(self, ctx, argument: str) -> Optional[int]:
         if (match := re.match(r"^(\d+w)?(\d+d)?(\d+h)?(\d+m)?$", argument)) is None:
             raise BadArgument(tg.invalid_duration)
 
-        weeks, days, hours, minutes = [0 if (value := match.group(i)) is None else int(value[:-1]) for i in range(1, 5)]
+        weeks, days, hours, minutes = [
+            0 if (value := match.group(i)) is None else int(value[:-1])
+            for i in range(1, 5)
+        ]
 
         days += weeks * 7
         td = timedelta(days=days, hours=hours, minutes=minutes)
@@ -89,14 +92,15 @@ async def fill(db_model: Type[Base]):
                 if entry.minutes == -1:
                     continue
 
-                expiration_timestamp = entry.timestamp + timedelta(minutes=entry.minutes)
+                expiration_timestamp = entry.timestamp + timedelta(
+                    minutes=entry.minutes
+                )
 
                 await pipe.hmset(entry_key, {str(entry.id): str(expiration_timestamp)})
 
             await pipe.expire(entry_key, CACHE_TTL)
             await pipe.execute()
 
-
     if await redis.exists(load_key := "mod_entries_loaded"):
         return
 
@@ -122,7 +126,9 @@ def get_func(key, value):
         func = getattr(t.times, key)
         return func(cnt=value)
 
-    return ", ".join(get_func(key, time) for key in _keys if (time := getattr(rd, key)) != 0)
+    return ", ".join(
+        get_func(key, time) for key in _keys if (time := getattr(rd, key)) != 0
+    )
 
 
 async def get_mute_role(guild: Guild) -> Role:
@@ -207,7 +213,9 @@ async def send_to_changelog_mod(
     embed.add_field(name=t.log_field.member_id, value=str(member_id), inline=True)
 
     if message:
-        embed.set_footer(text=str(message.author), icon_url=message.author.display_avatar.url)
+        embed.set_footer(
+            text=str(message.author), icon_url=message.author.display_avatar.url
+        )
         embed.add_field(
             name=t.log_field.channel,
             value=t.jump_url(message.channel.mention, message.jump_url),
@@ -218,7 +226,11 @@ async def send_to_changelog_mod(
         embed.add_field(name=t.log_field.duration, value=duration, inline=True)
 
     if evidence:
-        embed.add_field(name=t.log_field.evidence, value=t.image_link(evidence.filename, evidence.url), inline=True)
+        embed.add_field(
+            name=t.log_field.evidence,
+            value=t.image_link(evidence.filename, evidence.url),
+            inline=True,
+        )
 
     embed.add_field(name=t.log_field.reason, value=reason, inline=False)
 
@@ -226,7 +238,12 @@ async def send_to_changelog_mod(
 
 
 class ModCog(Cog, name="Mod Tools"):
-    CONTRIBUTORS = [Contributor.Defelo, Contributor.wolflu, Contributor.Florian, Contributor.LoC]
+    CONTRIBUTORS = [
+        Contributor.Defelo,
+        Contributor.wolflu,
+        Contributor.Florian,
+        Contributor.LoC,
+    ]
 
     async def on_ready(self):
         guild: Guild = self.bot.guilds[0]
@@ -248,10 +265,14 @@ async def mod_loop(self):
         guild: Guild = self.bot.guilds[0]
         await load_entries()
 
-        ban_keys = await redis.hkeys(ban_entries_key := f"mod_entries:{Ban.__tablename__}")
+        ban_keys = await redis.hkeys(
+            ban_entries_key := f"mod_entries:{Ban.__tablename__}"
+        )
 
         for key in ban_keys:
-            if utcnow() >= datetime.fromisoformat(await redis.hget(ban_entries_key, key)):
+            if utcnow() >= datetime.fromisoformat(
+                await redis.hget(ban_entries_key, key)
+            ):
                 ban = await db.get(Ban, id=int(key))
 
                 try:
@@ -285,10 +306,14 @@ async def mod_loop(self):
             await send_alert(guild, t.cannot_assign_mute_role(mute_role, mute_role.id))
             return
 
-        mute_keys = await redis.hkeys(mute_entries_key := f"mod_entries:{Mute.__tablename__}")
+        mute_keys = await redis.hkeys(
+            mute_entries_key := f"mod_entries:{Mute.__tablename__}"
+        )
 
         for key in mute_keys:
-            if utcnow() >= datetime.fromisoformat(await redis.hget(mute_entries_key, key)):
+            if utcnow() >= datetime.fromisoformat(
+                await redis.hget(mute_entries_key, key)
+            ):
                 mute = await db.get(Mute, id=int(key))
 
                 if member := guild.get_member(mute.member):
@@ -314,7 +339,9 @@ async def handle_log_auto_kick(self, member: Member):
         await Kick.create(member.id, str(member), None, None, None, None)
 
     @get_user_info_entries.subscribe
-    async def handle_get_user_stats_entries(self, user_id: int) -> list[tuple[str, str]]:
+    async def handle_get_user_stats_entries(
+        self, user_id: int
+    ) -> list[tuple[str, str]]:
         out: list[tuple[str, str]] = []
 
         async def count(cls):
@@ -326,8 +353,14 @@ async def count(cls):
             passive = await db.count(filter_by(cls, member=user_id))
 
             if cls is Kick:
-                if auto_kicks := await db.count(filter_by(cls, member=user_id, mod=None)):
-                    return t.active_passive(active, passive - auto_kicks) + "\n" + t.autokicks(cnt=auto_kicks)
+                if auto_kicks := await db.count(
+                    filter_by(cls, member=user_id, mod=None)
+                ):
+                    return (
+                        t.active_passive(active, passive - auto_kicks)
+                        + "\n"
+                        + t.autokicks(cnt=auto_kicks)
+                    )
 
             return t.active_passive(active, passive)
 
@@ -340,19 +373,25 @@ async def count(cls):
         return out
 
     @get_user_status_entries.subscribe
-    async def handle_get_user_status_entries(self, user_id: int) -> list[tuple[str, str]]:
+    async def handle_get_user_status_entries(
+        self, user_id: int
+    ) -> list[tuple[str, str]]:
         status = t.none
         if (ban := await db.get(Ban, member=user_id, active=True)) is not None:
             if ban.minutes != -1:
                 expiry_date: datetime = ban.timestamp + timedelta(minutes=ban.minutes)
-                time_left = time_to_units((expiry_date - utcnow()).total_seconds() / 60 + 1)
+                time_left = time_to_units(
+                    (expiry_date - utcnow()).total_seconds() / 60 + 1
+                )
                 status = t.status_banned_time(time_to_units(ban.minutes), time_left)
             else:
                 status = t.status_banned
         elif (mute := await db.get(Mute, member=user_id, active=True)) is not None:
             if mute.minutes != -1:
                 expiry_date: datetime = mute.timestamp + timedelta(minutes=mute.minutes)
-                time_left = time_to_units((expiry_date - utcnow()).total_seconds() / 60 + 1)
+                time_left = time_to_units(
+                    (expiry_date - utcnow()).total_seconds() / 60 + 1
+                )
                 status = t.status_muted_time(time_to_units(mute.minutes), time_left)
             else:
                 status = t.status_muted
@@ -365,193 +404,177 @@ async def handle_get_userlog_entries(
         show_ids: bool,
         author: Member,
     ) -> list[tuple[datetime, str]]:
+        def wrap_time_entry(
+            translation,
+            mod: int,
+            reason: str,
+            evidence: str,
+            minutes: Optional[int] = None,
+            entry_id: Optional[int] = None,
+        ) -> str:
+            if minutes:
+                if id:
+                    return translation.temp.id_on(
+                        f"<@{mod}>",
+                        time_to_units(minutes),
+                        reason,
+                        entry_id,
+                        show_evidence(evidence),
+                    )
+                else:
+                    return translation.temp.id_off(
+                        f"<@{mod}>",
+                        time_to_units(minutes),
+                        reason,
+                        show_evidence(evidence),
+                    )
+            else:
+                if id:
+                    return translation.inf.id_on(
+                        f"<@{mod}>", reason, entry_id, show_evidence(evidence)
+                    )
+                else:
+                    return translation.inf.id_on(
+                        f"<@{mod}>", reason, show_evidence(evidence)
+                    )
+
+        def wrap_entry(
+            translation,
+            user: int,
+            reason: str,
+            evidence: Optional[str],
+            entry_id: Optional[int] = None,
+        ) -> str:
+            if entry_id:
+                return translation.id_on(
+                    f"<@{user}>", reason, entry_id, show_evidence(evidence)
+                )
+            else:
+                return translation.id_off(f"<@{user}>", reason, show_evidence(evidence))
+
         out: list[tuple[datetime, str]] = []
 
         if await is_teamler(author):
             report: Report
             async for report in await db.stream(filter_by(Report, member=user_id)):
-                if show_ids:
-                    out.append(
-                        (
-                            report.timestamp,
-                            t.ulog.reported.id_on(
-                                f"<@{report.reporter}>",
-                                report.reason,
-                                report.id,
-                                show_evidence(report.evidence),
-                            ),
-                        ),
-                    )
-                else:
-                    out.append(
-                        (
-                            report.timestamp,
-                            t.ulog.reported.id_off(
-                                f"<@{report.reporter}>",
-                                report.reason,
-                                show_evidence(report.evidence),
-                            ),
+                out.append(
+                    (
+                        report.timestamp,
+                        wrap_entry(
+                            t.ulog.reported,
+                            report.reporter,
+                            report.reason,
+                            report.evidence,
+                            report.id if show_ids else None,
                         ),
-                    )
+                    ),
+                )
 
         warn: Warn
         async for warn in await db.stream(filter_by(Warn, member=user_id)):
-            if show_ids:
-                out.append(
-                    (
-                        warn.timestamp,
-                        t.ulog.warned.id_on(f"<@{warn.mod}>", warn.reason, warn.id, show_evidence(warn.evidence)),
+            out.append(
+                (
+                    warn.timestamp,
+                    wrap_entry(
+                        t.ulog.warned,
+                        warn.mod,
+                        warn.reason,
+                        warn.evidence,
+                        warn.id if show_ids else None,
                     ),
-                )
-            else:
-                out.append(
-                    (warn.timestamp, t.ulog.warned.id_off(f"<@{warn.mod}>", warn.reason, show_evidence(warn.evidence))),
-                )
+                ),
+            )
 
         mute: Mute
         async for mute in await db.stream(filter_by(Mute, member=user_id)):
-            if mute.minutes == -1:
-                if show_ids:
-                    out.append(
-                        (
-                            mute.timestamp,
-                            t.ulog.muted.inf.id_on(f"<@{mute.mod}>", mute.reason, mute.id, show_evidence(mute.evidence)),
-                        ),
-                    )
-                else:
-                    out.append(
-                        (mute.timestamp, t.ulog.muted.inf.id_off(f"<@{mute.mod}>", mute.reason, show_evidence(mute.evidence))),
-                    )
-            else:
-                if show_ids:
-                    out.append(
-                        (
-                            mute.timestamp,
-                            t.ulog.muted.temp.id_on(
-                                f"<@{mute.mod}>",
-                                time_to_units(mute.minutes),
-                                mute.reason,
-                                mute.id,
-                                show_evidence(mute.evidence),
-                            ),
-                        ),
-                    )
-                else:
-                    out.append(
-                        (
-                            mute.timestamp,
-                            t.ulog.muted.temp.id_off(
-                                f"<@{mute.mod}>",
-                                time_to_units(mute.minutes),
-                                mute.reason,
-                                show_evidence(mute.evidence),
-                            ),
-                        ),
-                    )
+            out.append(
+                (
+                    mute.timestamp,
+                    wrap_time_entry(
+                        translation=t.muted,
+                        mod=mute.mod,
+                        reason=mute.reason,
+                        evidence=mute.evidence,
+                        minutes=mute.minutes if mute.minutes != -1 else None,
+                        entry_id=mute.id if show_ids else None,
+                    ),
+                ),
+            )
 
             if not mute.active:
                 if mute.unmute_mod is None:
                     out.append((mute.deactivation_timestamp, t.ulog.unmuted_expired))
                 else:
-                    if show_ids:
-                        out.append(
-                            (
-                                mute.deactivation_timestamp,
-                                t.ulog.unmuted.id_on(f"<@{mute.unmute_mod}>", mute.unmute_reason, mute.id),
-                            ),
-                        )
-                    else:
-                        out.append(
-                            (
-                                mute.deactivation_timestamp,
-                                t.ulog.unmuted.id_off(f"<@{mute.unmute_mod}>", mute.unmute_reason),
+                    out.append(
+                        (
+                            mute.deactivation_timestamp,
+                            wrap_entry(
+                                translation=t.unmuted,
+                                user=mute.unmute_mod,
+                                reason=mute.unmute_reason,
+                                evidence=None,
+                                entry_id=mute.id if show_ids else None,
                             ),
                         )
+                    )
 
         kick: Kick
         async for kick in await db.stream(filter_by(Kick, member=user_id)):
             if kick.mod is not None:
-                if show_ids:
-                    out.append(
-                        (
-                            kick.timestamp,
-                            t.ulog.kicked.id_on(f"<@{kick.mod}>", kick.reason, kick.id, show_evidence(kick.evidence)),
-                        ),
-                    )
-                else:
-                    out.append(
-                        (
-                            kick.timestamp,
-                            t.ulog.kicked.id_off(f"<@{kick.mod}>", kick.reason, show_evidence(kick.evidence)),
+                out.append(
+                    (
+                        kick.timestamp,
+                        wrap_entry(
+                            t.ulog.kicked,
+                            kick.mod,
+                            kick.reason,
+                            kick.evidence,
+                            kick.id if show_ids else None,
                         ),
-                    )
+                    ),
+                )
             else:
                 out.append((kick.timestamp, t.ulog.autokicked))
 
         ban: Ban
         async for ban in await db.stream(filter_by(Ban, member=user_id)):
-            if ban.minutes == -1:
-                if show_ids:
-                    out.append(
-                        (
-                            ban.timestamp,
-                            t.ulog.banned.inf.id_on(f"<@{ban.mod}>", ban.reason, ban.id, show_evidence(ban.evidence)),
-                        ),
-                    )
-                else:
-                    out.append(
-                        (ban.timestamp, t.ulog.banned.inf.id_off(f"<@{ban.mod}>", ban.reason, show_evidence(ban.evidence))),
-                    )
-            else:
-                if show_ids:
-                    out.append(
-                        (
-                            ban.timestamp,
-                            t.ulog.banned.temp.id_on(
-                                f"<@{ban.mod}>",
-                                time_to_units(ban.minutes),
-                                ban.reason,
-                                ban.id,
-                                show_evidence(ban.evidence),
-                            ),
-                        ),
-                    )
-                else:
-                    out.append(
-                        (
-                            ban.timestamp,
-                            t.ulog.banned.temp.id_off(
-                                f"<@{ban.mod}>",
-                                time_to_units(ban.minutes),
-                                ban.reason,
-                                show_evidence(ban.evidence),
-                            ),
-                        ),
-                    )
+            out.append(
+                (
+                    ban.timestamp,
+                    wrap_time_entry(
+                        translation=t.banned,
+                        mod=ban.mod,
+                        reason=ban.reason,
+                        evidence=ban.evidence,
+                        minutes=ban.minutes if ban.minutes != -1 else None,
+                        entry_id=ban.id if show_ids else None,
+                    ),
+                ),
+            )
 
             if not ban.active:
                 if ban.unban_mod is None:
                     out.append((ban.deactivation_timestamp, t.ulog.unbanned_expired))
                 else:
-                    if show_ids:
-                        out.append(
-                            (
-                                ban.deactivation_timestamp,
-                                t.ulog.unbanned.id_on(f"<@{ban.unban_mod}>", ban.unban_reason, ban.id),
-                            ),
-                        )
-                    else:
-                        out.append(
-                            (
-                                ban.deactivation_timestamp,
-                                t.ulog.unbanned.id_off(f"<@{ban.unban_mod}>", ban.unban_reason),
+                    out.append(
+                        (
+                            ban.deactivation_timestamp,
+                            wrap_entry(
+                                translation=t.unbanned,
+                                user=ban.unban_mod,
+                                reason=ban.unban_reason,
+                                evidence=None,
+                                entry_id=ban.id if show_ids else None,
                             ),
                         )
+                    )
 
         return out
 
     async def on_member_join(self, member: Member):
-        mute_role: Optional[Role] = member.guild.get_role(await RoleSettings.get("mute"))
+        mute_role: Optional[Role] = member.guild.get_role(
+            await RoleSettings.get("mute")
+        )
         if mute_role is None:
             return
 
@@ -564,7 +587,9 @@ async def on_member_ban(self, guild: Guild, member: Member):
 
             try:
                 entry: AuditLogEntry
-                async for entry in guild.audit_logs(limit=search_limit, action=AuditLogAction.ban):
+                async for entry in guild.audit_logs(
+                    limit=search_limit, action=AuditLogAction.ban
+                ):
                     if entry.user == self.bot.user:
                         continue
 
@@ -593,14 +618,17 @@ async def on_member_ban(self, guild: Guild, member: Member):
                         )
 
                     else:
-                        await send_alert(guild, t.alert_member_banned(str(entry.target), str(entry.user)))
+                        await send_alert(
+                            guild,
+                            t.alert_member_banned(str(entry.target), str(entry.user)),
+                        )
 
                     return
 
             except Forbidden:
                 await send_alert(guild, t.cannot_fetch_audit_logs)
 
-            await sleep(delay=i*10)
+            await sleep(delay=i * 10)
             search_limit -= i * 10
 
     @commands.command()
@@ -639,7 +667,9 @@ async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
             color=Colors.ModTools,
         )
 
-        if not await confirm_action(ctx, conf_embed, t.report_confirmed, t.report_canceled):
+        if not await confirm_action(
+            ctx, conf_embed, t.report_confirmed, t.report_canceled
+        ):
             return
 
         attachments = ctx.message.attachments
@@ -647,7 +677,9 @@ async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         evidence_url = evidence.url if attachments else None
 
         await Report.create(user.id, str(user), ctx.author.id, reason, evidence_url)
-        server_embed = Embed(title=t.report, description=t.reported_response, colour=Colors.ModTools)
+        server_embed = Embed(
+            title=t.report, description=t.reported_response, colour=Colors.ModTools
+        )
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
         await reply(ctx, embed=server_embed)
 
@@ -700,14 +732,23 @@ async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
             description=t.warned(ctx.author.mention, ctx.guild.name, reason),
         )
 
-        server_embed = Embed(title=t.warn, description=t.warned_response, colour=Colors.ModTools)
+        server_embed = Embed(
+            title=t.warn, description=t.warned_response, colour=Colors.ModTools
+        )
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
         try:
             await user.send(embed=user_embed)
         except (Forbidden, HTTPException):
             server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
             server_embed.colour = Colors.error
-        await Warn.create(user.id, str(user), ctx.author.id, await get_mod_level(ctx.author), reason, evidence_url)
+        await Warn.create(
+            user.id,
+            str(user),
+            ctx.author.id,
+            await get_mod_level(ctx.author),
+            reason,
+            evidence_url,
+        )
         await reply(ctx, embed=server_embed)
         await send_to_changelog_mod(
             guild=ctx.guild,
@@ -716,7 +757,7 @@ async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
             title=t.log_warned,
             member=user,
             reason=reason,
-            evidence=evidence
+            evidence=evidence,
         )
 
     @commands.command(aliases=["warn_edit"])
@@ -748,7 +789,9 @@ async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
             description=t.warn_edited(warn.reason, reason),
             colour=Colors.ModTools,
         )
-        server_embed = Embed(title=t.warn, description=t.warn_edited_response, colour=Colors.ModTools)
+        server_embed = Embed(
+            title=t.warn, description=t.warn_edited_response, colour=Colors.ModTools
+        )
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
         await Warn.edit(warn_id, ctx.author.id, await get_mod_level(ctx.author), reason)
@@ -765,7 +808,7 @@ async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
             colour=Colors.warn,
             title=t.log_warn_edited,
             member=user,
-            reason=reason
+            reason=reason,
         )
 
     @commands.command(aliases=["warn_delete"])
@@ -791,7 +834,9 @@ async def delete_warn(self, ctx: Context, warn_id: int):
         except (NotFound, HTTPException):
             raise CommandError(t.user_not_found)
 
-        server_embed = Embed(title=t.warn, description=t.warn_deleted_response, colour=Colors.ModTools)
+        server_embed = Embed(
+            title=t.warn, description=t.warn_deleted_response, colour=Colors.ModTools
+        )
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
         if await ModSettings.send_delete_user_message.get():
@@ -814,14 +859,21 @@ async def delete_warn(self, ctx: Context, warn_id: int):
             colour=Colors.warn,
             title=t.log_warn_deleted,
             member=user,
-            reason=warn.reason
+            reason=warn.reason,
         )
 
     @commands.command()
     @ModPermission.mute.check
     @guild_only()
     @docs(t.commands.mute)
-    async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConverter, *, reason: str):
+    async def mute(
+        self,
+        ctx: Context,
+        user: UserMemberConverter,
+        time: DurationConverter,
+        *,
+        reason: str,
+    ):
         user: Union[Member, User]
 
         time: Optional[int]
@@ -851,7 +903,9 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
                 return
 
         user_embed = Embed(title=t.mute, colour=Colors.ModTools)
-        server_embed = Embed(title=t.mute, description=t.muted_response, colour=Colors.ModTools)
+        server_embed = Embed(
+            title=t.mute, description=t.muted_response, colour=Colors.ModTools
+        )
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
         await Mute.create(
@@ -873,14 +927,20 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
             title=t.log_muted,
             member=user,
             reason=reason,
-            duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
+            duration=time_to_units(minutes)
+            if minutes is not None
+            else t.log_field.infinity,
             evidence=evidence,
         )
 
         if minutes is not None:
-            user_embed.description = t.muted(ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason)
+            user_embed.description = t.muted(
+                ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason
+            )
         else:
-            user_embed.description = t.muted_inf(ctx.author.mention, ctx.guild.name, reason)
+            user_embed.description = t.muted_inf(
+                ctx.author.mention, ctx.guild.name, reason
+            )
 
         try:
             await user.send(embed=user_embed)
@@ -925,10 +985,14 @@ async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
             description=t.mute_edited.reason(mute.reason, reason),
             colour=Colors.ModTools,
         )
-        server_embed = Embed(title=t.mute, description=t.mute_edited_response, colour=Colors.ModTools)
+        server_embed = Embed(
+            title=t.mute, description=t.mute_edited_response, colour=Colors.ModTools
+        )
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-        await Mute.edit_reason(mute_id, ctx.author.id, await get_mod_level(ctx.author), reason)
+        await Mute.edit_reason(
+            mute_id, ctx.author.id, await get_mod_level(ctx.author), reason
+        )
 
         try:
             await user.send(embed=user_embed)
@@ -942,18 +1006,21 @@ async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
             colour=Colors.mute,
             title=t.log_mute_edited,
             member=user,
-            reason=reason
+            reason=reason,
         )
 
     @edit_mute.command(name="duration", aliases=["d"])
     @docs(t.commands.edit_mute_duration)
-    async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time: DurationConverter):
+    async def edit_mute_duration(
+        self, ctx: Context, user: UserMemberConverter, time: DurationConverter
+    ):
         user: Union[Member, User]
         time: Optional[int]
         minutes = time
 
         active_mutes: List[Mute] = sorted(
-            await db.all(filter_by(Mute, active=True, member=user.id)), key=lambda active_mute: active_mute.timestamp,
+            await db.all(filter_by(Mute, active=True, member=user.id)),
+            key=lambda active_mute: active_mute.timestamp,
         )
 
         if not active_mutes:
@@ -961,7 +1028,10 @@ async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time
 
         mute = active_mutes[0]
 
-        if not await compare_mod_level(ctx.author, mute.mod_level) or not ctx.author.id == mute.mod:
+        if (
+            not await compare_mod_level(ctx.author, mute.mod_level)
+            or not ctx.author.id == mute.mod
+        ):
             raise CommandError(tg.permission_denied)
 
         if mute.minutes == minutes or (mute.minutes == -1 and minutes is None):
@@ -977,7 +1047,9 @@ async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time
         if minutes is None:
             conf_embed.description = t.confirm_mute_edit.duration(old_time, t.infinity)
         else:
-            conf_embed.description = t.confirm_mute_edit.duration(old_time, time_to_units(minutes))
+            conf_embed.description = t.confirm_mute_edit.duration(
+                old_time, time_to_units(minutes)
+            )
 
         if not await confirm_action(ctx, conf_embed):
             return
@@ -989,10 +1061,14 @@ async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time
             title=t.mute,
             colour=Colors.ModTools,
         )
-        server_embed = Embed(title=t.mute, description=t.mute_edited_response, colour=Colors.ModTools)
+        server_embed = Embed(
+            title=t.mute, description=t.mute_edited_response, colour=Colors.ModTools
+        )
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-        await Mute.edit_duration(mute.id, ctx.author.id, await get_mod_level(ctx.author), minutes)
+        await Mute.edit_duration(
+            mute.id, ctx.author.id, await get_mod_level(ctx.author), minutes
+        )
 
         await invalidate_entry_cache()
 
@@ -1007,7 +1083,9 @@ async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time
             title=t.log_mute_edited,
             member=user,
             reason=Mute.reason,
-            duration=t.log_field.infinity if minutes is None else time_to_units(minutes),
+            duration=t.log_field.infinity
+            if minutes is None
+            else time_to_units(minutes),
         )
 
         try:
@@ -1033,7 +1111,9 @@ async def delete_mute(self, ctx: Context, mute_id: int):
         if not await confirm_action(ctx, conf_embed):
             return
 
-        active_mutes: List[Mute] = await db.all(filter_by(Mute, active=True, member=mute.member))
+        active_mutes: List[Mute] = await db.all(
+            filter_by(Mute, active=True, member=mute.member)
+        )
 
         if len(active_mutes) == 1 and mute in active_mutes:
             user = ctx.guild.get_member(mute.member)
@@ -1050,7 +1130,9 @@ async def delete_mute(self, ctx: Context, mute_id: int):
 
         await invalidate_entry_cache()
 
-        server_embed = Embed(title=t.mute, description=t.mute_deleted_response, colour=Colors.ModTools)
+        server_embed = Embed(
+            title=t.mute, description=t.mute_deleted_response, colour=Colors.ModTools
+        )
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
         if await ModSettings.send_delete_user_message.get():
@@ -1062,7 +1144,9 @@ async def delete_mute(self, ctx: Context, mute_id: int):
             if mute.minutes == -1:
                 user_embed.description = t.mute_deleted.inf(mute.reason)
             else:
-                user_embed.description = t.mute_deleted.not_inf(time_to_units(mute.minutes), mute.reason)
+                user_embed.description = t.mute_deleted.not_inf(
+                    time_to_units(mute.minutes), mute.reason
+                )
 
             try:
                 await user.send(embed=user_embed)
@@ -1079,7 +1163,9 @@ async def delete_mute(self, ctx: Context, mute_id: int):
             title=t.log_mute_deleted,
             member=user,
             reason=mute.reason,
-            duration=t.log_field_infinity if mute.minutes == -1 else time_to_units(mute.minutes),
+            duration=t.log_field_infinity
+            if mute.minutes == -1
+            else time_to_units(mute.minutes),
         )
 
     @commands.command()
@@ -1100,7 +1186,10 @@ async def unmute(self, ctx: Context, user: UserMemberConverter, *, reason: str):
             await user.remove_roles(mute_role)
 
         async for mute in await db.stream(filter_by(Mute, active=True, member=user.id)):
-            if not await compare_mod_level(ctx.author, mute.mod_level) or not ctx.author.id == mute.mod:
+            if (
+                not await compare_mod_level(ctx.author, mute.mod_level)
+                or not ctx.author.id == mute.mod
+            ):
                 raise CommandError(tg.permission_denied)
 
             await Mute.deactivate(mute.id, ctx.author.id, reason)
@@ -1111,7 +1200,9 @@ async def unmute(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         if not was_muted:
             raise UserCommandError(user, t.not_muted)
 
-        server_embed = Embed(title=t.unmute, description=t.unmuted_response, colour=Colors.ModTools)
+        server_embed = Embed(
+            title=t.unmute, description=t.unmuted_response, colour=Colors.ModTools
+        )
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
         await reply(ctx, embed=server_embed)
         await send_to_changelog_mod(
@@ -1120,7 +1211,7 @@ async def unmute(self, ctx: Context, user: UserMemberConverter, *, reason: str):
             colour=Colors.unmute,
             title=t.log_unmuted,
             member=user,
-            reason=reason
+            reason=reason,
         )
 
     @commands.command()
@@ -1148,7 +1239,14 @@ async def kick(self, ctx: Context, member: Member, *, reason: str):
             if not await confirm_no_evidence(ctx):
                 return
 
-        await Kick.create(member.id, str(member), ctx.author.id, await get_mod_level(ctx.author), reason, evidence_url)
+        await Kick.create(
+            member.id,
+            str(member),
+            ctx.author.id,
+            await get_mod_level(ctx.author),
+            reason,
+            evidence_url,
+        )
         await send_to_changelog_mod(
             guild=ctx.guild,
             message=ctx.message,
@@ -1162,10 +1260,14 @@ async def kick(self, ctx: Context, member: Member, *, reason: str):
         user_embed = Embed(
             title=t.kick,
             colour=Colors.ModTools,
-            description=t.kicked.no_evidence(ctx.author.mention, ctx.guild.name, reason),
+            description=t.kicked.no_evidence(
+                ctx.author.mention, ctx.guild.name, reason
+            ),
         )
 
-        server_embed = Embed(title=t.kick, description=t.kicked_response, colour=Colors.ModTools)
+        server_embed = Embed(
+            title=t.kick, description=t.kicked_response, colour=Colors.ModTools
+        )
         server_embed.set_author(name=str(member), icon_url=member.display_avatar.url)
 
         try:
@@ -1208,7 +1310,9 @@ async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
             description=t.kick_edited(kick.reason, reason),
             colour=Colors.ModTools,
         )
-        server_embed = Embed(title=t.kick, description=t.kick_edited_reponse, colour=Colors.ModTools)
+        server_embed = Embed(
+            title=t.kick, description=t.kick_edited_reponse, colour=Colors.ModTools
+        )
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
         await Kick.edit(kick_id, ctx.author.id, await get_mod_level(ctx.author), reason)
@@ -1225,7 +1329,7 @@ async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
             colour=Colors.kick,
             title=t.log_kick_edited,
             member=user,
-            reason=reason
+            reason=reason,
         )
 
     @commands.command(aliases=["kick_delete"])
@@ -1251,7 +1355,9 @@ async def delete_kick(self, ctx: Context, kick_id: int):
         except (NotFound, HTTPException):
             raise CommandError(t.user_not_found)
 
-        server_embed = Embed(title=t.warn, description=t.kick_deleted_response, colour=Colors.ModTools)
+        server_embed = Embed(
+            title=t.warn, description=t.kick_deleted_response, colour=Colors.ModTools
+        )
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
         if await ModSettings.send_delete_user_message.get():
@@ -1274,7 +1380,7 @@ async def delete_kick(self, ctx: Context, kick_id: int):
             colour=Colors.kick,
             title=t.log_kick_deleted,
             member=user,
-            reason=kick.reason
+            reason=kick.reason,
         )
 
     @commands.command()
@@ -1305,14 +1411,20 @@ async def ban(
 
         if user == self.bot.user or await is_teamler(user):
             raise UserCommandError(user, t.cannot_ban)
-        if isinstance(user, Member) and (user.top_role >= ctx.guild.me.top_role or user.id == ctx.guild.owner_id):
+        if isinstance(user, Member) and (
+            user.top_role >= ctx.guild.me.top_role or user.id == ctx.guild.owner_id
+        ):
             raise UserCommandError(user, t.cannot_ban)
 
-        active_bans: List[Ban] = await db.all(filter_by(Ban, active=True, member=user.id))
+        active_bans: List[Ban] = await db.all(
+            filter_by(Ban, active=True, member=user.id)
+        )
         if active_bans:
             raise UserCommandError(user, t.already_banned)
 
-        active_mutes: List[Mute] = await db.all(filter_by(Mute, active=True, member=user.id))
+        active_mutes: List[Mute] = await db.all(
+            filter_by(Mute, active=True, member=user.id)
+        )
         for mute in active_mutes:
             await Mute.deactivate(mute.id, ctx.author.id, t.cancelled_by_ban)
 
@@ -1325,7 +1437,9 @@ async def ban(
                 return
 
         user_embed = Embed(title=t.ban, colour=Colors.ModTools)
-        server_embed = Embed(title=t.ban, description=t.banned_response, colour=Colors.ModTools)
+        server_embed = Embed(
+            title=t.ban, description=t.banned_response, colour=Colors.ModTools
+        )
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
         if active_mutes:
@@ -1348,17 +1462,23 @@ async def ban(
             message=ctx.message,
             colour=Colors.ban,
             title=t.log_banned,
-            member= user,
+            member=user,
             reason=reason,
-            duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
+            duration=time_to_units(minutes)
+            if minutes is not None
+            else t.log_field.infinity,
             evidence=evidence,
         )
 
         if minutes is not None:
-            user_embed.description = t.banned(ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason)
+            user_embed.description = t.banned(
+                ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason
+            )
 
         else:
-            user_embed.description = t.banned_inf(ctx.author.mention, ctx.guild.name, reason)
+            user_embed.description = t.banned_inf(
+                ctx.author.mention, ctx.guild.name, reason
+            )
 
         try:
             await user.send(embed=user_embed)
@@ -1401,11 +1521,19 @@ async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
         except (NotFound, HTTPException):
             raise CommandError(t.user_not_found)
 
-        user_embed = Embed(title=t.ban, description=t.ban_edited.reason(ban.reason, reason), colour=Colors.ModTools)
-        server_embed = Embed(title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools)
+        user_embed = Embed(
+            title=t.ban,
+            description=t.ban_edited.reason(ban.reason, reason),
+            colour=Colors.ModTools,
+        )
+        server_embed = Embed(
+            title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools
+        )
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-        await Ban.edit_reason(ban_id, ctx.author.id, await get_mod_level(ctx.author), reason)
+        await Ban.edit_reason(
+            ban_id, ctx.author.id, await get_mod_level(ctx.author), reason
+        )
 
         try:
             await user.send(embed=user_embed)
@@ -1419,18 +1547,21 @@ async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
             colour=Colors.ban,
             title=t.log_ban_edited,
             member=user,
-            reason=reason
+            reason=reason,
         )
 
     @edit_ban.command(name="duration", aliases=["d"])
     @docs(t.commands.edit_ban_duration)
-    async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time: DurationConverter):
+    async def edit_ban_duration(
+        self, ctx: Context, user: UserMemberConverter, time: DurationConverter
+    ):
         user: Union[Member, User]
         time: Optional[int]
         minutes = time
 
         active_bans: List[Ban] = sorted(
-            await db.all(filter_by(Ban, active=True, member=user.id)), key=lambda active_ban: active_ban.timestamp
+            await db.all(filter_by(Ban, active=True, member=user.id)),
+            key=lambda active_ban: active_ban.timestamp,
         )
 
         if not active_bans:
@@ -1438,7 +1569,10 @@ async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time:
 
         ban = active_bans[0]
 
-        if not await compare_mod_level(ctx.author, ban.mod_level) or not ctx.author.id == ban.mod:
+        if (
+            not await compare_mod_level(ctx.author, ban.mod_level)
+            or not ctx.author.id == ban.mod
+        ):
             raise CommandError(tg.permission_denied)
 
         if ban.minutes == minutes or (ban.minutes == -1 and minutes is None):
@@ -1451,7 +1585,9 @@ async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time:
         if minutes is None:
             conf_embed.description = t.confirm_ban_edit.duration(old_time, t.infinity)
         else:
-            conf_embed.description = t.confirm_ban_edit.duration(old_time, time_to_units(minutes))
+            conf_embed.description = t.confirm_ban_edit.duration(
+                old_time, time_to_units(minutes)
+            )
 
         if not await confirm_action(ctx, conf_embed):
             return
@@ -1460,10 +1596,14 @@ async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time:
             await Ban.delete(ban.id)
 
         user_embed = Embed(title=t.ban, colour=Colors.ModTools)
-        server_embed = Embed(title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools)
+        server_embed = Embed(
+            title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools
+        )
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-        await Ban.edit_duration(ban.id, ctx.author.id, await get_mod_level(ctx.author), minutes)
+        await Ban.edit_duration(
+            ban.id, ctx.author.id, await get_mod_level(ctx.author), minutes
+        )
 
         await invalidate_entry_cache()
 
@@ -1478,7 +1618,9 @@ async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time:
             title=t.log_ban_edited,
             member=user,
             reason=ban.reason,
-            duration=t.log_field.infinity if minutes is None else time_to_units(minutes),
+            duration=t.log_field.infinity
+            if minutes is None
+            else time_to_units(minutes),
         )
 
         try:
@@ -1504,7 +1646,9 @@ async def delete_ban(self, ctx: Context, ban_id: int):
         if not await confirm_action(ctx, conf_embed):
             return
 
-        active_bans: List[Ban] = await db.all(filter_by(Ban, active=True, member=ban.member))
+        active_bans: List[Ban] = await db.all(
+            filter_by(Ban, active=True, member=ban.member)
+        )
 
         if len(active_bans) == 1 and ban in active_bans:
             user = ctx.guild.get_member(ban.member)
@@ -1523,7 +1667,9 @@ async def delete_ban(self, ctx: Context, ban_id: int):
 
         await invalidate_entry_cache()
 
-        server_embed = Embed(title=t.mute, description=t.ban_deleted_response, colour=Colors.ModTools)
+        server_embed = Embed(
+            title=t.mute, description=t.ban_deleted_response, colour=Colors.ModTools
+        )
 
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
@@ -1533,7 +1679,9 @@ async def delete_ban(self, ctx: Context, ban_id: int):
             if ban.minutes == -1:
                 user_embed.description = t.ban_deleted.inf(ban.reason)
             else:
-                user_embed.description = t.ban_deleted.not_inf(time_to_units(ban.minutes), ban.reason)
+                user_embed.description = t.ban_deleted.not_inf(
+                    time_to_units(ban.minutes), ban.reason
+                )
 
             try:
                 await user.send(embed=user_embed)
@@ -1550,7 +1698,9 @@ async def delete_ban(self, ctx: Context, ban_id: int):
             title=t.log_ban_deleted,
             member=user,
             reason=ban.reason,
-            duration=t.log_field_infinity if ban.minutes == -1 else time_to_units(ban.minutes),
+            duration=t.log_field_infinity
+            if ban.minutes == -1
+            else time_to_units(ban.minutes),
         )
 
     @commands.command()
@@ -1573,7 +1723,10 @@ async def unban(self, ctx: Context, user: UserMemberConverter, *, reason: str):
             was_banned = False
 
         async for ban in await db.stream(filter_by(Ban, active=True, member=user.id)):
-            if not await compare_mod_level(ctx.author, ban.mod_level) or not ctx.author.id == ban.mod:
+            if (
+                not await compare_mod_level(ctx.author, ban.mod_level)
+                or not ctx.author.id == ban.mod
+            ):
                 raise CommandError(tg.permission_denied)
 
             await Ban.deactivate(ban.id, ctx.author.id, reason)
@@ -1584,7 +1737,9 @@ async def unban(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         if not was_banned:
             raise UserCommandError(user, t.not_banned)
 
-        server_embed = Embed(title=t.unban, description=t.unbanned_response, colour=Colors.ModTools)
+        server_embed = Embed(
+            title=t.unban, description=t.unbanned_response, colour=Colors.ModTools
+        )
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
         await reply(ctx, embed=server_embed)
         await send_to_changelog_mod(
@@ -1593,5 +1748,5 @@ async def unban(self, ctx: Context, user: UserMemberConverter, *, reason: str):
             colour=Colors.unban,
             title=t.log_unbanned,
             member=user,
-            reason=reason
+            reason=reason,
         )

From 4a0445be68147f2dd2c693e0a125dab0d380dcc6 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Sun, 6 Mar 2022 11:09:15 +0100
Subject: [PATCH 086/120] Made black fix itself

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 275 ++++++++++--------------------------------
 1 file changed, 67 insertions(+), 208 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 760faa5a1..0d946fd43 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -67,10 +67,7 @@ async def convert(self, ctx, argument: str) -> Optional[int]:
         if (match := re.match(r"^(\d+w)?(\d+d)?(\d+h)?(\d+m)?$", argument)) is None:
             raise BadArgument(tg.invalid_duration)
 
-        weeks, days, hours, minutes = [
-            0 if (value := match.group(i)) is None else int(value[:-1])
-            for i in range(1, 5)
-        ]
+        weeks, days, hours, minutes = [0 if (value := match.group(i)) is None else int(value[:-1]) for i in range(1, 5)]
 
         days += weeks * 7
         td = timedelta(days=days, hours=hours, minutes=minutes)
@@ -92,9 +89,7 @@ async def fill(db_model: Type[Base]):
                 if entry.minutes == -1:
                     continue
 
-                expiration_timestamp = entry.timestamp + timedelta(
-                    minutes=entry.minutes
-                )
+                expiration_timestamp = entry.timestamp + timedelta(minutes=entry.minutes)
 
                 await pipe.hmset(entry_key, {str(entry.id): str(expiration_timestamp)})
 
@@ -126,9 +121,7 @@ def get_func(key, value):
         func = getattr(t.times, key)
         return func(cnt=value)
 
-    return ", ".join(
-        get_func(key, time) for key in _keys if (time := getattr(rd, key)) != 0
-    )
+    return ", ".join(get_func(key, time) for key in _keys if (time := getattr(rd, key)) != 0)
 
 
 async def get_mute_role(guild: Guild) -> Role:
@@ -213,9 +206,7 @@ async def send_to_changelog_mod(
     embed.add_field(name=t.log_field.member_id, value=str(member_id), inline=True)
 
     if message:
-        embed.set_footer(
-            text=str(message.author), icon_url=message.author.display_avatar.url
-        )
+        embed.set_footer(text=str(message.author), icon_url=message.author.display_avatar.url)
         embed.add_field(
             name=t.log_field.channel,
             value=t.jump_url(message.channel.mention, message.jump_url),
@@ -265,14 +256,10 @@ async def mod_loop(self):
         guild: Guild = self.bot.guilds[0]
         await load_entries()
 
-        ban_keys = await redis.hkeys(
-            ban_entries_key := f"mod_entries:{Ban.__tablename__}"
-        )
+        ban_keys = await redis.hkeys(ban_entries_key := f"mod_entries:{Ban.__tablename__}")
 
         for key in ban_keys:
-            if utcnow() >= datetime.fromisoformat(
-                await redis.hget(ban_entries_key, key)
-            ):
+            if utcnow() >= datetime.fromisoformat(await redis.hget(ban_entries_key, key)):
                 ban = await db.get(Ban, id=int(key))
 
                 try:
@@ -306,14 +293,10 @@ async def mod_loop(self):
             await send_alert(guild, t.cannot_assign_mute_role(mute_role, mute_role.id))
             return
 
-        mute_keys = await redis.hkeys(
-            mute_entries_key := f"mod_entries:{Mute.__tablename__}"
-        )
+        mute_keys = await redis.hkeys(mute_entries_key := f"mod_entries:{Mute.__tablename__}")
 
         for key in mute_keys:
-            if utcnow() >= datetime.fromisoformat(
-                await redis.hget(mute_entries_key, key)
-            ):
+            if utcnow() >= datetime.fromisoformat(await redis.hget(mute_entries_key, key)):
                 mute = await db.get(Mute, id=int(key))
 
                 if member := guild.get_member(mute.member):
@@ -339,9 +322,7 @@ async def handle_log_auto_kick(self, member: Member):
         await Kick.create(member.id, str(member), None, None, None, None)
 
     @get_user_info_entries.subscribe
-    async def handle_get_user_stats_entries(
-        self, user_id: int
-    ) -> list[tuple[str, str]]:
+    async def handle_get_user_stats_entries(self, user_id: int) -> list[tuple[str, str]]:
         out: list[tuple[str, str]] = []
 
         async def count(cls):
@@ -353,14 +334,8 @@ async def count(cls):
             passive = await db.count(filter_by(cls, member=user_id))
 
             if cls is Kick:
-                if auto_kicks := await db.count(
-                    filter_by(cls, member=user_id, mod=None)
-                ):
-                    return (
-                        t.active_passive(active, passive - auto_kicks)
-                        + "\n"
-                        + t.autokicks(cnt=auto_kicks)
-                    )
+                if auto_kicks := await db.count(filter_by(cls, member=user_id, mod=None)):
+                    return t.active_passive(active, passive - auto_kicks) + "\n" + t.autokicks(cnt=auto_kicks)
 
             return t.active_passive(active, passive)
 
@@ -373,25 +348,19 @@ async def count(cls):
         return out
 
     @get_user_status_entries.subscribe
-    async def handle_get_user_status_entries(
-        self, user_id: int
-    ) -> list[tuple[str, str]]:
+    async def handle_get_user_status_entries(self, user_id: int) -> list[tuple[str, str]]:
         status = t.none
         if (ban := await db.get(Ban, member=user_id, active=True)) is not None:
             if ban.minutes != -1:
                 expiry_date: datetime = ban.timestamp + timedelta(minutes=ban.minutes)
-                time_left = time_to_units(
-                    (expiry_date - utcnow()).total_seconds() / 60 + 1
-                )
+                time_left = time_to_units((expiry_date - utcnow()).total_seconds() / 60 + 1)
                 status = t.status_banned_time(time_to_units(ban.minutes), time_left)
             else:
                 status = t.status_banned
         elif (mute := await db.get(Mute, member=user_id, active=True)) is not None:
             if mute.minutes != -1:
                 expiry_date: datetime = mute.timestamp + timedelta(minutes=mute.minutes)
-                time_left = time_to_units(
-                    (expiry_date - utcnow()).total_seconds() / 60 + 1
-                )
+                time_left = time_to_units((expiry_date - utcnow()).total_seconds() / 60 + 1)
                 status = t.status_muted_time(time_to_units(mute.minutes), time_left)
             else:
                 status = t.status_muted
@@ -430,13 +399,9 @@ def wrap_time_entry(
                     )
             else:
                 if id:
-                    return translation.inf.id_on(
-                        f"<@{mod}>", reason, entry_id, show_evidence(evidence)
-                    )
+                    return translation.inf.id_on(f"<@{mod}>", reason, entry_id, show_evidence(evidence))
                 else:
-                    return translation.inf.id_on(
-                        f"<@{mod}>", reason, show_evidence(evidence)
-                    )
+                    return translation.inf.id_on(f"<@{mod}>", reason, show_evidence(evidence))
 
         def wrap_entry(
             translation,
@@ -446,9 +411,7 @@ def wrap_entry(
             entry_id: Optional[int] = None,
         ) -> str:
             if entry_id:
-                return translation.id_on(
-                    f"<@{user}>", reason, entry_id, show_evidence(evidence)
-                )
+                return translation.id_on(f"<@{user}>", reason, entry_id, show_evidence(evidence))
             else:
                 return translation.id_off(f"<@{user}>", reason, show_evidence(evidence))
 
@@ -572,9 +535,7 @@ def wrap_entry(
         return out
 
     async def on_member_join(self, member: Member):
-        mute_role: Optional[Role] = member.guild.get_role(
-            await RoleSettings.get("mute")
-        )
+        mute_role: Optional[Role] = member.guild.get_role(await RoleSettings.get("mute"))
         if mute_role is None:
             return
 
@@ -587,9 +548,7 @@ async def on_member_ban(self, guild: Guild, member: Member):
 
             try:
                 entry: AuditLogEntry
-                async for entry in guild.audit_logs(
-                    limit=search_limit, action=AuditLogAction.ban
-                ):
+                async for entry in guild.audit_logs(limit=search_limit, action=AuditLogAction.ban):
                     if entry.user == self.bot.user:
                         continue
 
@@ -667,9 +626,7 @@ async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
             color=Colors.ModTools,
         )
 
-        if not await confirm_action(
-            ctx, conf_embed, t.report_confirmed, t.report_canceled
-        ):
+        if not await confirm_action(ctx, conf_embed, t.report_confirmed, t.report_canceled):
             return
 
         attachments = ctx.message.attachments
@@ -677,9 +634,7 @@ async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         evidence_url = evidence.url if attachments else None
 
         await Report.create(user.id, str(user), ctx.author.id, reason, evidence_url)
-        server_embed = Embed(
-            title=t.report, description=t.reported_response, colour=Colors.ModTools
-        )
+        server_embed = Embed(title=t.report, description=t.reported_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
         await reply(ctx, embed=server_embed)
 
@@ -732,9 +687,7 @@ async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
             description=t.warned(ctx.author.mention, ctx.guild.name, reason),
         )
 
-        server_embed = Embed(
-            title=t.warn, description=t.warned_response, colour=Colors.ModTools
-        )
+        server_embed = Embed(title=t.warn, description=t.warned_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
         try:
             await user.send(embed=user_embed)
@@ -789,9 +742,7 @@ async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
             description=t.warn_edited(warn.reason, reason),
             colour=Colors.ModTools,
         )
-        server_embed = Embed(
-            title=t.warn, description=t.warn_edited_response, colour=Colors.ModTools
-        )
+        server_embed = Embed(title=t.warn, description=t.warn_edited_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
         await Warn.edit(warn_id, ctx.author.id, await get_mod_level(ctx.author), reason)
@@ -834,9 +785,7 @@ async def delete_warn(self, ctx: Context, warn_id: int):
         except (NotFound, HTTPException):
             raise CommandError(t.user_not_found)
 
-        server_embed = Embed(
-            title=t.warn, description=t.warn_deleted_response, colour=Colors.ModTools
-        )
+        server_embed = Embed(title=t.warn, description=t.warn_deleted_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
         if await ModSettings.send_delete_user_message.get():
@@ -903,9 +852,7 @@ async def mute(
                 return
 
         user_embed = Embed(title=t.mute, colour=Colors.ModTools)
-        server_embed = Embed(
-            title=t.mute, description=t.muted_response, colour=Colors.ModTools
-        )
+        server_embed = Embed(title=t.mute, description=t.muted_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
         await Mute.create(
@@ -927,20 +874,14 @@ async def mute(
             title=t.log_muted,
             member=user,
             reason=reason,
-            duration=time_to_units(minutes)
-            if minutes is not None
-            else t.log_field.infinity,
+            duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
             evidence=evidence,
         )
 
         if minutes is not None:
-            user_embed.description = t.muted(
-                ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason
-            )
+            user_embed.description = t.muted(ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason)
         else:
-            user_embed.description = t.muted_inf(
-                ctx.author.mention, ctx.guild.name, reason
-            )
+            user_embed.description = t.muted_inf(ctx.author.mention, ctx.guild.name, reason)
 
         try:
             await user.send(embed=user_embed)
@@ -985,14 +926,10 @@ async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
             description=t.mute_edited.reason(mute.reason, reason),
             colour=Colors.ModTools,
         )
-        server_embed = Embed(
-            title=t.mute, description=t.mute_edited_response, colour=Colors.ModTools
-        )
+        server_embed = Embed(title=t.mute, description=t.mute_edited_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-        await Mute.edit_reason(
-            mute_id, ctx.author.id, await get_mod_level(ctx.author), reason
-        )
+        await Mute.edit_reason(mute_id, ctx.author.id, await get_mod_level(ctx.author), reason)
 
         try:
             await user.send(embed=user_embed)
@@ -1011,9 +948,7 @@ async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
 
     @edit_mute.command(name="duration", aliases=["d"])
     @docs(t.commands.edit_mute_duration)
-    async def edit_mute_duration(
-        self, ctx: Context, user: UserMemberConverter, time: DurationConverter
-    ):
+    async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time: DurationConverter):
         user: Union[Member, User]
         time: Optional[int]
         minutes = time
@@ -1028,10 +963,7 @@ async def edit_mute_duration(
 
         mute = active_mutes[0]
 
-        if (
-            not await compare_mod_level(ctx.author, mute.mod_level)
-            or not ctx.author.id == mute.mod
-        ):
+        if not await compare_mod_level(ctx.author, mute.mod_level) or not ctx.author.id == mute.mod:
             raise CommandError(tg.permission_denied)
 
         if mute.minutes == minutes or (mute.minutes == -1 and minutes is None):
@@ -1047,9 +979,7 @@ async def edit_mute_duration(
         if minutes is None:
             conf_embed.description = t.confirm_mute_edit.duration(old_time, t.infinity)
         else:
-            conf_embed.description = t.confirm_mute_edit.duration(
-                old_time, time_to_units(minutes)
-            )
+            conf_embed.description = t.confirm_mute_edit.duration(old_time, time_to_units(minutes))
 
         if not await confirm_action(ctx, conf_embed):
             return
@@ -1061,14 +991,10 @@ async def edit_mute_duration(
             title=t.mute,
             colour=Colors.ModTools,
         )
-        server_embed = Embed(
-            title=t.mute, description=t.mute_edited_response, colour=Colors.ModTools
-        )
+        server_embed = Embed(title=t.mute, description=t.mute_edited_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-        await Mute.edit_duration(
-            mute.id, ctx.author.id, await get_mod_level(ctx.author), minutes
-        )
+        await Mute.edit_duration(mute.id, ctx.author.id, await get_mod_level(ctx.author), minutes)
 
         await invalidate_entry_cache()
 
@@ -1083,9 +1009,7 @@ async def edit_mute_duration(
             title=t.log_mute_edited,
             member=user,
             reason=Mute.reason,
-            duration=t.log_field.infinity
-            if minutes is None
-            else time_to_units(minutes),
+            duration=t.log_field.infinity if minutes is None else time_to_units(minutes),
         )
 
         try:
@@ -1111,9 +1035,7 @@ async def delete_mute(self, ctx: Context, mute_id: int):
         if not await confirm_action(ctx, conf_embed):
             return
 
-        active_mutes: List[Mute] = await db.all(
-            filter_by(Mute, active=True, member=mute.member)
-        )
+        active_mutes: List[Mute] = await db.all(filter_by(Mute, active=True, member=mute.member))
 
         if len(active_mutes) == 1 and mute in active_mutes:
             user = ctx.guild.get_member(mute.member)
@@ -1130,9 +1052,7 @@ async def delete_mute(self, ctx: Context, mute_id: int):
 
         await invalidate_entry_cache()
 
-        server_embed = Embed(
-            title=t.mute, description=t.mute_deleted_response, colour=Colors.ModTools
-        )
+        server_embed = Embed(title=t.mute, description=t.mute_deleted_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
         if await ModSettings.send_delete_user_message.get():
@@ -1144,9 +1064,7 @@ async def delete_mute(self, ctx: Context, mute_id: int):
             if mute.minutes == -1:
                 user_embed.description = t.mute_deleted.inf(mute.reason)
             else:
-                user_embed.description = t.mute_deleted.not_inf(
-                    time_to_units(mute.minutes), mute.reason
-                )
+                user_embed.description = t.mute_deleted.not_inf(time_to_units(mute.minutes), mute.reason)
 
             try:
                 await user.send(embed=user_embed)
@@ -1163,9 +1081,7 @@ async def delete_mute(self, ctx: Context, mute_id: int):
             title=t.log_mute_deleted,
             member=user,
             reason=mute.reason,
-            duration=t.log_field_infinity
-            if mute.minutes == -1
-            else time_to_units(mute.minutes),
+            duration=t.log_field_infinity if mute.minutes == -1 else time_to_units(mute.minutes),
         )
 
     @commands.command()
@@ -1186,10 +1102,7 @@ async def unmute(self, ctx: Context, user: UserMemberConverter, *, reason: str):
             await user.remove_roles(mute_role)
 
         async for mute in await db.stream(filter_by(Mute, active=True, member=user.id)):
-            if (
-                not await compare_mod_level(ctx.author, mute.mod_level)
-                or not ctx.author.id == mute.mod
-            ):
+            if not await compare_mod_level(ctx.author, mute.mod_level) or not ctx.author.id == mute.mod:
                 raise CommandError(tg.permission_denied)
 
             await Mute.deactivate(mute.id, ctx.author.id, reason)
@@ -1200,9 +1113,7 @@ async def unmute(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         if not was_muted:
             raise UserCommandError(user, t.not_muted)
 
-        server_embed = Embed(
-            title=t.unmute, description=t.unmuted_response, colour=Colors.ModTools
-        )
+        server_embed = Embed(title=t.unmute, description=t.unmuted_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
         await reply(ctx, embed=server_embed)
         await send_to_changelog_mod(
@@ -1260,14 +1171,10 @@ async def kick(self, ctx: Context, member: Member, *, reason: str):
         user_embed = Embed(
             title=t.kick,
             colour=Colors.ModTools,
-            description=t.kicked.no_evidence(
-                ctx.author.mention, ctx.guild.name, reason
-            ),
+            description=t.kicked.no_evidence(ctx.author.mention, ctx.guild.name, reason),
         )
 
-        server_embed = Embed(
-            title=t.kick, description=t.kicked_response, colour=Colors.ModTools
-        )
+        server_embed = Embed(title=t.kick, description=t.kicked_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(member), icon_url=member.display_avatar.url)
 
         try:
@@ -1310,9 +1217,7 @@ async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
             description=t.kick_edited(kick.reason, reason),
             colour=Colors.ModTools,
         )
-        server_embed = Embed(
-            title=t.kick, description=t.kick_edited_reponse, colour=Colors.ModTools
-        )
+        server_embed = Embed(title=t.kick, description=t.kick_edited_reponse, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
         await Kick.edit(kick_id, ctx.author.id, await get_mod_level(ctx.author), reason)
@@ -1355,9 +1260,7 @@ async def delete_kick(self, ctx: Context, kick_id: int):
         except (NotFound, HTTPException):
             raise CommandError(t.user_not_found)
 
-        server_embed = Embed(
-            title=t.warn, description=t.kick_deleted_response, colour=Colors.ModTools
-        )
+        server_embed = Embed(title=t.warn, description=t.kick_deleted_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
         if await ModSettings.send_delete_user_message.get():
@@ -1411,20 +1314,14 @@ async def ban(
 
         if user == self.bot.user or await is_teamler(user):
             raise UserCommandError(user, t.cannot_ban)
-        if isinstance(user, Member) and (
-            user.top_role >= ctx.guild.me.top_role or user.id == ctx.guild.owner_id
-        ):
+        if isinstance(user, Member) and (user.top_role >= ctx.guild.me.top_role or user.id == ctx.guild.owner_id):
             raise UserCommandError(user, t.cannot_ban)
 
-        active_bans: List[Ban] = await db.all(
-            filter_by(Ban, active=True, member=user.id)
-        )
+        active_bans: List[Ban] = await db.all(filter_by(Ban, active=True, member=user.id))
         if active_bans:
             raise UserCommandError(user, t.already_banned)
 
-        active_mutes: List[Mute] = await db.all(
-            filter_by(Mute, active=True, member=user.id)
-        )
+        active_mutes: List[Mute] = await db.all(filter_by(Mute, active=True, member=user.id))
         for mute in active_mutes:
             await Mute.deactivate(mute.id, ctx.author.id, t.cancelled_by_ban)
 
@@ -1437,9 +1334,7 @@ async def ban(
                 return
 
         user_embed = Embed(title=t.ban, colour=Colors.ModTools)
-        server_embed = Embed(
-            title=t.ban, description=t.banned_response, colour=Colors.ModTools
-        )
+        server_embed = Embed(title=t.ban, description=t.banned_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
         if active_mutes:
@@ -1464,21 +1359,15 @@ async def ban(
             title=t.log_banned,
             member=user,
             reason=reason,
-            duration=time_to_units(minutes)
-            if minutes is not None
-            else t.log_field.infinity,
+            duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
             evidence=evidence,
         )
 
         if minutes is not None:
-            user_embed.description = t.banned(
-                ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason
-            )
+            user_embed.description = t.banned(ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason)
 
         else:
-            user_embed.description = t.banned_inf(
-                ctx.author.mention, ctx.guild.name, reason
-            )
+            user_embed.description = t.banned_inf(ctx.author.mention, ctx.guild.name, reason)
 
         try:
             await user.send(embed=user_embed)
@@ -1526,14 +1415,10 @@ async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
             description=t.ban_edited.reason(ban.reason, reason),
             colour=Colors.ModTools,
         )
-        server_embed = Embed(
-            title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools
-        )
+        server_embed = Embed(title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-        await Ban.edit_reason(
-            ban_id, ctx.author.id, await get_mod_level(ctx.author), reason
-        )
+        await Ban.edit_reason(ban_id, ctx.author.id, await get_mod_level(ctx.author), reason)
 
         try:
             await user.send(embed=user_embed)
@@ -1552,9 +1437,7 @@ async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
 
     @edit_ban.command(name="duration", aliases=["d"])
     @docs(t.commands.edit_ban_duration)
-    async def edit_ban_duration(
-        self, ctx: Context, user: UserMemberConverter, time: DurationConverter
-    ):
+    async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time: DurationConverter):
         user: Union[Member, User]
         time: Optional[int]
         minutes = time
@@ -1569,10 +1452,7 @@ async def edit_ban_duration(
 
         ban = active_bans[0]
 
-        if (
-            not await compare_mod_level(ctx.author, ban.mod_level)
-            or not ctx.author.id == ban.mod
-        ):
+        if not await compare_mod_level(ctx.author, ban.mod_level) or not ctx.author.id == ban.mod:
             raise CommandError(tg.permission_denied)
 
         if ban.minutes == minutes or (ban.minutes == -1 and minutes is None):
@@ -1585,9 +1465,7 @@ async def edit_ban_duration(
         if minutes is None:
             conf_embed.description = t.confirm_ban_edit.duration(old_time, t.infinity)
         else:
-            conf_embed.description = t.confirm_ban_edit.duration(
-                old_time, time_to_units(minutes)
-            )
+            conf_embed.description = t.confirm_ban_edit.duration(old_time, time_to_units(minutes))
 
         if not await confirm_action(ctx, conf_embed):
             return
@@ -1596,14 +1474,10 @@ async def edit_ban_duration(
             await Ban.delete(ban.id)
 
         user_embed = Embed(title=t.ban, colour=Colors.ModTools)
-        server_embed = Embed(
-            title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools
-        )
+        server_embed = Embed(title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-        await Ban.edit_duration(
-            ban.id, ctx.author.id, await get_mod_level(ctx.author), minutes
-        )
+        await Ban.edit_duration(ban.id, ctx.author.id, await get_mod_level(ctx.author), minutes)
 
         await invalidate_entry_cache()
 
@@ -1618,9 +1492,7 @@ async def edit_ban_duration(
             title=t.log_ban_edited,
             member=user,
             reason=ban.reason,
-            duration=t.log_field.infinity
-            if minutes is None
-            else time_to_units(minutes),
+            duration=t.log_field.infinity if minutes is None else time_to_units(minutes),
         )
 
         try:
@@ -1646,9 +1518,7 @@ async def delete_ban(self, ctx: Context, ban_id: int):
         if not await confirm_action(ctx, conf_embed):
             return
 
-        active_bans: List[Ban] = await db.all(
-            filter_by(Ban, active=True, member=ban.member)
-        )
+        active_bans: List[Ban] = await db.all(filter_by(Ban, active=True, member=ban.member))
 
         if len(active_bans) == 1 and ban in active_bans:
             user = ctx.guild.get_member(ban.member)
@@ -1667,9 +1537,7 @@ async def delete_ban(self, ctx: Context, ban_id: int):
 
         await invalidate_entry_cache()
 
-        server_embed = Embed(
-            title=t.mute, description=t.ban_deleted_response, colour=Colors.ModTools
-        )
+        server_embed = Embed(title=t.mute, description=t.ban_deleted_response, colour=Colors.ModTools)
 
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
@@ -1679,9 +1547,7 @@ async def delete_ban(self, ctx: Context, ban_id: int):
             if ban.minutes == -1:
                 user_embed.description = t.ban_deleted.inf(ban.reason)
             else:
-                user_embed.description = t.ban_deleted.not_inf(
-                    time_to_units(ban.minutes), ban.reason
-                )
+                user_embed.description = t.ban_deleted.not_inf(time_to_units(ban.minutes), ban.reason)
 
             try:
                 await user.send(embed=user_embed)
@@ -1698,9 +1564,7 @@ async def delete_ban(self, ctx: Context, ban_id: int):
             title=t.log_ban_deleted,
             member=user,
             reason=ban.reason,
-            duration=t.log_field_infinity
-            if ban.minutes == -1
-            else time_to_units(ban.minutes),
+            duration=t.log_field_infinity if ban.minutes == -1 else time_to_units(ban.minutes),
         )
 
     @commands.command()
@@ -1723,10 +1587,7 @@ async def unban(self, ctx: Context, user: UserMemberConverter, *, reason: str):
             was_banned = False
 
         async for ban in await db.stream(filter_by(Ban, active=True, member=user.id)):
-            if (
-                not await compare_mod_level(ctx.author, ban.mod_level)
-                or not ctx.author.id == ban.mod
-            ):
+            if not await compare_mod_level(ctx.author, ban.mod_level) or not ctx.author.id == ban.mod:
                 raise CommandError(tg.permission_denied)
 
             await Ban.deactivate(ban.id, ctx.author.id, reason)
@@ -1737,9 +1598,7 @@ async def unban(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         if not was_banned:
             raise UserCommandError(user, t.not_banned)
 
-        server_embed = Embed(
-            title=t.unban, description=t.unbanned_response, colour=Colors.ModTools
-        )
+        server_embed = Embed(title=t.unban, description=t.unbanned_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
         await reply(ctx, embed=server_embed)
         await send_to_changelog_mod(

From aaedeb407f2a108efeb17bdf925e6ea08a953ce3 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Mon, 7 Mar 2022 15:24:30 +0100
Subject: [PATCH 087/120] Removed unnecessary variable & made black reformat my
 code

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 8043e2e5e..370ffb20d 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -89,7 +89,7 @@ async def fill(db_model: Type[Base]):
             await pipe.expire(entry_key, CACHE_TTL)
             await pipe.execute()
 
-    if await redis.exists(load_key := "mod_entries_loaded"):
+    if await redis.exists("mod_entries_loaded"):
         return
 
     await fill(Ban)

From 0954ff57c3781db2af99519c2f1abde20c0b5f10 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Thu, 31 Mar 2022 22:10:48 +0200
Subject: [PATCH 088/120] Tried to reduce the "Cognitive Complexity"

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 27 +++++++++++++++++----------
 1 file changed, 17 insertions(+), 10 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 370ffb20d..f00ac8c76 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -352,18 +352,25 @@ def wrap_time_entry(
             minutes: Optional[int] = None,
             entry_id: Optional[int] = None,
         ) -> str:
+            args = [mod]
+
             if minutes:
-                if id:
-                    return translation.temp.id_on(
-                        f"<@{mod}>", time_to_units(minutes), reason, entry_id, show_evidence(evidence)
-                    )
-                else:
-                    return translation.temp.id_off(f"<@{mod}>", time_to_units(minutes), reason, show_evidence(evidence))
+                translation = translation.temp
+                args.append(minutes)
             else:
-                if id:
-                    return translation.inf.id_on(f"<@{mod}>", reason, entry_id, show_evidence(evidence))
-                else:
-                    return translation.inf.id_on(f"<@{mod}>", reason, show_evidence(evidence))
+                translation = translation.inf
+
+            args.append(reason)
+
+            if entry_id:
+                translation = translation.id_on
+                args.append(entry_id)
+            else:
+                translation = translation.id_off
+
+            args.append(evidence)
+
+            return translation(*args)
 
         def wrap_entry(
             translation, user: int, reason: str, evidence: Optional[str], entry_id: Optional[int] = None

From 7a26e16f0b83a2585602d2cbc4a48d88bd8e00f1 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Tue, 5 Apr 2022 20:36:18 +0200
Subject: [PATCH 089/120] Added more information to unban/unmute changelog
 embeds (#71)

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py              | 64 +++++++++++++++++++++++-------
 moderation/mod/translations/en.yml |  2 +
 2 files changed, 51 insertions(+), 15 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index f00ac8c76..f57f39cb4 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -167,15 +167,17 @@ async def confirm_no_evidence(ctx: Context):
 
 
 async def send_to_changelog_mod(
-    guild: Guild,
-    message: Optional[Message],
-    colour: int,
-    title: str,
-    member: Union[Member, User, Tuple[int, str]],
-    reason: str,
-    *,
-    duration: Optional[str] = None,
-    evidence: Optional[Attachment] = None,
+        guild: Guild,
+        message: Optional[Message],
+        colour: int,
+        title: str,
+        member: Union[Member, User, Tuple[int, str]],
+        reason: str,
+        *,
+        duration: Optional[str] = None,
+        evidence: Optional[Attachment] = None,
+        mod: Optional[Union[Member, User]] = None,
+        original_reason: Optional[str] = None,
 ):
     embed = Embed(title=title, colour=colour, timestamp=utcnow())
 
@@ -202,6 +204,12 @@ async def send_to_changelog_mod(
     if evidence:
         embed.add_field(name=t.log_field.evidence, value=t.image_link(evidence.filename, evidence.url), inline=True)
 
+    if mod:
+        embed.add_field(name=t.log_field.mod, value=f"<@{mod.id}>", inline=True)
+
+    if original_reason:
+        embed.add_field(name=t.log_field_original_reason, value=original_reason, inline=True)
+
     embed.add_field(name=t.log_field.reason, value=reason, inline=False)
 
     await send_to_changelog(guild, embed)
@@ -998,23 +1006,36 @@ async def unmute(self, ctx: Context, user: UserMemberConverter, *, reason: str):
             was_muted = True
             await user.remove_roles(mute_role)
 
+        minutes = 0
         async for mute in await db.stream(filter_by(Mute, active=True, member=user.id)):
             if not await compare_mod_level(ctx.author, mute.mod_level) or not ctx.author.id == mute.mod:
                 raise CommandError(tg.permission_denied)
 
             await Mute.deactivate(mute.id, ctx.author.id, reason)
 
-            await invalidate_entry_cache()
-
             was_muted = True
+
+            if mute.minutes > minutes or mute.minutes == -1:
+                minutes = mute.minutes
+
         if not was_muted:
             raise UserCommandError(user, t.not_muted)
 
+        await invalidate_entry_cache()
+
         server_embed = Embed(title=t.unmute, description=t.unmuted_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
         await reply(ctx, embed=server_embed)
         await send_to_changelog_mod(
-            guild=ctx.guild, message=ctx.message, colour=Colors.unmute, title=t.log_unmuted, member=user, reason=reason
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.unmute,
+            title=t.log_unmuted,
+            member=user,
+            reason=reason,
+            duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
+            mod=ctx.author,
+            original_reason=mute.reason,
         )
 
     @commands.command()
@@ -1438,21 +1459,34 @@ async def unban(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         except HTTPException:
             was_banned = False
 
+        minutes = 0
         async for ban in await db.stream(filter_by(Ban, active=True, member=user.id)):
             if not await compare_mod_level(ctx.author, ban.mod_level) or not ctx.author.id == ban.mod:
                 raise CommandError(tg.permission_denied)
 
             await Ban.deactivate(ban.id, ctx.author.id, reason)
 
-            await invalidate_entry_cache()
-
             was_banned = True
+
+            if ban.minutes > minutes or ban.minutes == -1:
+                minutes = ban.minutes
+
         if not was_banned:
             raise UserCommandError(user, t.not_banned)
 
+        await invalidate_entry_cache()
+
         server_embed = Embed(title=t.unban, description=t.unbanned_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
         await reply(ctx, embed=server_embed)
         await send_to_changelog_mod(
-            guild=ctx.guild, message=ctx.message, colour=Colors.unban, title=t.log_unbanned, member=user, reason=reason
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.unban,
+            title=t.log_unbanned,
+            member=user,
+            reason=reason,
+            duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
+            mod=ctx.author,
+            original_reason=ban.reason,
         )
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index bd62d6dbf..0f0a36413 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -52,6 +52,8 @@ log_field:
   reason: ":scroll: Reason"
   infinity: "*Permanent*"
   evidence: ":file_cabinet: Evidence image"
+  mod: ":key: Mod"
+  original_reason: ":pencil: Original reason"
 
 not_found:
   warn: No warn with this ID could be found

From db860933744b6cd052bf9a2214751681b4201215 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Tue, 5 Apr 2022 20:38:33 +0200
Subject: [PATCH 090/120] Improved codestyle

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index f57f39cb4..5e5fe1bc3 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -167,17 +167,17 @@ async def confirm_no_evidence(ctx: Context):
 
 
 async def send_to_changelog_mod(
-        guild: Guild,
-        message: Optional[Message],
-        colour: int,
-        title: str,
-        member: Union[Member, User, Tuple[int, str]],
-        reason: str,
-        *,
-        duration: Optional[str] = None,
-        evidence: Optional[Attachment] = None,
-        mod: Optional[Union[Member, User]] = None,
-        original_reason: Optional[str] = None,
+    guild: Guild,
+    message: Optional[Message],
+    colour: int,
+    title: str,
+    member: Union[Member, User, Tuple[int, str]],
+    reason: str,
+    *,
+    duration: Optional[str] = None,
+    evidence: Optional[Attachment] = None,
+    mod: Optional[Union[Member, User]] = None,
+    original_reason: Optional[str] = None,
 ):
     embed = Embed(title=title, colour=colour, timestamp=utcnow())
 

From 01be19fbc11b930a76a2fd70c12e22903c4e8c39 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Sat, 9 Apr 2022 09:38:56 +0200
Subject: [PATCH 091/120] Used inheritance to simplify database models

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/models.py | 99 +++++++++++++++-------------------------
 1 file changed, 37 insertions(+), 62 deletions(-)

diff --git a/moderation/mod/models.py b/moderation/mod/models.py
index 08a8ac563..c5a3f557b 100644
--- a/moderation/mod/models.py
+++ b/moderation/mod/models.py
@@ -10,17 +10,38 @@
 from discord.utils import utcnow
 
 
-class Report(Base):
-    __tablename__ = "report"
+class ModBase(Base):
+    __abstract__ = True
 
     id: Union[Column, int] = Column(Integer, primary_key=True, unique=True, autoincrement=True)
     member: Union[Column, int] = Column(BigInteger)
     member_name: Union[Column, str] = Column(Text)
-    reporter: Union[Column, int] = Column(BigInteger)
     timestamp: Union[Column, datetime] = Column(UTCDateTime)
     reason: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
     evidence: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
 
+
+class Punishment(ModBase):
+    __abstract__ = True
+
+    mod: Union[Column, int] = Column(BigInteger)
+    mod_level: Union[Column, int] = Column(Integer)
+
+
+class TimedPunishment(Punishment):
+    __abstract__ = True
+
+    active: Union[Column, bool] = Column(Boolean)
+    deactivation_timestamp: Union[Column, Optional[datetime]] = Column(UTCDateTime, nullable=True)
+    unmute_mod: Union[Column, Optional[int]] = Column(BigInteger, nullable=True)
+    unmute_reason: Union[Column, Optional[str]] = Column(Text(collation="utf8mb4_bin"), nullable=True)
+
+
+class Report(ModBase):
+    __tablename__ = "report"
+
+    reporter: Union[Column, int] = Column(BigInteger)
+
     @staticmethod
     async def create(member: int, member_name: str, reporter: int, reason: str, evidence: Optional[str]) -> Report:
         row = Report(
@@ -35,21 +56,12 @@ async def create(member: int, member_name: str, reporter: int, reason: str, evid
         return row
 
 
-class Warn(Base):
+class Warn(Punishment):
     __tablename__ = "warn"
 
-    id: Union[Column, int] = Column(Integer, primary_key=True, unique=True, autoincrement=True)
-    member: Union[Column, int] = Column(BigInteger)
-    member_name: Union[Column, str] = Column(Text)
-    mod: Union[Column, int] = Column(BigInteger)
-    mod_level: Union[Column, int] = Column(Integer)
-    timestamp: Union[Column, datetime] = Column(UTCDateTime)
-    reason: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
-    evidence: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
-
     @staticmethod
     async def create(
-        member: int, member_name: str, mod: int, mod_level: int, reason: str, evidence: Optional[str]
+            member: int, member_name: str, mod: int, mod_level: int, reason: str, evidence: Optional[str]
     ) -> Warn:
         row = Warn(
             member=member,
@@ -76,26 +88,12 @@ async def delete(warn_id: int):
         await db.delete(row)
 
 
-class Mute(Base):
+class Mute(Punishment):
     __tablename__ = "mute"
 
-    id: Union[Column, int] = Column(Integer, primary_key=True, unique=True, autoincrement=True)
-    member: Union[Column, int] = Column(BigInteger)
-    member_name: Union[Column, str] = Column(Text)
-    mod: Union[Column, int] = Column(BigInteger)
-    mod_level: Union[Column, int] = Column(Integer)
-    timestamp: Union[Column, datetime] = Column(UTCDateTime)
-    minutes: Union[Column, int] = Column(Integer)
-    reason: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
-    evidence: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
-    active: Union[Column, bool] = Column(Boolean)
-    deactivation_timestamp: Union[Column, Optional[datetime]] = Column(UTCDateTime, nullable=True)
-    unmute_mod: Union[Column, Optional[int]] = Column(BigInteger, nullable=True)
-    unmute_reason: Union[Column, Optional[str]] = Column(Text(collation="utf8mb4_bin"), nullable=True)
-
     @staticmethod
     async def create(
-        member: int, member_name: str, mod: int, mod_level: int, minutes: int, reason: str, evidence: Optional[str]
+            member: int, member_name: str, mod: int, mod_level: int, minutes: int, reason: str, evidence: Optional[str]
     ) -> Mute:
         row = Mute(
             member=member,
@@ -143,26 +141,17 @@ async def delete(mute_id: int):
         await db.delete(row)
 
 
-class Kick(Base):
+class Kick(Punishment):
     __tablename__ = "kick"
 
-    id: Union[Column, int] = Column(Integer, primary_key=True, unique=True, autoincrement=True)
-    member: Union[Column, int] = Column(BigInteger)
-    member_name: Union[Column, str] = Column(Text)
-    mod: Union[Column, int] = Column(BigInteger)
-    mod_level: Union[Column, int] = Column(Integer)
-    timestamp: Union[Column, datetime] = Column(UTCDateTime)
-    reason: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
-    evidence: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
-
     @staticmethod
     async def create(
-        member: int,
-        member_name: str,
-        mod: Optional[int],
-        mod_level: Optional[int],
-        reason: Optional[str],
-        evidence: Optional[str],
+            member: int,
+            member_name: str,
+            mod: Optional[int],
+            mod_level: Optional[int],
+            reason: Optional[str],
+            evidence: Optional[str],
     ) -> Kick:
         row = Kick(
             member=member,
@@ -189,26 +178,12 @@ async def delete(kick_id: int):
         await db.delete(row)
 
 
-class Ban(Base):
+class Ban(Punishment):
     __tablename__ = "ban"
 
-    id: Union[Column, int] = Column(Integer, primary_key=True, unique=True, autoincrement=True)
-    member: Union[Column, int] = Column(BigInteger)
-    member_name: Union[Column, str] = Column(Text)
-    mod: Union[Column, int] = Column(BigInteger)
-    mod_level: Union[Column, int] = Column(Integer)
-    timestamp: Union[Column, datetime] = Column(UTCDateTime)
-    minutes: Union[Column, int] = Column(Integer)
-    reason: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
-    evidence: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
-    active: Union[Column, bool] = Column(Boolean)
-    deactivation_timestamp: Union[Column, Optional[datetime]] = Column(UTCDateTime, nullable=True)
-    unban_reason: Union[Column, Optional[str]] = Column(Text, nullable=True)
-    unban_mod: Union[Column, Optional[int]] = Column(BigInteger, nullable=True)
-
     @staticmethod
     async def create(
-        member: int, member_name: str, mod: int, mod_level: int, minutes: int, reason: str, evidence: Optional[str]
+            member: int, member_name: str, mod: int, mod_level: int, minutes: int, reason: str, evidence: Optional[str]
     ) -> Ban:
         row = Ban(
             member=member,

From 161c20846f721df56d0893850a76c00192316a2c Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Mon, 11 Apr 2022 07:44:37 +0200
Subject: [PATCH 092/120] Improved database model inheritance

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py              |  30 ++---
 moderation/mod/models.py           | 195 ++++++++---------------------
 moderation/mod/translations/en.yml |  16 +--
 3 files changed, 78 insertions(+), 163 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 5e5fe1bc3..57a2ff7bf 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -360,11 +360,11 @@ def wrap_time_entry(
             minutes: Optional[int] = None,
             entry_id: Optional[int] = None,
         ) -> str:
-            args = [mod]
+            args = [f"<@{mod}>"]
 
             if minutes:
                 translation = translation.temp
-                args.append(minutes)
+                args.append(time_to_units(minutes))
             else:
                 translation = translation.inf
 
@@ -376,7 +376,7 @@ def wrap_time_entry(
             else:
                 translation = translation.id_off
 
-            args.append(evidence)
+            args.append(show_evidence(evidence))
 
             return translation(*args)
 
@@ -421,7 +421,7 @@ def wrap_entry(
                 (
                     mute.timestamp,
                     wrap_time_entry(
-                        translation=t.muted,
+                        translation=t.ulog.muted,
                         mod=mute.mod,
                         reason=mute.reason,
                         evidence=mute.evidence,
@@ -432,16 +432,16 @@ def wrap_entry(
             )
 
             if not mute.active:
-                if mute.unmute_mod is None:
-                    out.append((mute.deactivation_timestamp, t.ulog.unmuted_expired))
+                if mute.deactivate_mod is None:
+    out.append((mute.deactivation_timestamp, t.ulog.unmuted_expired))
                 else:
                     out.append(
                         (
                             mute.deactivation_timestamp,
                             wrap_entry(
                                 translation=t.unmuted,
-                                user=mute.unmute_mod,
-                                reason=mute.unmute_reason,
+                                user=mute.deactivate_mod,
+                                reason=mute.deactivate_reason,
                                 evidence=None,
                                 entry_id=mute.id if show_ids else None,
                             ),
@@ -466,7 +466,7 @@ def wrap_entry(
                 (
                     ban.timestamp,
                     wrap_time_entry(
-                        translation=t.banned,
+                        translation=t.ulog.banned,
                         mod=ban.mod,
                         reason=ban.reason,
                         evidence=ban.evidence,
@@ -477,16 +477,16 @@ def wrap_entry(
             )
 
             if not ban.active:
-                if ban.unban_mod is None:
-                    out.append((ban.deactivation_timestamp, t.ulog.unbanned_expired))
+                if ban.deactivate_mod is None:
+    out.append((ban.deactivation_timestamp, t.ulog.unbanned_expired))
                 else:
                     out.append(
                         (
                             ban.deactivation_timestamp,
                             wrap_entry(
-                                translation=t.unbanned,
-                                user=ban.unban_mod,
-                                reason=ban.unban_reason,
+                                translation=t.ulog.unbanned,
+                                user=ban.deactivate_mod,
+                                reason=ban.deactivate_reason,
                                 evidence=None,
                                 entry_id=ban.id if show_ids else None,
                             ),
@@ -1077,7 +1077,7 @@ async def kick(self, ctx: Context, member: Member, *, reason: str):
         user_embed = Embed(
             title=t.kick,
             colour=Colors.ModTools,
-            description=t.kicked.no_evidence(ctx.author.mention, ctx.guild.name, reason),
+            description=t.kicked(ctx.author.mention, ctx.guild.name, reason),
         )
 
         server_embed = Embed(title=t.kick, description=t.kicked_response, colour=Colors.ModTools)
diff --git a/moderation/mod/models.py b/moderation/mod/models.py
index c5a3f557b..a62c11fec 100644
--- a/moderation/mod/models.py
+++ b/moderation/mod/models.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Union, Optional
+from typing import Union, Optional, Type
 from datetime import datetime
 
 from sqlalchemy import Column, Integer, BigInteger, Text, Boolean
@@ -10,9 +10,7 @@
 from discord.utils import utcnow
 
 
-class ModBase(Base):
-    __abstract__ = True
-
+class ModBase:
     id: Union[Column, int] = Column(Integer, primary_key=True, unique=True, autoincrement=True)
     member: Union[Column, int] = Column(BigInteger)
     member_name: Union[Column, str] = Column(Text)
@@ -22,48 +20,14 @@ class ModBase(Base):
 
 
 class Punishment(ModBase):
-    __abstract__ = True
-
     mod: Union[Column, int] = Column(BigInteger)
     mod_level: Union[Column, int] = Column(Integer)
 
-
-class TimedPunishment(Punishment):
-    __abstract__ = True
-
-    active: Union[Column, bool] = Column(Boolean)
-    deactivation_timestamp: Union[Column, Optional[datetime]] = Column(UTCDateTime, nullable=True)
-    unmute_mod: Union[Column, Optional[int]] = Column(BigInteger, nullable=True)
-    unmute_reason: Union[Column, Optional[str]] = Column(Text(collation="utf8mb4_bin"), nullable=True)
-
-
-class Report(ModBase):
-    __tablename__ = "report"
-
-    reporter: Union[Column, int] = Column(BigInteger)
-
-    @staticmethod
-    async def create(member: int, member_name: str, reporter: int, reason: str, evidence: Optional[str]) -> Report:
-        row = Report(
-            member=member,
-            member_name=member_name,
-            reporter=reporter,
-            timestamp=utcnow(),
-            reason=reason,
-            evidence=evidence,
-        )
-        await db.add(row)
-        return row
-
-
-class Warn(Punishment):
-    __tablename__ = "warn"
-
-    @staticmethod
+    @classmethod
     async def create(
-            member: int, member_name: str, mod: int, mod_level: int, reason: str, evidence: Optional[str]
-    ) -> Warn:
-        row = Warn(
+            cls, member: int, member_name: str, mod: int, mod_level: int, reason: str, evidence: Optional[str]
+    ) -> Punishment:
+        row = cls(
             member=member,
             member_name=member_name,
             mod=mod,
@@ -75,27 +39,33 @@ async def create(
         await db.add(row)
         return row
 
-    @staticmethod
-    async def edit(warn_id: int, mod: int, mod_level: int, new_reason: str):
-        row = await db.get(Warn, id=warn_id)
+    @classmethod
+    async def edit(cls, entry_id: int, mod: int, mod_level: int, new_reason: str):
+        row = await db.get(cls, id=entry_id)
         row.mod = mod
         row.mod_level = mod_level
         row.reason = new_reason
 
-    @staticmethod
-    async def delete(warn_id: int):
-        row = await db.get(Warn, id=warn_id)
+    @classmethod
+    async def delete(cls, entry_id: int):
+        row = await db.get(cls, id=entry_id)
         await db.delete(row)
 
 
-class Mute(Punishment):
-    __tablename__ = "mute"
+class TimedPunishment(ModBase):
+    mod: Union[Column, int] = Column(BigInteger)
+    mod_level: Union[Column, int] = Column(Integer)
+    minutes: Union[Column, int] = Column(Integer)
+    active: Union[Column, bool] = Column(Boolean)
+    deactivation_timestamp: Union[Column, Optional[datetime]] = Column(UTCDateTime, nullable=True)
+    deactivate_mod: Union[Column, Optional[int]] = Column(BigInteger, nullable=True)
+    deactivate_reason: Union[Column, Optional[str]] = Column(Text(collation="utf8mb4_bin"), nullable=True)
 
-    @staticmethod
+    @classmethod
     async def create(
-            member: int, member_name: str, mod: int, mod_level: int, minutes: int, reason: str, evidence: Optional[str]
-    ) -> Mute:
-        row = Mute(
+        cls, member: int, member_name: str, mod: int, mod_level: int, minutes: int, reason: str, evidence: Optional[str]
+    ) -> TimedPunishment:
+        row = cls(
             member=member,
             member_name=member_name,
             mod=mod,
@@ -106,58 +76,52 @@ async def create(
             evidence=evidence,
             active=True,
             deactivation_timestamp=None,
-            unmute_mod=None,
-            unmute_reason=None,
+            deactivate_mod=None,
+            deactivate_reason=None,
         )
         await db.add(row)
         return row
 
-    @staticmethod
-    async def deactivate(mute_id: int, unmute_mod: int = None, reason: str = None) -> "Mute":
-        row: Mute = await db.get(Mute, id=mute_id)
+    @classmethod
+    async def deactivate(cls, mute_id: int, deactivate_mod: int = None, reason: str = None) -> "TimedPunishment":
+        row: TimedPunishment = await db.get(cls, id=mute_id)
         row.active = False
         row.deactivation_timestamp = utcnow()
-        row.unmute_mod = unmute_mod
-        row.unmute_reason = reason
+        row.deactivate_mod = deactivate_mod
+        row.deactivate_reason = reason
         return row
 
-    @staticmethod
-    async def edit_reason(mute_id: int, mod: int, mod_level: int, new_reason: str):
-        row = await db.get(Mute, id=mute_id)
+    @classmethod
+    async def edit_reason(cls, entry_id: int, mod: int, mod_level: int, new_reason: str):
+        row = await db.get(cls, id=entry_id)
         row.mod = mod
         row.mod_level = mod_level
         row.reason = new_reason
 
-    @staticmethod
-    async def edit_duration(mute_id: int, mod: int, mod_level: int, new_duration: int):
-        row = await db.get(Mute, id=mute_id)
+    @classmethod
+    async def edit_duration(cls, entry_id: int, mod: int, mod_level: int, new_duration: int):
+        row = await db.get(cls, id=entry_id)
         row.mod = mod
         row.mod_level = mod_level
         row.minutes = new_duration
 
-    @staticmethod
-    async def delete(mute_id: int):
-        row = await db.get(Mute, id=mute_id)
+    @classmethod
+    async def delete(cls, entry_id: int):
+        row = await db.get(cls, id=entry_id)
         await db.delete(row)
 
 
-class Kick(Punishment):
-    __tablename__ = "kick"
+class Report(ModBase, Base):
+    __tablename__ = "report"
+
+    reporter: Union[Column, int] = Column(BigInteger)
 
     @staticmethod
-    async def create(
-            member: int,
-            member_name: str,
-            mod: Optional[int],
-            mod_level: Optional[int],
-            reason: Optional[str],
-            evidence: Optional[str],
-    ) -> Kick:
-        row = Kick(
+    async def create(member: int, member_name: str, reporter: int, reason: str, evidence: Optional[str]) -> Report:
+        row = Report(
             member=member,
             member_name=member_name,
-            mod=mod,
-            mod_level=mod_level,
+            reporter=reporter,
             timestamp=utcnow(),
             reason=reason,
             evidence=evidence,
@@ -165,67 +129,18 @@ async def create(
         await db.add(row)
         return row
 
-    @staticmethod
-    async def edit(kick_id: int, mod: int, mod_level: int, new_reason: str):
-        row = await db.get(Kick, id=kick_id)
-        row.mod = mod
-        row.mod_level = mod_level
-        row.reason = new_reason
-
-    @staticmethod
-    async def delete(kick_id: int):
-        row = await db.get(Kick, id=kick_id)
-        await db.delete(row)
 
+class Warn(Punishment, Base):
+    __tablename__ = "warn"
 
-class Ban(Punishment):
-    __tablename__ = "ban"
 
-    @staticmethod
-    async def create(
-            member: int, member_name: str, mod: int, mod_level: int, minutes: int, reason: str, evidence: Optional[str]
-    ) -> Ban:
-        row = Ban(
-            member=member,
-            member_name=member_name,
-            mod=mod,
-            mod_level=mod_level,
-            timestamp=utcnow(),
-            minutes=minutes,
-            reason=reason,
-            evidence=evidence,
-            active=True,
-            deactivation_timestamp=None,
-            unban_reason=None,
-            unban_mod=None,
-        )
-        await db.add(row)
-        return row
+class Mute(TimedPunishment, Base):
+    __tablename__ = "mute"
 
-    @staticmethod
-    async def deactivate(ban_id: int, unban_mod: int = None, unban_reason: str = None) -> Ban:
-        row: Ban = await db.get(Ban, id=ban_id)
-        row.active = False
-        row.deactivation_timestamp = utcnow()
-        row.unban_mod = unban_mod
-        row.unban_reason = unban_reason
-        return row
 
-    @staticmethod
-    async def edit_reason(ban_id: int, mod: int, mod_level: int, new_reason: str):
-        row = await db.get(Ban, id=ban_id)
-        row.mod = mod
-        row.mod_level = mod_level
-        row.reason = new_reason
+class Kick(Punishment, Base):
+    __tablename__ = "kick"
 
-    @staticmethod
-    async def edit_duration(ban_id: int, mod: int, mod_level: int, new_duration: int):
-        row = await db.get(Ban, id=ban_id)
-        row.mod = mod
-        row.mod_level = mod_level
-        row.minutes = new_duration
 
-    @staticmethod
-    async def delete(ban_id: int):
-        row = await db.get(Ban, id=ban_id)
-        await db.delete(row)
+class Ban(TimedPunishment, Base):
+    __tablename__ = "ban"
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index 0f0a36413..20601506d 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -9,22 +9,22 @@ commands:
   send_delete_message: configure whether to send a warn/mute/kick/ban delete message to the concerned user
   report: report a user
   warn: warn a user
-  edit_warn: edit a warn\nget the warn id from the users user log
-  delete_warn: delete a warn\nget the warn id from the users user log
+  edit_warn: "edit a warn\nget the warn id from the users user log"
+  delete_warn: "delete a warn\nget the warn id from the users user log"
   mute: "mute a user\ntime format: `wdhm`\nset time to `inf` for a permanent mute"
   edit_mute: edit a mute
-  edit_mute_reason: edit a mute reason\nget the mute id from the users user log
+  edit_mute_reason: "edit a mute reason\nget the mute id from the users user log"
   edit_mute_duration: "edit a mute duration\ntime format: `wdhm`\nset time to `inf` for a permanent mute"
-  delete_mute: delete a mute\nget the mute id from the users user log
+  delete_mute: "delete a mute\nget the mute id from the users user log"
   unmute: unmute a user
   kick: kick a member
-  edit_kick: edit a kick\nget the kick id from the users user log
-  delete_kick: delete a kick\nget the kick id from the users user log
+  edit_kick: "edit a kick\nget the kick id from the users user log"
+  delete_kick: "delete a kick\nget the kick id from the users user log"
   ban: "ban a user\ntime format: `wdhm`\nset time to `inf` for a permanent ban"
   edit_ban: edit a ban
-  edit_ban_reason: edit a ban reason\nget the ban id from the users user log
+  edit_ban_reason: "edit a ban reason\nget the ban id from the users user log"
   edit_ban_duration: "edit a ban duration\ntime format: `wdhm`\nset time to `inf` for a permanent ban"
-  delete_ban: delete a ban\nget the ban id from the users user log
+  delete_ban: "delete a ban\nget the ban id from the users user log"
   unban: unban a user
 
 times:

From d416442eb187f5f0c0727ee948fa73105eaecf6f Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Mon, 11 Apr 2022 07:46:37 +0200
Subject: [PATCH 093/120] Fixed wrong indents

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 57a2ff7bf..16058342a 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -433,7 +433,7 @@ def wrap_entry(
 
             if not mute.active:
                 if mute.deactivate_mod is None:
-    out.append((mute.deactivation_timestamp, t.ulog.unmuted_expired))
+                    out.append((mute.deactivation_timestamp, t.ulog.unmuted_expired))
                 else:
                     out.append(
                         (
@@ -478,7 +478,7 @@ def wrap_entry(
 
             if not ban.active:
                 if ban.deactivate_mod is None:
-    out.append((ban.deactivation_timestamp, t.ulog.unbanned_expired))
+                    out.append((ban.deactivation_timestamp, t.ulog.unbanned_expired))
                 else:
                     out.append(
                         (

From 7c8fbede827851557cc85e046261830f356b84fb Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Mon, 11 Apr 2022 07:57:36 +0200
Subject: [PATCH 094/120] Improved codestyle

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/models.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/moderation/mod/models.py b/moderation/mod/models.py
index a62c11fec..7eb958277 100644
--- a/moderation/mod/models.py
+++ b/moderation/mod/models.py
@@ -39,6 +39,8 @@ async def create(
         await db.add(row)
         return row
 
+    # test
+
     @classmethod
     async def edit(cls, entry_id: int, mod: int, mod_level: int, new_reason: str):
         row = await db.get(cls, id=entry_id)

From f34d6480b834c4f900b8bbdf5c498326943c42fa Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Mon, 11 Apr 2022 07:57:55 +0200
Subject: [PATCH 095/120] Improved codestyle

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/models.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/moderation/mod/models.py b/moderation/mod/models.py
index 7eb958277..a62c11fec 100644
--- a/moderation/mod/models.py
+++ b/moderation/mod/models.py
@@ -39,8 +39,6 @@ async def create(
         await db.add(row)
         return row
 
-    # test
-
     @classmethod
     async def edit(cls, entry_id: int, mod: int, mod_level: int, new_reason: str):
         row = await db.get(cls, id=entry_id)

From 85653e2688ce3de663e2dbeb6c419a95ead71f82 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Mon, 11 Apr 2022 08:14:41 +0200
Subject: [PATCH 096/120] Improved codestyle

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 1666 +++++++++++++++++++++--------------------
 1 file changed, 842 insertions(+), 824 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 57a2ff7bf..de250976b 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -433,7 +433,7 @@ def wrap_entry(
 
             if not mute.active:
                 if mute.deactivate_mod is None:
-    out.append((mute.deactivation_timestamp, t.ulog.unmuted_expired))
+                    out.append((mute.deactivation_timestamp, t.ulog.unmuted_expired))
                 else:
                     out.append(
                         (
@@ -478,7 +478,7 @@ def wrap_entry(
 
             if not ban.active:
                 if ban.deactivate_mod is None:
-    out.append((ban.deactivation_timestamp, t.ulog.unbanned_expired))
+                    out.append((ban.deactivation_timestamp, t.ulog.unbanned_expired))
                 else:
                     out.append(
                         (
@@ -495,998 +495,1016 @@ def wrap_entry(
 
         return out
 
-    async def on_member_join(self, member: Member):
-        mute_role: Optional[Role] = member.guild.get_role(await RoleSettings.get("mute"))
-        if mute_role is None:
-            return
 
-        if await db.exists(filter_by(Mute, active=True, member=member.id)):
-            await member.add_roles(mute_role)
+async def on_member_join(self, member: Member):
+    mute_role: Optional[Role] = member.guild.get_role(await RoleSettings.get("mute"))
+    if mute_role is None:
+        return
 
-    async def on_member_ban(self, guild: Guild, member: Member):
-        search_limit = 100
-        for i in range(10, 1, -1):
+    if await db.exists(filter_by(Mute, active=True, member=member.id)):
+        await member.add_roles(mute_role)
 
-            try:
-                entry: AuditLogEntry
-                async for entry in guild.audit_logs(limit=search_limit, action=AuditLogAction.ban):
-                    if entry.user == self.bot.user:
-                        continue
-
-                    if member.id != entry.target.id:
-                        continue
-
-                    if entry.reason:
-                        await Ban.create(
-                            entry.target.id,
-                            str(entry.target),
-                            entry.user.id,
-                            await get_mod_level(entry.user),
-                            -1,
-                            entry.reason,
-                            None,
-                        )
 
-                        await send_to_changelog_mod(
-                            guild=guild,
-                            message=None,
-                            colour=Colors.ban,
-                            title=t.log_banned,
-                            member=entry.target,
-                            reason=entry.reason,
-                            duration=t.log_field.infinity,
-                        )
+async def on_member_ban(self, guild: Guild, member: Member):
+    search_limit = 100
+    for i in range(10, 1, -1):
 
-                    else:
-                        await send_alert(guild, t.alert_member_banned(str(entry.target), str(entry.user)))
+        try:
+            entry: AuditLogEntry
+            async for entry in guild.audit_logs(limit=search_limit, action=AuditLogAction.ban):
+                if entry.user == self.bot.user:
+                    continue
+
+                if member.id != entry.target.id:
+                    continue
 
-                    return
+                if entry.reason:
+                    await Ban.create(
+                        entry.target.id,
+                        str(entry.target),
+                        entry.user.id,
+                        await get_mod_level(entry.user),
+                        -1,
+                        entry.reason,
+                        None,
+                    )
 
-            except Forbidden:
-                await send_alert(guild, t.cannot_fetch_audit_logs)
+                    await send_to_changelog_mod(
+                        guild=guild,
+                        message=None,
+                        colour=Colors.ban,
+                        title=t.log_banned,
+                        member=entry.target,
+                        reason=entry.reason,
+                        duration=t.log_field.infinity,
+                    )
 
-            await sleep(delay=i * 10)
-            search_limit -= i * 10
+                else:
+                    await send_alert(guild, t.alert_member_banned(str(entry.target), str(entry.user)))
 
-    @commands.command()
-    @guild_only()
-    @ModPermission.modtools_write.check
-    @docs(t.commands.send_delete_message)
-    async def send_delete_message(self, ctx: Context, send: Optional[bool] = None):
-        embed = Embed(title=t.modtools, color=Colors.ModTools)
+                return
 
-        if send is None:
-            send = await ModSettings.send_delete_user_message.get()
-            embed.description = t.current_send_delete_message[send]
-        else:
-            await ModSettings.send_delete_user_message.set(send)
-            embed.description = t.configured_send_delete_message[send]
+        except Forbidden:
+            await send_alert(guild, t.cannot_fetch_audit_logs)
 
-        await reply(ctx, embed=embed)
-        await send_to_changelog(ctx.guild, t.configured_send_delete_message[send])
+        await sleep(delay=i * 10)
+        search_limit -= i * 10
 
-    @commands.command()
-    @docs(t.commands.report)
-    async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
-        user: Union[Member, User]
 
-        if len(reason) > 900:
-            raise CommandError(t.reason_too_long)
+@commands.command()
+@guild_only()
+@ModPermission.modtools_write.check
+@docs(t.commands.send_delete_message)
+async def send_delete_message(self, ctx: Context, send: Optional[bool] = None):
+    embed = Embed(title=t.modtools, color=Colors.ModTools)
 
-        if user == self.bot.user:
-            raise UserCommandError(user, t.cannot_report)
-        if user == ctx.author:
-            raise UserCommandError(user, t.no_self_report)
+    if send is None:
+        send = await ModSettings.send_delete_user_message.get()
+        embed.description = t.current_send_delete_message[send]
+    else:
+        await ModSettings.send_delete_user_message.set(send)
+        embed.description = t.configured_send_delete_message[send]
 
-        conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_report(user.mention, reason), color=Colors.ModTools
-        )
+    await reply(ctx, embed=embed)
+    await send_to_changelog(ctx.guild, t.configured_send_delete_message[send])
 
-        if not await confirm_action(ctx, conf_embed, t.report_confirmed, t.report_canceled):
-            return
 
-        attachments = ctx.message.attachments
-        evidence = attachments[0] if attachments else None
-        evidence_url = evidence.url if attachments else None
+@commands.command()
+@docs(t.commands.report)
+async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
+    user: Union[Member, User]
 
-        await Report.create(user.id, str(user), ctx.author.id, reason, evidence_url)
-        server_embed = Embed(title=t.report, description=t.reported_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-        await reply(ctx, embed=server_embed)
+    if len(reason) > 900:
+        raise CommandError(t.reason_too_long)
 
-        alert_embed = Embed(
-            title=t.report,
-            description=t.alert_report(ctx.author.mention, user.mention, reason),
-            color=Colors.report,
-            timestamp=utcnow(),
-        )
+    if user == self.bot.user:
+        raise UserCommandError(user, t.cannot_report)
+    if user == ctx.author:
+        raise UserCommandError(user, t.no_self_report)
 
-        if type(ctx.channel) in (Thread, TextChannel):
-            alert_embed.add_field(
-                name=t.log_field.channel, value=t.jump_url(ctx.channel.mention, ctx.message.jump_url), inline=True
-            )
-        if evidence:
-            alert_embed.add_field(
-                name=t.log_field.evidence, value=t.image_link(evidence.filename, evidence_url), inline=True
-            )
+    conf_embed = Embed(title=t.confirmation, description=t.confirm_report(user.mention, reason), color=Colors.ModTools)
 
-        await send_alert(self.bot.guilds[0], alert_embed)
+    if not await confirm_action(ctx, conf_embed, t.report_confirmed, t.report_canceled):
+        return
 
-    @commands.command()
-    @ModPermission.warn.check
-    @guild_only()
-    @docs(t.commands.warn)
-    async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
-        user: Union[Member, User]
+    attachments = ctx.message.attachments
+    evidence = attachments[0] if attachments else None
+    evidence_url = evidence.url if attachments else None
+
+    await Report.create(user.id, str(user), ctx.author.id, reason, evidence_url)
+    server_embed = Embed(title=t.report, description=t.reported_response, colour=Colors.ModTools)
+    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+    await reply(ctx, embed=server_embed)
+
+    alert_embed = Embed(
+        title=t.report,
+        description=t.alert_report(ctx.author.mention, user.mention, reason),
+        color=Colors.report,
+        timestamp=utcnow(),
+    )
+
+    if type(ctx.channel) in (Thread, TextChannel):
+        alert_embed.add_field(
+            name=t.log_field.channel, value=t.jump_url(ctx.channel.mention, ctx.message.jump_url), inline=True
+        )
+    if evidence:
+        alert_embed.add_field(
+            name=t.log_field.evidence, value=t.image_link(evidence.filename, evidence_url), inline=True
+        )
 
-        if len(reason) > 900:
-            raise CommandError(t.reason_too_long)
+    await send_alert(self.bot.guilds[0], alert_embed)
 
-        if user == self.bot.user:
-            raise UserCommandError(user, t.cannot_warn)
 
-        attachments = ctx.message.attachments
-        evidence = attachments[0] if attachments else None
-        evidence_url = evidence.url if attachments else None
+@commands.command()
+@ModPermission.warn.check
+@guild_only()
+@docs(t.commands.warn)
+async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
+    user: Union[Member, User]
 
-        if not evidence:
-            if not await confirm_no_evidence(ctx):
-                return
+    if len(reason) > 900:
+        raise CommandError(t.reason_too_long)
 
-        user_embed = Embed(
-            title=t.warn, colour=Colors.ModTools, description=t.warned(ctx.author.mention, ctx.guild.name, reason)
-        )
+    if user == self.bot.user:
+        raise UserCommandError(user, t.cannot_warn)
 
-        server_embed = Embed(title=t.warn, description=t.warned_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-        try:
-            await user.send(embed=user_embed)
-        except (Forbidden, HTTPException):
-            server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-            server_embed.colour = Colors.error
-        await Warn.create(user.id, str(user), ctx.author.id, await get_mod_level(ctx.author), reason, evidence_url)
-        await reply(ctx, embed=server_embed)
-        await send_to_changelog_mod(
-            guild=ctx.guild,
-            message=ctx.message,
-            colour=Colors.warn,
-            title=t.log_warned,
-            member=user,
-            reason=reason,
-            evidence=evidence,
-        )
+    attachments = ctx.message.attachments
+    evidence = attachments[0] if attachments else None
+    evidence_url = evidence.url if attachments else None
 
-    @commands.command(aliases=["warn_edit"])
-    @ModPermission.warn.check
-    @guild_only()
-    @docs(t.commands.edit_warn)
-    async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
-        warn = await get_and_compare_entry(Warn, warn_id, ctx.author)
+    if not evidence:
+        if not await confirm_no_evidence(ctx):
+            return
 
-        if len(reason) > 900:
-            raise CommandError(t.reason_too_long)
+    user_embed = Embed(
+        title=t.warn, colour=Colors.ModTools, description=t.warned(ctx.author.mention, ctx.guild.name, reason)
+    )
+
+    server_embed = Embed(title=t.warn, description=t.warned_response, colour=Colors.ModTools)
+    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+    try:
+        await user.send(embed=user_embed)
+    except (Forbidden, HTTPException):
+        server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
+        server_embed.colour = Colors.error
+    await Warn.create(user.id, str(user), ctx.author.id, await get_mod_level(ctx.author), reason, evidence_url)
+    await reply(ctx, embed=server_embed)
+    await send_to_changelog_mod(
+        guild=ctx.guild,
+        message=ctx.message,
+        colour=Colors.warn,
+        title=t.log_warned,
+        member=user,
+        reason=reason,
+        evidence=evidence,
+    )
+
+
+@commands.command(aliases=["warn_edit"])
+@ModPermission.warn.check
+@guild_only()
+@docs(t.commands.edit_warn)
+async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
+    warn = await get_and_compare_entry(Warn, warn_id, ctx.author)
+
+    if len(reason) > 900:
+        raise CommandError(t.reason_too_long)
+
+    conf_embed = Embed(
+        title=t.confirmation, description=t.confirm_warn_edit(warn.reason, reason), color=Colors.ModTools
+    )
+
+    if not await confirm_action(ctx, conf_embed):
+        return
 
-        conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_warn_edit(warn.reason, reason), color=Colors.ModTools
-        )
+    try:
+        user = await self.bot.fetch_user(warn.member)
+    except (NotFound, HTTPException):
+        raise CommandError(t.user_not_found)
+
+    user_embed = Embed(title=t.warn, description=t.warn_edited(warn.reason, reason), colour=Colors.ModTools)
+    server_embed = Embed(title=t.warn, description=t.warn_edited_response, colour=Colors.ModTools)
+    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+
+    await Warn.edit(warn_id, ctx.author.id, await get_mod_level(ctx.author), reason)
+
+    try:
+        await user.send(embed=user_embed)
+    except (Forbidden, HTTPException):
+        server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
+        server_embed.colour = Colors.error
+    await reply(ctx, embed=server_embed)
+    await send_to_changelog_mod(
+        guild=ctx.guild,
+        message=ctx.message,
+        colour=Colors.warn,
+        title=t.log_warn_edited,
+        member=user,
+        reason=reason,
+    )
+
+
+@commands.command(aliases=["warn_delete"])
+@ModPermission.warn.check
+@guild_only()
+@docs(t.commands.delete_warn)
+async def delete_warn(self, ctx: Context, warn_id: int):
+    warn = await get_and_compare_entry(Warn, warn_id, ctx.author)
+
+    conf_embed = Embed(
+        title=t.confirmation, description=t.confirm_warn_delete(warn.member_name, warn.id), color=Colors.ModTools
+    )
+
+    if not await confirm_action(ctx, conf_embed):
+        return
 
-        if not await confirm_action(ctx, conf_embed):
-            return
+    await Warn.delete(warn_id)
 
-        try:
-            user = await self.bot.fetch_user(warn.member)
-        except (NotFound, HTTPException):
-            raise CommandError(t.user_not_found)
+    try:
+        user = await self.bot.fetch_user(warn.member)
+    except (NotFound, HTTPException):
+        raise CommandError(t.user_not_found)
 
-        user_embed = Embed(title=t.warn, description=t.warn_edited(warn.reason, reason), colour=Colors.ModTools)
-        server_embed = Embed(title=t.warn, description=t.warn_edited_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+    server_embed = Embed(title=t.warn, description=t.warn_deleted_response, colour=Colors.ModTools)
+    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-        await Warn.edit(warn_id, ctx.author.id, await get_mod_level(ctx.author), reason)
+    if await ModSettings.send_delete_user_message.get():
+        user_embed = Embed(title=t.warn, description=t.warn_deleted(warn.reason), colour=Colors.ModTools)
 
         try:
             await user.send(embed=user_embed)
         except (Forbidden, HTTPException):
             server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
             server_embed.colour = Colors.error
-        await reply(ctx, embed=server_embed)
-        await send_to_changelog_mod(
-            guild=ctx.guild,
-            message=ctx.message,
-            colour=Colors.warn,
-            title=t.log_warn_edited,
-            member=user,
-            reason=reason,
-        )
-
-    @commands.command(aliases=["warn_delete"])
-    @ModPermission.warn.check
-    @guild_only()
-    @docs(t.commands.delete_warn)
-    async def delete_warn(self, ctx: Context, warn_id: int):
-        warn = await get_and_compare_entry(Warn, warn_id, ctx.author)
-
-        conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_warn_delete(warn.member_name, warn.id), color=Colors.ModTools
-        )
 
-        if not await confirm_action(ctx, conf_embed):
-            return
-
-        await Warn.delete(warn_id)
-
-        try:
-            user = await self.bot.fetch_user(warn.member)
-        except (NotFound, HTTPException):
-            raise CommandError(t.user_not_found)
+    await reply(ctx, embed=server_embed)
+    await send_to_changelog_mod(
+        guild=ctx.guild,
+        message=ctx.message,
+        colour=Colors.warn,
+        title=t.log_warn_deleted,
+        member=user,
+        reason=warn.reason,
+    )
 
-        server_embed = Embed(title=t.warn, description=t.warn_deleted_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-        if await ModSettings.send_delete_user_message.get():
-            user_embed = Embed(title=t.warn, description=t.warn_deleted(warn.reason), colour=Colors.ModTools)
+@commands.command()
+@ModPermission.mute.check
+@guild_only()
+@docs(t.commands.mute)
+async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConverter, *, reason: str):
+    user: Union[Member, User]
 
-            try:
-                await user.send(embed=user_embed)
-            except (Forbidden, HTTPException):
-                server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-                server_embed.colour = Colors.error
-
-        await reply(ctx, embed=server_embed)
-        await send_to_changelog_mod(
-            guild=ctx.guild,
-            message=ctx.message,
-            colour=Colors.warn,
-            title=t.log_warn_deleted,
-            member=user,
-            reason=warn.reason,
-        )
+    time: Optional[int]
+    minutes = time
 
-    @commands.command()
-    @ModPermission.mute.check
-    @guild_only()
-    @docs(t.commands.mute)
-    async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConverter, *, reason: str):
-        user: Union[Member, User]
+    if len(reason) > 900:
+        raise CommandError(t.reason_too_long)
 
-        time: Optional[int]
-        minutes = time
+    mute_role: Role = await get_mute_role(ctx.guild)
 
-        if len(reason) > 900:
-            raise CommandError(t.reason_too_long)
+    if user == self.bot.user or await is_teamler(user):
+        raise UserCommandError(user, t.cannot_mute)
 
-        mute_role: Role = await get_mute_role(ctx.guild)
+    if isinstance(user, Member):
+        await user.add_roles(mute_role)
+        await user.move_to(None)
 
-        if user == self.bot.user or await is_teamler(user):
-            raise UserCommandError(user, t.cannot_mute)
+    if await db.exists(filter_by(Mute, active=True, member=user.id)):
+        raise UserCommandError(user, t.already_muted)
 
-        if isinstance(user, Member):
-            await user.add_roles(mute_role)
-            await user.move_to(None)
+    attachments = ctx.message.attachments
+    evidence = attachments[0] if attachments else None
+    evidence_url = evidence.url if attachments else None
 
-        if await db.exists(filter_by(Mute, active=True, member=user.id)):
-            raise UserCommandError(user, t.already_muted)
+    if not evidence:
+        if not await confirm_no_evidence(ctx):
+            return
 
-        attachments = ctx.message.attachments
-        evidence = attachments[0] if attachments else None
-        evidence_url = evidence.url if attachments else None
+    user_embed = Embed(title=t.mute, colour=Colors.ModTools)
+    server_embed = Embed(title=t.mute, description=t.muted_response, colour=Colors.ModTools)
+    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+
+    await Mute.create(
+        user.id,
+        str(user),
+        ctx.author.id,
+        await get_mod_level(ctx.author),
+        minutes if minutes is not None else -1,
+        reason,
+        evidence_url,
+    )
+
+    await invalidate_entry_cache()
+
+    await send_to_changelog_mod(
+        guild=ctx.guild,
+        message=ctx.message,
+        colour=Colors.mute,
+        title=t.log_muted,
+        member=user,
+        reason=reason,
+        duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
+        evidence=evidence,
+    )
+
+    if minutes is not None:
+        user_embed.description = t.muted(ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason)
+    else:
+        user_embed.description = t.muted_inf(ctx.author.mention, ctx.guild.name, reason)
 
-        if not evidence:
-            if not await confirm_no_evidence(ctx):
-                return
+    try:
+        await user.send(embed=user_embed)
+    except (Forbidden, HTTPException):
+        server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
+        server_embed.colour = Colors.error
 
-        user_embed = Embed(title=t.mute, colour=Colors.ModTools)
-        server_embed = Embed(title=t.mute, description=t.muted_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-
-        await Mute.create(
-            user.id,
-            str(user),
-            ctx.author.id,
-            await get_mod_level(ctx.author),
-            minutes if minutes is not None else -1,
-            reason,
-            evidence_url,
-        )
+    await reply(ctx, embed=server_embed)
 
-        await invalidate_entry_cache()
-
-        await send_to_changelog_mod(
-            guild=ctx.guild,
-            message=ctx.message,
-            colour=Colors.mute,
-            title=t.log_muted,
-            member=user,
-            reason=reason,
-            duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
-            evidence=evidence,
-        )
 
-        if minutes is not None:
-            user_embed.description = t.muted(ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason)
-        else:
-            user_embed.description = t.muted_inf(ctx.author.mention, ctx.guild.name, reason)
+@commands.group(aliases=["mute_edit"])
+@ModPermission.mute.check
+@guild_only()
+@docs(t.commands.edit_mute)
+async def edit_mute(self, ctx):
+    if ctx.invoked_subcommand is None:
+        raise UserInputError
 
-        try:
-            await user.send(embed=user_embed)
-        except (Forbidden, HTTPException):
-            server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-            server_embed.colour = Colors.error
 
-        await reply(ctx, embed=server_embed)
+@edit_mute.command(name="reason", aliases=["r"])
+@docs(t.commands.edit_mute_reason)
+async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
+    mute = await get_and_compare_entry(Mute, mute_id, ctx.author)
 
-    @commands.group(aliases=["mute_edit"])
-    @ModPermission.mute.check
-    @guild_only()
-    @docs(t.commands.edit_mute)
-    async def edit_mute(self, ctx):
-        if ctx.invoked_subcommand is None:
-            raise UserInputError
+    if len(reason) > 900:
+        raise CommandError(t.reason_too_long)
 
-    @edit_mute.command(name="reason", aliases=["r"])
-    @docs(t.commands.edit_mute_reason)
-    async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
-        mute = await get_and_compare_entry(Mute, mute_id, ctx.author)
+    conf_embed = Embed(
+        title=t.confirmation, description=t.confirm_mute_edit.reason(mute.reason, reason), color=Colors.ModTools
+    )
 
-        if len(reason) > 900:
-            raise CommandError(t.reason_too_long)
+    if not await confirm_action(ctx, conf_embed):
+        return
 
-        conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_mute_edit.reason(mute.reason, reason), color=Colors.ModTools
-        )
+    try:
+        user = await self.bot.fetch_user(mute.member)
+    except (NotFound, HTTPException):
+        raise CommandError(t.user_not_found)
+
+    user_embed = Embed(title=t.mute, description=t.mute_edited.reason(mute.reason, reason), colour=Colors.ModTools)
+    server_embed = Embed(title=t.mute, description=t.mute_edited_response, colour=Colors.ModTools)
+    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+
+    await Mute.edit_reason(mute_id, ctx.author.id, await get_mod_level(ctx.author), reason)
+
+    try:
+        await user.send(embed=user_embed)
+    except (Forbidden, HTTPException):
+        server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
+        server_embed.colour = Colors.error
+    await reply(ctx, embed=server_embed)
+    await send_to_changelog_mod(
+        guild=ctx.guild,
+        message=ctx.message,
+        colour=Colors.mute,
+        title=t.log_mute_edited,
+        member=user,
+        reason=reason,
+    )
+
+
+@edit_mute.command(name="duration", aliases=["d"])
+@docs(t.commands.edit_mute_duration)
+async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time: DurationConverter):
+    user: Union[Member, User]
+    time: Optional[int]
+    minutes = time
+
+    active_mutes: List[Mute] = sorted(
+        await db.all(filter_by(Mute, active=True, member=user.id)), key=lambda active_mute: active_mute.timestamp
+    )
+
+    if not active_mutes:
+        raise CommandError(t.not_muted)
+
+    mute = active_mutes[0]
+
+    if not await compare_mod_level(ctx.author, mute.mod_level) or not ctx.author.id == mute.mod:
+        raise CommandError(tg.permission_denied)
 
-        if not await confirm_action(ctx, conf_embed):
-            return
+    if mute.minutes == minutes or (mute.minutes == -1 and minutes is None):
+        raise CommandError(t.already_muted)
 
-        try:
-            user = await self.bot.fetch_user(mute.member)
-        except (NotFound, HTTPException):
-            raise CommandError(t.user_not_found)
+    conf_embed = Embed(title=t.confirmation, color=Colors.ModTools)
 
-        user_embed = Embed(title=t.mute, description=t.mute_edited.reason(mute.reason, reason), colour=Colors.ModTools)
-        server_embed = Embed(title=t.mute, description=t.mute_edited_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+    old_time = t.infinity if mute.minutes == -1 else time_to_units(mute.minutes)
 
-        await Mute.edit_reason(mute_id, ctx.author.id, await get_mod_level(ctx.author), reason)
+    if minutes is None:
+        conf_embed.description = t.confirm_mute_edit.duration(old_time, t.infinity)
+    else:
+        conf_embed.description = t.confirm_mute_edit.duration(old_time, time_to_units(minutes))
 
-        try:
-            await user.send(embed=user_embed)
-        except (Forbidden, HTTPException):
-            server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-            server_embed.colour = Colors.error
-        await reply(ctx, embed=server_embed)
-        await send_to_changelog_mod(
-            guild=ctx.guild,
-            message=ctx.message,
-            colour=Colors.mute,
-            title=t.log_mute_edited,
-            member=user,
-            reason=reason,
-        )
+    if not await confirm_action(ctx, conf_embed):
+        return
 
-    @edit_mute.command(name="duration", aliases=["d"])
-    @docs(t.commands.edit_mute_duration)
-    async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time: DurationConverter):
-        user: Union[Member, User]
-        time: Optional[int]
-        minutes = time
+    for active_mute in active_mutes[1:]:
+        await Mute.delete(active_mute.id)
+
+    user_embed = Embed(title=t.mute, colour=Colors.ModTools)
+    server_embed = Embed(title=t.mute, description=t.mute_edited_response, colour=Colors.ModTools)
+    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+
+    await Mute.edit_duration(mute.id, ctx.author.id, await get_mod_level(ctx.author), minutes)
+
+    await invalidate_entry_cache()
+
+    user_embed.description = t.mute_edited.duration(
+        time_to_units(mute.minutes), t.infinity if minutes is None else time_to_units(minutes)
+    )
+    await send_to_changelog_mod(
+        guild=ctx.guild,
+        message=ctx.message,
+        colour=Colors.mute,
+        title=t.log_mute_edited,
+        member=user,
+        reason=Mute.reason,
+        duration=t.log_field.infinity if minutes is None else time_to_units(minutes),
+    )
+
+    try:
+        await user.send(embed=user_embed)
+    except (Forbidden, HTTPException):
+        server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
+        server_embed.colour = Colors.error
+    await reply(ctx, embed=server_embed)
+
+
+@commands.command(aliases=["mute_delete"])
+@ModPermission.mute.check
+@guild_only()
+@docs(t.commands.delete_mute)
+async def delete_mute(self, ctx: Context, mute_id: int):
+    mute = await get_and_compare_entry(Mute, mute_id, ctx.author)
+
+    conf_embed = Embed(
+        title=t.confirmation, description=t.confirm_mute_delete(mute.member_name, mute.id), color=Colors.ModTools
+    )
+
+    if not await confirm_action(ctx, conf_embed):
+        return
 
-        active_mutes: List[Mute] = sorted(
-            await db.all(filter_by(Mute, active=True, member=user.id)), key=lambda active_mute: active_mute.timestamp
-        )
+    active_mutes: List[Mute] = await db.all(filter_by(Mute, active=True, member=mute.member))
 
-        if not active_mutes:
-            raise CommandError(t.not_muted)
+    if len(active_mutes) == 1 and mute in active_mutes:
+        user = ctx.guild.get_member(mute.member)
+        if user is not None:
+            if (mute_role := await get_mute_role(ctx.guild)) in user.roles:
+                await user.remove_roles(mute_role)
 
-        mute = active_mutes[0]
+    try:
+        user = await self.bot.fetch_user(mute.member)
+    except (NotFound, HTTPException):
+        raise CommandError(t.user_not_found)
 
-        if not await compare_mod_level(ctx.author, mute.mod_level) or not ctx.author.id == mute.mod:
-            raise CommandError(tg.permission_denied)
+    await Mute.delete(mute_id)
 
-        if mute.minutes == minutes or (mute.minutes == -1 and minutes is None):
-            raise CommandError(t.already_muted)
+    await invalidate_entry_cache()
 
-        conf_embed = Embed(title=t.confirmation, color=Colors.ModTools)
+    server_embed = Embed(title=t.mute, description=t.mute_deleted_response, colour=Colors.ModTools)
+    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-        old_time = t.infinity if mute.minutes == -1 else time_to_units(mute.minutes)
+    if await ModSettings.send_delete_user_message.get():
+        user_embed = Embed(title=t.warn, colour=Colors.ModTools)
 
-        if minutes is None:
-            conf_embed.description = t.confirm_mute_edit.duration(old_time, t.infinity)
+        if mute.minutes == -1:
+            user_embed.description = t.mute_deleted.inf(mute.reason)
         else:
-            conf_embed.description = t.confirm_mute_edit.duration(old_time, time_to_units(minutes))
-
-        if not await confirm_action(ctx, conf_embed):
-            return
-
-        for active_mute in active_mutes[1:]:
-            await Mute.delete(active_mute.id)
-
-        user_embed = Embed(title=t.mute, colour=Colors.ModTools)
-        server_embed = Embed(title=t.mute, description=t.mute_edited_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-
-        await Mute.edit_duration(mute.id, ctx.author.id, await get_mod_level(ctx.author), minutes)
-
-        await invalidate_entry_cache()
-
-        user_embed.description = t.mute_edited.duration(
-            time_to_units(mute.minutes), t.infinity if minutes is None else time_to_units(minutes)
-        )
-        await send_to_changelog_mod(
-            guild=ctx.guild,
-            message=ctx.message,
-            colour=Colors.mute,
-            title=t.log_mute_edited,
-            member=user,
-            reason=Mute.reason,
-            duration=t.log_field.infinity if minutes is None else time_to_units(minutes),
-        )
+            user_embed.description = t.mute_deleted.not_inf(time_to_units(mute.minutes), mute.reason)
 
         try:
             await user.send(embed=user_embed)
         except (Forbidden, HTTPException):
             server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
             server_embed.colour = Colors.error
-        await reply(ctx, embed=server_embed)
-
-    @commands.command(aliases=["mute_delete"])
-    @ModPermission.mute.check
-    @guild_only()
-    @docs(t.commands.delete_mute)
-    async def delete_mute(self, ctx: Context, mute_id: int):
-        mute = await get_and_compare_entry(Mute, mute_id, ctx.author)
 
-        conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_mute_delete(mute.member_name, mute.id), color=Colors.ModTools
-        )
-
-        if not await confirm_action(ctx, conf_embed):
-            return
+    await reply(ctx, embed=server_embed)
 
-        active_mutes: List[Mute] = await db.all(filter_by(Mute, active=True, member=mute.member))
+    await send_to_changelog_mod(
+        guild=ctx.guild,
+        message=ctx.message,
+        colour=Colors.mute,
+        title=t.log_mute_deleted,
+        member=user,
+        reason=mute.reason,
+        duration=t.log_field_infinity if mute.minutes == -1 else time_to_units(mute.minutes),
+    )
 
-        if len(active_mutes) == 1 and mute in active_mutes:
-            user = ctx.guild.get_member(mute.member)
-            if user is not None:
-                if (mute_role := await get_mute_role(ctx.guild)) in user.roles:
-                    await user.remove_roles(mute_role)
 
-        try:
-            user = await self.bot.fetch_user(mute.member)
-        except (NotFound, HTTPException):
-            raise CommandError(t.user_not_found)
-
-        await Mute.delete(mute_id)
+@commands.command()
+@ModPermission.mute.check
+@guild_only()
+@docs(t.commands.unmute)
+async def unmute(self, ctx: Context, user: UserMemberConverter, *, reason: str):
+    user: Union[Member, User]
 
-        await invalidate_entry_cache()
+    if len(reason) > 900:
+        raise CommandError(t.reason_too_long)
 
-        server_embed = Embed(title=t.mute, description=t.mute_deleted_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+    mute_role: Role = await get_mute_role(ctx.guild)
 
-        if await ModSettings.send_delete_user_message.get():
-            user_embed = Embed(title=t.warn, colour=Colors.ModTools)
+    was_muted = False
+    if isinstance(user, Member) and mute_role in user.roles:
+        was_muted = True
+        await user.remove_roles(mute_role)
 
-            if mute.minutes == -1:
-                user_embed.description = t.mute_deleted.inf(mute.reason)
-            else:
-                user_embed.description = t.mute_deleted.not_inf(time_to_units(mute.minutes), mute.reason)
-
-            try:
-                await user.send(embed=user_embed)
-            except (Forbidden, HTTPException):
-                server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-                server_embed.colour = Colors.error
-
-        await reply(ctx, embed=server_embed)
-
-        await send_to_changelog_mod(
-            guild=ctx.guild,
-            message=ctx.message,
-            colour=Colors.mute,
-            title=t.log_mute_deleted,
-            member=user,
-            reason=mute.reason,
-            duration=t.log_field_infinity if mute.minutes == -1 else time_to_units(mute.minutes),
-        )
-
-    @commands.command()
-    @ModPermission.mute.check
-    @guild_only()
-    @docs(t.commands.unmute)
-    async def unmute(self, ctx: Context, user: UserMemberConverter, *, reason: str):
-        user: Union[Member, User]
-
-        if len(reason) > 900:
-            raise CommandError(t.reason_too_long)
-
-        mute_role: Role = await get_mute_role(ctx.guild)
-
-        was_muted = False
-        if isinstance(user, Member) and mute_role in user.roles:
-            was_muted = True
-            await user.remove_roles(mute_role)
-
-        minutes = 0
-        async for mute in await db.stream(filter_by(Mute, active=True, member=user.id)):
-            if not await compare_mod_level(ctx.author, mute.mod_level) or not ctx.author.id == mute.mod:
-                raise CommandError(tg.permission_denied)
-
-            await Mute.deactivate(mute.id, ctx.author.id, reason)
-
-            was_muted = True
-
-            if mute.minutes > minutes or mute.minutes == -1:
-                minutes = mute.minutes
-
-        if not was_muted:
-            raise UserCommandError(user, t.not_muted)
-
-        await invalidate_entry_cache()
-
-        server_embed = Embed(title=t.unmute, description=t.unmuted_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-        await reply(ctx, embed=server_embed)
-        await send_to_changelog_mod(
-            guild=ctx.guild,
-            message=ctx.message,
-            colour=Colors.unmute,
-            title=t.log_unmuted,
-            member=user,
-            reason=reason,
-            duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
-            mod=ctx.author,
-            original_reason=mute.reason,
-        )
+    minutes = 0
+    async for mute in await db.stream(filter_by(Mute, active=True, member=user.id)):
+        if not await compare_mod_level(ctx.author, mute.mod_level) or not ctx.author.id == mute.mod:
+            raise CommandError(tg.permission_denied)
 
-    @commands.command()
-    @ModPermission.kick.check
-    @guild_only()
-    @docs(t.commands.kick)
-    async def kick(self, ctx: Context, member: Member, *, reason: str):
-        if len(reason) > 900:
-            raise CommandError(t.reason_too_long)
+        await Mute.deactivate(mute.id, ctx.author.id, reason)
 
-        if member == self.bot.user or await is_teamler(member):
-            raise UserCommandError(member, t.cannot_kick)
+        was_muted = True
 
-        if not ctx.guild.me.guild_permissions.kick_members:
-            raise CommandError(t.cannot_kick_permissions)
+        if mute.minutes > minutes or mute.minutes == -1:
+            minutes = mute.minutes
 
-        if member.top_role >= ctx.guild.me.top_role or member.id == ctx.guild.owner_id:
-            raise UserCommandError(member, t.cannot_kick)
+    if not was_muted:
+        raise UserCommandError(user, t.not_muted)
 
-        attachments = ctx.message.attachments
-        evidence = attachments[0] if attachments else None
-        evidence_url = evidence.url if attachments else None
+    await invalidate_entry_cache()
 
-        if not evidence:
-            if not await confirm_no_evidence(ctx):
-                return
+    server_embed = Embed(title=t.unmute, description=t.unmuted_response, colour=Colors.ModTools)
+    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+    await reply(ctx, embed=server_embed)
+    await send_to_changelog_mod(
+        guild=ctx.guild,
+        message=ctx.message,
+        colour=Colors.unmute,
+        title=t.log_unmuted,
+        member=user,
+        reason=reason,
+        duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
+        mod=ctx.author,
+        original_reason=mute.reason,
+    )
 
-        await Kick.create(member.id, str(member), ctx.author.id, await get_mod_level(ctx.author), reason, evidence_url)
-        await send_to_changelog_mod(
-            guild=ctx.guild,
-            message=ctx.message,
-            colour=Colors.kick,
-            title=t.log_kicked,
-            member=member,
-            reason=reason,
-            evidence=evidence,
-        )
 
-        user_embed = Embed(
-            title=t.kick,
-            colour=Colors.ModTools,
-            description=t.kicked(ctx.author.mention, ctx.guild.name, reason),
-        )
+@commands.command()
+@ModPermission.kick.check
+@guild_only()
+@docs(t.commands.kick)
+async def kick(self, ctx: Context, member: Member, *, reason: str):
+    if len(reason) > 900:
+        raise CommandError(t.reason_too_long)
 
-        server_embed = Embed(title=t.kick, description=t.kicked_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(member), icon_url=member.display_avatar.url)
+    if member == self.bot.user or await is_teamler(member):
+        raise UserCommandError(member, t.cannot_kick)
 
-        try:
-            await member.send(embed=user_embed)
-        except (Forbidden, HTTPException):
-            server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-            server_embed.colour = Colors.error
+    if not ctx.guild.me.guild_permissions.kick_members:
+        raise CommandError(t.cannot_kick_permissions)
 
-        await member.kick(reason=reason)
-        await revoke_verification(member)
+    if member.top_role >= ctx.guild.me.top_role or member.id == ctx.guild.owner_id:
+        raise UserCommandError(member, t.cannot_kick)
 
-        await reply(ctx, embed=server_embed)
+    attachments = ctx.message.attachments
+    evidence = attachments[0] if attachments else None
+    evidence_url = evidence.url if attachments else None
 
-    @commands.command(aliases=["kick_edit"])
-    @ModPermission.kick.check
-    @guild_only()
-    @docs(t.commands.edit_kick)
-    async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
-        kick = await get_and_compare_entry(Kick, kick_id, ctx.author)
+    if not evidence:
+        if not await confirm_no_evidence(ctx):
+            return
 
-        if len(reason) > 900:
-            raise CommandError(t.reason_too_long)
+    await Kick.create(member.id, str(member), ctx.author.id, await get_mod_level(ctx.author), reason, evidence_url)
+    await send_to_changelog_mod(
+        guild=ctx.guild,
+        message=ctx.message,
+        colour=Colors.kick,
+        title=t.log_kicked,
+        member=member,
+        reason=reason,
+        evidence=evidence,
+    )
+
+    user_embed = Embed(
+        title=t.kick,
+        colour=Colors.ModTools,
+        description=t.kicked(ctx.author.mention, ctx.guild.name, reason),
+    )
+
+    server_embed = Embed(title=t.kick, description=t.kicked_response, colour=Colors.ModTools)
+    server_embed.set_author(name=str(member), icon_url=member.display_avatar.url)
+
+    try:
+        await member.send(embed=user_embed)
+    except (Forbidden, HTTPException):
+        server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
+        server_embed.colour = Colors.error
+
+    await member.kick(reason=reason)
+    await revoke_verification(member)
+
+    await reply(ctx, embed=server_embed)
+
+
+@commands.command(aliases=["kick_edit"])
+@ModPermission.kick.check
+@guild_only()
+@docs(t.commands.edit_kick)
+async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
+    kick = await get_and_compare_entry(Kick, kick_id, ctx.author)
+
+    if len(reason) > 900:
+        raise CommandError(t.reason_too_long)
+
+    conf_embed = Embed(
+        title=t.confirmation, description=t.confirm_kick_edit(kick.reason, reason), color=Colors.ModTools
+    )
+
+    if not await confirm_action(ctx, conf_embed):
+        return
 
-        conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_kick_edit(kick.reason, reason), color=Colors.ModTools
-        )
+    try:
+        user = await self.bot.fetch_user(kick.member)
+    except (NotFound, HTTPException):
+        raise CommandError(t.user_not_found)
+
+    user_embed = Embed(title=t.kick, description=t.kick_edited(kick.reason, reason), colour=Colors.ModTools)
+    server_embed = Embed(title=t.kick, description=t.kick_edited_reponse, colour=Colors.ModTools)
+    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+
+    await Kick.edit(kick_id, ctx.author.id, await get_mod_level(ctx.author), reason)
+
+    try:
+        await user.send(embed=user_embed)
+    except (Forbidden, HTTPException):
+        server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
+        server_embed.colour = Colors.error
+    await reply(ctx, embed=server_embed)
+    await send_to_changelog_mod(
+        guild=ctx.guild,
+        message=ctx.message,
+        colour=Colors.kick,
+        title=t.log_kick_edited,
+        member=user,
+        reason=reason,
+    )
+
+
+@commands.command(aliases=["kick_delete"])
+@ModPermission.kick.check
+@guild_only()
+@docs(t.commands.delete_kick)
+async def delete_kick(self, ctx: Context, kick_id: int):
+    kick = await get_and_compare_entry(Kick, kick_id, ctx.author)
+
+    conf_embed = Embed(
+        title=t.confirmation, description=t.confirm_kick_delete(kick.member_name, kick.id), color=Colors.ModTools
+    )
+
+    if not await confirm_action(ctx, conf_embed):
+        return
 
-        if not await confirm_action(ctx, conf_embed):
-            return
+    await Kick.delete(kick_id)
 
-        try:
-            user = await self.bot.fetch_user(kick.member)
-        except (NotFound, HTTPException):
-            raise CommandError(t.user_not_found)
+    try:
+        user = await self.bot.fetch_user(kick.member)
+    except (NotFound, HTTPException):
+        raise CommandError(t.user_not_found)
 
-        user_embed = Embed(title=t.kick, description=t.kick_edited(kick.reason, reason), colour=Colors.ModTools)
-        server_embed = Embed(title=t.kick, description=t.kick_edited_reponse, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+    server_embed = Embed(title=t.warn, description=t.kick_deleted_response, colour=Colors.ModTools)
+    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-        await Kick.edit(kick_id, ctx.author.id, await get_mod_level(ctx.author), reason)
+    if await ModSettings.send_delete_user_message.get():
+        user_embed = Embed(title=t.kick, description=t.kick_deleted(kick.reason), colour=Colors.ModTools)
 
         try:
             await user.send(embed=user_embed)
         except (Forbidden, HTTPException):
             server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
             server_embed.colour = Colors.error
-        await reply(ctx, embed=server_embed)
-        await send_to_changelog_mod(
-            guild=ctx.guild,
-            message=ctx.message,
-            colour=Colors.kick,
-            title=t.log_kick_edited,
-            member=user,
-            reason=reason,
-        )
-
-    @commands.command(aliases=["kick_delete"])
-    @ModPermission.kick.check
-    @guild_only()
-    @docs(t.commands.delete_kick)
-    async def delete_kick(self, ctx: Context, kick_id: int):
-        kick = await get_and_compare_entry(Kick, kick_id, ctx.author)
 
-        conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_kick_delete(kick.member_name, kick.id), color=Colors.ModTools
-        )
-
-        if not await confirm_action(ctx, conf_embed):
+    await reply(ctx, embed=server_embed)
+    await send_to_changelog_mod(
+        guild=ctx.guild,
+        message=ctx.message,
+        colour=Colors.kick,
+        title=t.log_kick_deleted,
+        member=user,
+        reason=kick.reason,
+    )
+
+
+@commands.command()
+@ModPermission.ban.check
+@guild_only()
+@docs(t.commands.ban)
+async def ban(self, ctx: Context, user: UserMemberConverter, time: DurationConverter, delete_days: int, *, reason: str):
+    time: Optional[int]
+    minutes = time
+
+    user: Union[Member, User]
+
+    if not ctx.guild.me.guild_permissions.ban_members:
+        raise CommandError(t.cannot_ban_permissions)
+
+    if len(reason) > 900:
+        raise CommandError(t.reason_too_long)
+    if not 0 <= delete_days <= 7:
+        raise CommandError(tg.invalid_duration)
+
+    if user == self.bot.user or await is_teamler(user):
+        raise UserCommandError(user, t.cannot_ban)
+    if isinstance(user, Member) and (user.top_role >= ctx.guild.me.top_role or user.id == ctx.guild.owner_id):
+        raise UserCommandError(user, t.cannot_ban)
+
+    active_bans: List[Ban] = await db.all(filter_by(Ban, active=True, member=user.id))
+    if active_bans:
+        raise UserCommandError(user, t.already_banned)
+
+    active_mutes: List[Mute] = await db.all(filter_by(Mute, active=True, member=user.id))
+    for mute in active_mutes:
+        await Mute.deactivate(mute.id, ctx.author.id, t.cancelled_by_ban)
+
+    attachments = ctx.message.attachments
+    evidence = attachments[0] if attachments else None
+    evidence_url = evidence.url if attachments else None
+
+    if not evidence:
+        if not await confirm_no_evidence(ctx):
             return
 
-        await Kick.delete(kick_id)
+    user_embed = Embed(title=t.ban, colour=Colors.ModTools)
+    server_embed = Embed(title=t.ban, description=t.banned_response, colour=Colors.ModTools)
+    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+
+    if active_mutes:
+        server_embed.description += f"\n\n{t.previously_muted}"
+
+    await Ban.create(
+        user.id,
+        str(user),
+        ctx.author.id,
+        await get_mod_level(ctx.author),
+        minutes if minutes is not None else -1,
+        reason,
+        evidence_url,
+    )
+
+    await invalidate_entry_cache()
+
+    await send_to_changelog_mod(
+        guild=ctx.guild,
+        message=ctx.message,
+        colour=Colors.ban,
+        title=t.log_banned,
+        member=user,
+        reason=reason,
+        duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
+        evidence=evidence,
+    )
+
+    if minutes is not None:
+        user_embed.description = t.banned(ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason)
 
-        try:
-            user = await self.bot.fetch_user(kick.member)
-        except (NotFound, HTTPException):
-            raise CommandError(t.user_not_found)
+    else:
+        user_embed.description = t.banned_inf(ctx.author.mention, ctx.guild.name, reason)
 
-        server_embed = Embed(title=t.warn, description=t.kick_deleted_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+    try:
+        await user.send(embed=user_embed)
+    except (Forbidden, HTTPException):
+        server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
+        server_embed.colour = Colors.error
 
-        if await ModSettings.send_delete_user_message.get():
-            user_embed = Embed(title=t.kick, description=t.kick_deleted(kick.reason), colour=Colors.ModTools)
+    await ctx.guild.ban(user, delete_message_days=delete_days, reason=reason)
+    await revoke_verification(user)
 
-            try:
-                await user.send(embed=user_embed)
-            except (Forbidden, HTTPException):
-                server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-                server_embed.colour = Colors.error
-
-        await reply(ctx, embed=server_embed)
-        await send_to_changelog_mod(
-            guild=ctx.guild,
-            message=ctx.message,
-            colour=Colors.kick,
-            title=t.log_kick_deleted,
-            member=user,
-            reason=kick.reason,
-        )
+    await reply(ctx, embed=server_embed)
 
-    @commands.command()
-    @ModPermission.ban.check
-    @guild_only()
-    @docs(t.commands.ban)
-    async def ban(
-        self, ctx: Context, user: UserMemberConverter, time: DurationConverter, delete_days: int, *, reason: str
-    ):
-        time: Optional[int]
-        minutes = time
-
-        user: Union[Member, User]
-
-        if not ctx.guild.me.guild_permissions.ban_members:
-            raise CommandError(t.cannot_ban_permissions)
-
-        if len(reason) > 900:
-            raise CommandError(t.reason_too_long)
-        if not 0 <= delete_days <= 7:
-            raise CommandError(tg.invalid_duration)
-
-        if user == self.bot.user or await is_teamler(user):
-            raise UserCommandError(user, t.cannot_ban)
-        if isinstance(user, Member) and (user.top_role >= ctx.guild.me.top_role or user.id == ctx.guild.owner_id):
-            raise UserCommandError(user, t.cannot_ban)
-
-        active_bans: List[Ban] = await db.all(filter_by(Ban, active=True, member=user.id))
-        if active_bans:
-            raise UserCommandError(user, t.already_banned)
-
-        active_mutes: List[Mute] = await db.all(filter_by(Mute, active=True, member=user.id))
-        for mute in active_mutes:
-            await Mute.deactivate(mute.id, ctx.author.id, t.cancelled_by_ban)
-
-        attachments = ctx.message.attachments
-        evidence = attachments[0] if attachments else None
-        evidence_url = evidence.url if attachments else None
-
-        if not evidence:
-            if not await confirm_no_evidence(ctx):
-                return
 
-        user_embed = Embed(title=t.ban, colour=Colors.ModTools)
-        server_embed = Embed(title=t.ban, description=t.banned_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-
-        if active_mutes:
-            server_embed.description += f"\n\n{t.previously_muted}"
-
-        await Ban.create(
-            user.id,
-            str(user),
-            ctx.author.id,
-            await get_mod_level(ctx.author),
-            minutes if minutes is not None else -1,
-            reason,
-            evidence_url,
-        )
+@commands.group(aliases=["ban_edit"])
+@ModPermission.mute.check
+@guild_only()
+@docs(t.commands.edit_ban)
+async def edit_ban(self, ctx):
+    if ctx.invoked_subcommand is None:
+        raise UserInputError
 
-        await invalidate_entry_cache()
-
-        await send_to_changelog_mod(
-            guild=ctx.guild,
-            message=ctx.message,
-            colour=Colors.ban,
-            title=t.log_banned,
-            member=user,
-            reason=reason,
-            duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
-            evidence=evidence,
-        )
 
-        if minutes is not None:
-            user_embed.description = t.banned(ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason)
+@edit_ban.command(name="reason", aliases=["r"])
+@docs(t.commands.edit_ban_reason)
+async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
+    ban = await get_and_compare_entry(Ban, ban_id, ctx.author)
 
-        else:
-            user_embed.description = t.banned_inf(ctx.author.mention, ctx.guild.name, reason)
+    if len(reason) > 900:
+        raise CommandError(t.reason_too_long)
 
-        try:
-            await user.send(embed=user_embed)
-        except (Forbidden, HTTPException):
-            server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-            server_embed.colour = Colors.error
+    conf_embed = Embed(
+        title=t.confirmation, description=t.confirm_ban_edit.reason(ban.reason, reason), color=Colors.ModTools
+    )
 
-        await ctx.guild.ban(user, delete_message_days=delete_days, reason=reason)
-        await revoke_verification(user)
+    if not await confirm_action(ctx, conf_embed):
+        return
 
-        await reply(ctx, embed=server_embed)
+    try:
+        user = await self.bot.fetch_user(ban.member)
+    except (NotFound, HTTPException):
+        raise CommandError(t.user_not_found)
 
-    @commands.group(aliases=["ban_edit"])
-    @ModPermission.mute.check
-    @guild_only()
-    @docs(t.commands.edit_ban)
-    async def edit_ban(self, ctx):
-        if ctx.invoked_subcommand is None:
-            raise UserInputError
+    user_embed = Embed(title=t.ban, description=t.ban_edited.reason(ban.reason, reason), colour=Colors.ModTools)
+    server_embed = Embed(title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools)
+    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-    @edit_ban.command(name="reason", aliases=["r"])
-    @docs(t.commands.edit_ban_reason)
-    async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
-        ban = await get_and_compare_entry(Ban, ban_id, ctx.author)
+    await Ban.edit_reason(ban_id, ctx.author.id, await get_mod_level(ctx.author), reason)
 
-        if len(reason) > 900:
-            raise CommandError(t.reason_too_long)
+    try:
+        await user.send(embed=user_embed)
+    except (Forbidden, HTTPException):
+        server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
+        server_embed.colour = Colors.error
+    await reply(ctx, embed=server_embed)
+    await send_to_changelog_mod(
+        guild=ctx.guild, message=ctx.message, colour=Colors.ban, title=t.log_ban_edited, member=user, reason=reason
+    )
 
-        conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_ban_edit.reason(ban.reason, reason), color=Colors.ModTools
-        )
 
-        if not await confirm_action(ctx, conf_embed):
-            return
+@edit_ban.command(name="duration", aliases=["d"])
+@docs(t.commands.edit_ban_duration)
+async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time: DurationConverter):
+    user: Union[Member, User]
+    time: Optional[int]
+    minutes = time
 
-        try:
-            user = await self.bot.fetch_user(ban.member)
-        except (NotFound, HTTPException):
-            raise CommandError(t.user_not_found)
+    active_bans: List[Ban] = sorted(
+        await db.all(filter_by(Ban, active=True, member=user.id)), key=lambda active_ban: active_ban.timestamp
+    )
 
-        user_embed = Embed(title=t.ban, description=t.ban_edited.reason(ban.reason, reason), colour=Colors.ModTools)
-        server_embed = Embed(title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+    if not active_bans:
+        raise CommandError(t.not_banned)
 
-        await Ban.edit_reason(ban_id, ctx.author.id, await get_mod_level(ctx.author), reason)
+    ban = active_bans[0]
 
-        try:
-            await user.send(embed=user_embed)
-        except (Forbidden, HTTPException):
-            server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-            server_embed.colour = Colors.error
-        await reply(ctx, embed=server_embed)
-        await send_to_changelog_mod(
-            guild=ctx.guild, message=ctx.message, colour=Colors.ban, title=t.log_ban_edited, member=user, reason=reason
-        )
+    if not await compare_mod_level(ctx.author, ban.mod_level) or not ctx.author.id == ban.mod:
+        raise CommandError(tg.permission_denied)
 
-    @edit_ban.command(name="duration", aliases=["d"])
-    @docs(t.commands.edit_ban_duration)
-    async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time: DurationConverter):
-        user: Union[Member, User]
-        time: Optional[int]
-        minutes = time
+    if ban.minutes == minutes or (ban.minutes == -1 and minutes is None):
+        raise CommandError(t.already_banned)
 
-        active_bans: List[Ban] = sorted(
-            await db.all(filter_by(Ban, active=True, member=user.id)), key=lambda active_ban: active_ban.timestamp
-        )
+    conf_embed = Embed(title=t.confirmation, color=Colors.ModTools)
 
-        if not active_bans:
-            raise CommandError(t.not_banned)
+    old_time = t.infinity if ban.minutes == -1 else time_to_units(ban.minutes)
 
-        ban = active_bans[0]
+    if minutes is None:
+        conf_embed.description = t.confirm_ban_edit.duration(old_time, t.infinity)
+    else:
+        conf_embed.description = t.confirm_ban_edit.duration(old_time, time_to_units(minutes))
 
-        if not await compare_mod_level(ctx.author, ban.mod_level) or not ctx.author.id == ban.mod:
-            raise CommandError(tg.permission_denied)
+    if not await confirm_action(ctx, conf_embed):
+        return
 
-        if ban.minutes == minutes or (ban.minutes == -1 and minutes is None):
-            raise CommandError(t.already_banned)
+    for ban in active_bans[1:]:
+        await Ban.delete(ban.id)
+
+    user_embed = Embed(title=t.ban, colour=Colors.ModTools)
+    server_embed = Embed(title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools)
+    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+
+    await Ban.edit_duration(ban.id, ctx.author.id, await get_mod_level(ctx.author), minutes)
+
+    await invalidate_entry_cache()
+
+    user_embed.description = t.ban_edited.duration(
+        time_to_units(ban.minutes), t.infinity if minutes is None else time_to_units(minutes)
+    )
+    await send_to_changelog_mod(
+        guild=ctx.guild,
+        message=ctx.message,
+        colour=Colors.ban,
+        title=t.log_ban_edited,
+        member=user,
+        reason=ban.reason,
+        duration=t.log_field.infinity if minutes is None else time_to_units(minutes),
+    )
+
+    try:
+        await user.send(embed=user_embed)
+    except (Forbidden, HTTPException):
+        server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
+        server_embed.colour = Colors.error
+    await reply(ctx, embed=server_embed)
+
+
+@commands.command(aliases=["ban_delete"])
+@ModPermission.ban.check
+@guild_only()
+@docs(t.commands.delete_ban)
+async def delete_ban(self, ctx: Context, ban_id: int):
+    ban = await get_and_compare_entry(Ban, ban_id, ctx.author)
+
+    conf_embed = Embed(
+        title=t.confirmation, description=t.confirm_ban_delete(ban.member_name, ban.id), color=Colors.ModTools
+    )
+
+    if not await confirm_action(ctx, conf_embed):
+        return
 
-        conf_embed = Embed(title=t.confirmation, color=Colors.ModTools)
+    active_bans: List[Ban] = await db.all(filter_by(Ban, active=True, member=ban.member))
 
-        old_time = t.infinity if ban.minutes == -1 else time_to_units(ban.minutes)
+    if len(active_bans) == 1 and ban in active_bans:
+        user = ctx.guild.get_member(ban.member)
+        if user is not None:
+            try:
+                await ctx.guild.unban(user, reason="Ban deleted")
+            except HTTPException:
+                pass
 
-        if minutes is None:
-            conf_embed.description = t.confirm_ban_edit.duration(old_time, t.infinity)
-        else:
-            conf_embed.description = t.confirm_ban_edit.duration(old_time, time_to_units(minutes))
+    try:
+        user = await self.bot.fetch_user(ban.member)
+    except (NotFound, HTTPException):
+        raise CommandError(t.user_not_found)
 
-        if not await confirm_action(ctx, conf_embed):
-            return
+    await Ban.delete(ban_id)
 
-        for ban in active_bans[1:]:
-            await Ban.delete(ban.id)
+    await invalidate_entry_cache()
 
-        user_embed = Embed(title=t.ban, colour=Colors.ModTools)
-        server_embed = Embed(title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+    server_embed = Embed(title=t.mute, description=t.ban_deleted_response, colour=Colors.ModTools)
 
-        await Ban.edit_duration(ban.id, ctx.author.id, await get_mod_level(ctx.author), minutes)
+    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-        await invalidate_entry_cache()
+    if await ModSettings.send_delete_user_message.get():
+        user_embed = Embed(title=t.ban, colour=Colors.ModTools)
 
-        user_embed.description = t.ban_edited.duration(
-            time_to_units(ban.minutes), t.infinity if minutes is None else time_to_units(minutes)
-        )
-        await send_to_changelog_mod(
-            guild=ctx.guild,
-            message=ctx.message,
-            colour=Colors.ban,
-            title=t.log_ban_edited,
-            member=user,
-            reason=ban.reason,
-            duration=t.log_field.infinity if minutes is None else time_to_units(minutes),
-        )
+        if ban.minutes == -1:
+            user_embed.description = t.ban_deleted.inf(ban.reason)
+        else:
+            user_embed.description = t.ban_deleted.not_inf(time_to_units(ban.minutes), ban.reason)
 
         try:
             await user.send(embed=user_embed)
         except (Forbidden, HTTPException):
             server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
             server_embed.colour = Colors.error
-        await reply(ctx, embed=server_embed)
-
-    @commands.command(aliases=["ban_delete"])
-    @ModPermission.ban.check
-    @guild_only()
-    @docs(t.commands.delete_ban)
-    async def delete_ban(self, ctx: Context, ban_id: int):
-        ban = await get_and_compare_entry(Ban, ban_id, ctx.author)
-
-        conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_ban_delete(ban.member_name, ban.id), color=Colors.ModTools
-        )
-
-        if not await confirm_action(ctx, conf_embed):
-            return
-
-        active_bans: List[Ban] = await db.all(filter_by(Ban, active=True, member=ban.member))
-
-        if len(active_bans) == 1 and ban in active_bans:
-            user = ctx.guild.get_member(ban.member)
-            if user is not None:
-                try:
-                    await ctx.guild.unban(user, reason="Ban deleted")
-                except HTTPException:
-                    pass
 
-        try:
-            user = await self.bot.fetch_user(ban.member)
-        except (NotFound, HTTPException):
-            raise CommandError(t.user_not_found)
-
-        await Ban.delete(ban_id)
-
-        await invalidate_entry_cache()
+    await reply(ctx, embed=server_embed)
 
-        server_embed = Embed(title=t.mute, description=t.ban_deleted_response, colour=Colors.ModTools)
+    await send_to_changelog_mod(
+        guild=ctx.guild,
+        message=ctx.message,
+        colour=Colors.ban,
+        title=t.log_ban_deleted,
+        member=user,
+        reason=ban.reason,
+        duration=t.log_field_infinity if ban.minutes == -1 else time_to_units(ban.minutes),
+    )
 
-        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-        if await ModSettings.send_delete_user_message.get():
-            user_embed = Embed(title=t.ban, colour=Colors.ModTools)
+@commands.command()
+@ModPermission.ban.check
+@guild_only()
+@docs(t.commands.unban)
+async def unban(self, ctx: Context, user: UserMemberConverter, *, reason: str):
+    user: Union[Member, User]
 
-            if ban.minutes == -1:
-                user_embed.description = t.ban_deleted.inf(ban.reason)
-            else:
-                user_embed.description = t.ban_deleted.not_inf(time_to_units(ban.minutes), ban.reason)
+    if len(reason) > 900:
+        raise CommandError(t.reason_too_long)
 
-            try:
-                await user.send(embed=user_embed)
-            except (Forbidden, HTTPException):
-                server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-                server_embed.colour = Colors.error
-
-        await reply(ctx, embed=server_embed)
-
-        await send_to_changelog_mod(
-            guild=ctx.guild,
-            message=ctx.message,
-            colour=Colors.ban,
-            title=t.log_ban_deleted,
-            member=user,
-            reason=ban.reason,
-            duration=t.log_field_infinity if ban.minutes == -1 else time_to_units(ban.minutes),
-        )
+    if not ctx.guild.me.guild_permissions.ban_members:
+        raise CommandError(t.cannot_unban_permissions)
 
-    @commands.command()
-    @ModPermission.ban.check
-    @guild_only()
-    @docs(t.commands.unban)
-    async def unban(self, ctx: Context, user: UserMemberConverter, *, reason: str):
-        user: Union[Member, User]
+    was_banned = True
+    try:
+        await ctx.guild.unban(user, reason=reason)
+    except HTTPException:
+        was_banned = False
 
-        if len(reason) > 900:
-            raise CommandError(t.reason_too_long)
+    minutes = 0
+    async for ban in await db.stream(filter_by(Ban, active=True, member=user.id)):
+        if not await compare_mod_level(ctx.author, ban.mod_level) or not ctx.author.id == ban.mod:
+            raise CommandError(tg.permission_denied)
 
-        if not ctx.guild.me.guild_permissions.ban_members:
-            raise CommandError(t.cannot_unban_permissions)
+        await Ban.deactivate(ban.id, ctx.author.id, reason)
 
         was_banned = True
-        try:
-            await ctx.guild.unban(user, reason=reason)
-        except HTTPException:
-            was_banned = False
-
-        minutes = 0
-        async for ban in await db.stream(filter_by(Ban, active=True, member=user.id)):
-            if not await compare_mod_level(ctx.author, ban.mod_level) or not ctx.author.id == ban.mod:
-                raise CommandError(tg.permission_denied)
-
-            await Ban.deactivate(ban.id, ctx.author.id, reason)
-
-            was_banned = True
-
-            if ban.minutes > minutes or ban.minutes == -1:
-                minutes = ban.minutes
-
-        if not was_banned:
-            raise UserCommandError(user, t.not_banned)
-
-        await invalidate_entry_cache()
-
-        server_embed = Embed(title=t.unban, description=t.unbanned_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-        await reply(ctx, embed=server_embed)
-        await send_to_changelog_mod(
-            guild=ctx.guild,
-            message=ctx.message,
-            colour=Colors.unban,
-            title=t.log_unbanned,
-            member=user,
-            reason=reason,
-            duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
-            mod=ctx.author,
-            original_reason=ban.reason,
-        )
+
+        if ban.minutes > minutes or ban.minutes == -1:
+            minutes = ban.minutes
+
+    if not was_banned:
+        raise UserCommandError(user, t.not_banned)
+
+    await invalidate_entry_cache()
+
+    server_embed = Embed(title=t.unban, description=t.unbanned_response, colour=Colors.ModTools)
+    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+    await reply(ctx, embed=server_embed)
+    await send_to_changelog_mod(
+        guild=ctx.guild,
+        message=ctx.message,
+        colour=Colors.unban,
+        title=t.log_unbanned,
+        member=user,
+        reason=reason,
+        duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
+        mod=ctx.author,
+        original_reason=ban.reason,
+    )

From 62d4ba9af14c29e2778f7ea06a828c1b8dec91c9 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Mon, 11 Apr 2022 08:52:03 +0200
Subject: [PATCH 097/120] Improved codestyle

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/models.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/moderation/mod/models.py b/moderation/mod/models.py
index a62c11fec..4934d576b 100644
--- a/moderation/mod/models.py
+++ b/moderation/mod/models.py
@@ -25,7 +25,7 @@ class Punishment(ModBase):
 
     @classmethod
     async def create(
-            cls, member: int, member_name: str, mod: int, mod_level: int, reason: str, evidence: Optional[str]
+        cls, member: int, member_name: str, mod: int, mod_level: int, reason: str, evidence: Optional[str]
     ) -> Punishment:
         row = cls(
             member=member,

From 46c525ce7e2e07cfcb71de3a898f51597ffd9975 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Mon, 11 Apr 2022 21:29:59 +0200
Subject: [PATCH 098/120] Fixed amazingly stupid indents I defnitely did not
 make myself

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 1662 ++++++++++++++++++++---------------------
 1 file changed, 822 insertions(+), 840 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index de250976b..16058342a 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -495,1016 +495,998 @@ def wrap_entry(
 
         return out
 
+    async def on_member_join(self, member: Member):
+        mute_role: Optional[Role] = member.guild.get_role(await RoleSettings.get("mute"))
+        if mute_role is None:
+            return
 
-async def on_member_join(self, member: Member):
-    mute_role: Optional[Role] = member.guild.get_role(await RoleSettings.get("mute"))
-    if mute_role is None:
-        return
-
-    if await db.exists(filter_by(Mute, active=True, member=member.id)):
-        await member.add_roles(mute_role)
+        if await db.exists(filter_by(Mute, active=True, member=member.id)):
+            await member.add_roles(mute_role)
 
+    async def on_member_ban(self, guild: Guild, member: Member):
+        search_limit = 100
+        for i in range(10, 1, -1):
 
-async def on_member_ban(self, guild: Guild, member: Member):
-    search_limit = 100
-    for i in range(10, 1, -1):
+            try:
+                entry: AuditLogEntry
+                async for entry in guild.audit_logs(limit=search_limit, action=AuditLogAction.ban):
+                    if entry.user == self.bot.user:
+                        continue
+
+                    if member.id != entry.target.id:
+                        continue
+
+                    if entry.reason:
+                        await Ban.create(
+                            entry.target.id,
+                            str(entry.target),
+                            entry.user.id,
+                            await get_mod_level(entry.user),
+                            -1,
+                            entry.reason,
+                            None,
+                        )
 
-        try:
-            entry: AuditLogEntry
-            async for entry in guild.audit_logs(limit=search_limit, action=AuditLogAction.ban):
-                if entry.user == self.bot.user:
-                    continue
+                        await send_to_changelog_mod(
+                            guild=guild,
+                            message=None,
+                            colour=Colors.ban,
+                            title=t.log_banned,
+                            member=entry.target,
+                            reason=entry.reason,
+                            duration=t.log_field.infinity,
+                        )
 
-                if member.id != entry.target.id:
-                    continue
+                    else:
+                        await send_alert(guild, t.alert_member_banned(str(entry.target), str(entry.user)))
 
-                if entry.reason:
-                    await Ban.create(
-                        entry.target.id,
-                        str(entry.target),
-                        entry.user.id,
-                        await get_mod_level(entry.user),
-                        -1,
-                        entry.reason,
-                        None,
-                    )
+                    return
 
-                    await send_to_changelog_mod(
-                        guild=guild,
-                        message=None,
-                        colour=Colors.ban,
-                        title=t.log_banned,
-                        member=entry.target,
-                        reason=entry.reason,
-                        duration=t.log_field.infinity,
-                    )
+            except Forbidden:
+                await send_alert(guild, t.cannot_fetch_audit_logs)
 
-                else:
-                    await send_alert(guild, t.alert_member_banned(str(entry.target), str(entry.user)))
+            await sleep(delay=i * 10)
+            search_limit -= i * 10
 
-                return
+    @commands.command()
+    @guild_only()
+    @ModPermission.modtools_write.check
+    @docs(t.commands.send_delete_message)
+    async def send_delete_message(self, ctx: Context, send: Optional[bool] = None):
+        embed = Embed(title=t.modtools, color=Colors.ModTools)
 
-        except Forbidden:
-            await send_alert(guild, t.cannot_fetch_audit_logs)
+        if send is None:
+            send = await ModSettings.send_delete_user_message.get()
+            embed.description = t.current_send_delete_message[send]
+        else:
+            await ModSettings.send_delete_user_message.set(send)
+            embed.description = t.configured_send_delete_message[send]
 
-        await sleep(delay=i * 10)
-        search_limit -= i * 10
+        await reply(ctx, embed=embed)
+        await send_to_changelog(ctx.guild, t.configured_send_delete_message[send])
 
+    @commands.command()
+    @docs(t.commands.report)
+    async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
+        user: Union[Member, User]
 
-@commands.command()
-@guild_only()
-@ModPermission.modtools_write.check
-@docs(t.commands.send_delete_message)
-async def send_delete_message(self, ctx: Context, send: Optional[bool] = None):
-    embed = Embed(title=t.modtools, color=Colors.ModTools)
+        if len(reason) > 900:
+            raise CommandError(t.reason_too_long)
 
-    if send is None:
-        send = await ModSettings.send_delete_user_message.get()
-        embed.description = t.current_send_delete_message[send]
-    else:
-        await ModSettings.send_delete_user_message.set(send)
-        embed.description = t.configured_send_delete_message[send]
+        if user == self.bot.user:
+            raise UserCommandError(user, t.cannot_report)
+        if user == ctx.author:
+            raise UserCommandError(user, t.no_self_report)
 
-    await reply(ctx, embed=embed)
-    await send_to_changelog(ctx.guild, t.configured_send_delete_message[send])
+        conf_embed = Embed(
+            title=t.confirmation, description=t.confirm_report(user.mention, reason), color=Colors.ModTools
+        )
 
+        if not await confirm_action(ctx, conf_embed, t.report_confirmed, t.report_canceled):
+            return
 
-@commands.command()
-@docs(t.commands.report)
-async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
-    user: Union[Member, User]
+        attachments = ctx.message.attachments
+        evidence = attachments[0] if attachments else None
+        evidence_url = evidence.url if attachments else None
 
-    if len(reason) > 900:
-        raise CommandError(t.reason_too_long)
+        await Report.create(user.id, str(user), ctx.author.id, reason, evidence_url)
+        server_embed = Embed(title=t.report, description=t.reported_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+        await reply(ctx, embed=server_embed)
 
-    if user == self.bot.user:
-        raise UserCommandError(user, t.cannot_report)
-    if user == ctx.author:
-        raise UserCommandError(user, t.no_self_report)
+        alert_embed = Embed(
+            title=t.report,
+            description=t.alert_report(ctx.author.mention, user.mention, reason),
+            color=Colors.report,
+            timestamp=utcnow(),
+        )
 
-    conf_embed = Embed(title=t.confirmation, description=t.confirm_report(user.mention, reason), color=Colors.ModTools)
+        if type(ctx.channel) in (Thread, TextChannel):
+            alert_embed.add_field(
+                name=t.log_field.channel, value=t.jump_url(ctx.channel.mention, ctx.message.jump_url), inline=True
+            )
+        if evidence:
+            alert_embed.add_field(
+                name=t.log_field.evidence, value=t.image_link(evidence.filename, evidence_url), inline=True
+            )
 
-    if not await confirm_action(ctx, conf_embed, t.report_confirmed, t.report_canceled):
-        return
+        await send_alert(self.bot.guilds[0], alert_embed)
 
-    attachments = ctx.message.attachments
-    evidence = attachments[0] if attachments else None
-    evidence_url = evidence.url if attachments else None
-
-    await Report.create(user.id, str(user), ctx.author.id, reason, evidence_url)
-    server_embed = Embed(title=t.report, description=t.reported_response, colour=Colors.ModTools)
-    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-    await reply(ctx, embed=server_embed)
-
-    alert_embed = Embed(
-        title=t.report,
-        description=t.alert_report(ctx.author.mention, user.mention, reason),
-        color=Colors.report,
-        timestamp=utcnow(),
-    )
-
-    if type(ctx.channel) in (Thread, TextChannel):
-        alert_embed.add_field(
-            name=t.log_field.channel, value=t.jump_url(ctx.channel.mention, ctx.message.jump_url), inline=True
-        )
-    if evidence:
-        alert_embed.add_field(
-            name=t.log_field.evidence, value=t.image_link(evidence.filename, evidence_url), inline=True
-        )
+    @commands.command()
+    @ModPermission.warn.check
+    @guild_only()
+    @docs(t.commands.warn)
+    async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
+        user: Union[Member, User]
 
-    await send_alert(self.bot.guilds[0], alert_embed)
+        if len(reason) > 900:
+            raise CommandError(t.reason_too_long)
 
+        if user == self.bot.user:
+            raise UserCommandError(user, t.cannot_warn)
 
-@commands.command()
-@ModPermission.warn.check
-@guild_only()
-@docs(t.commands.warn)
-async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
-    user: Union[Member, User]
+        attachments = ctx.message.attachments
+        evidence = attachments[0] if attachments else None
+        evidence_url = evidence.url if attachments else None
 
-    if len(reason) > 900:
-        raise CommandError(t.reason_too_long)
+        if not evidence:
+            if not await confirm_no_evidence(ctx):
+                return
 
-    if user == self.bot.user:
-        raise UserCommandError(user, t.cannot_warn)
+        user_embed = Embed(
+            title=t.warn, colour=Colors.ModTools, description=t.warned(ctx.author.mention, ctx.guild.name, reason)
+        )
 
-    attachments = ctx.message.attachments
-    evidence = attachments[0] if attachments else None
-    evidence_url = evidence.url if attachments else None
+        server_embed = Embed(title=t.warn, description=t.warned_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+        try:
+            await user.send(embed=user_embed)
+        except (Forbidden, HTTPException):
+            server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
+            server_embed.colour = Colors.error
+        await Warn.create(user.id, str(user), ctx.author.id, await get_mod_level(ctx.author), reason, evidence_url)
+        await reply(ctx, embed=server_embed)
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.warn,
+            title=t.log_warned,
+            member=user,
+            reason=reason,
+            evidence=evidence,
+        )
 
-    if not evidence:
-        if not await confirm_no_evidence(ctx):
-            return
+    @commands.command(aliases=["warn_edit"])
+    @ModPermission.warn.check
+    @guild_only()
+    @docs(t.commands.edit_warn)
+    async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
+        warn = await get_and_compare_entry(Warn, warn_id, ctx.author)
 
-    user_embed = Embed(
-        title=t.warn, colour=Colors.ModTools, description=t.warned(ctx.author.mention, ctx.guild.name, reason)
-    )
-
-    server_embed = Embed(title=t.warn, description=t.warned_response, colour=Colors.ModTools)
-    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-    try:
-        await user.send(embed=user_embed)
-    except (Forbidden, HTTPException):
-        server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-        server_embed.colour = Colors.error
-    await Warn.create(user.id, str(user), ctx.author.id, await get_mod_level(ctx.author), reason, evidence_url)
-    await reply(ctx, embed=server_embed)
-    await send_to_changelog_mod(
-        guild=ctx.guild,
-        message=ctx.message,
-        colour=Colors.warn,
-        title=t.log_warned,
-        member=user,
-        reason=reason,
-        evidence=evidence,
-    )
-
-
-@commands.command(aliases=["warn_edit"])
-@ModPermission.warn.check
-@guild_only()
-@docs(t.commands.edit_warn)
-async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
-    warn = await get_and_compare_entry(Warn, warn_id, ctx.author)
-
-    if len(reason) > 900:
-        raise CommandError(t.reason_too_long)
-
-    conf_embed = Embed(
-        title=t.confirmation, description=t.confirm_warn_edit(warn.reason, reason), color=Colors.ModTools
-    )
-
-    if not await confirm_action(ctx, conf_embed):
-        return
+        if len(reason) > 900:
+            raise CommandError(t.reason_too_long)
 
-    try:
-        user = await self.bot.fetch_user(warn.member)
-    except (NotFound, HTTPException):
-        raise CommandError(t.user_not_found)
-
-    user_embed = Embed(title=t.warn, description=t.warn_edited(warn.reason, reason), colour=Colors.ModTools)
-    server_embed = Embed(title=t.warn, description=t.warn_edited_response, colour=Colors.ModTools)
-    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-
-    await Warn.edit(warn_id, ctx.author.id, await get_mod_level(ctx.author), reason)
-
-    try:
-        await user.send(embed=user_embed)
-    except (Forbidden, HTTPException):
-        server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-        server_embed.colour = Colors.error
-    await reply(ctx, embed=server_embed)
-    await send_to_changelog_mod(
-        guild=ctx.guild,
-        message=ctx.message,
-        colour=Colors.warn,
-        title=t.log_warn_edited,
-        member=user,
-        reason=reason,
-    )
-
-
-@commands.command(aliases=["warn_delete"])
-@ModPermission.warn.check
-@guild_only()
-@docs(t.commands.delete_warn)
-async def delete_warn(self, ctx: Context, warn_id: int):
-    warn = await get_and_compare_entry(Warn, warn_id, ctx.author)
-
-    conf_embed = Embed(
-        title=t.confirmation, description=t.confirm_warn_delete(warn.member_name, warn.id), color=Colors.ModTools
-    )
-
-    if not await confirm_action(ctx, conf_embed):
-        return
+        conf_embed = Embed(
+            title=t.confirmation, description=t.confirm_warn_edit(warn.reason, reason), color=Colors.ModTools
+        )
 
-    await Warn.delete(warn_id)
+        if not await confirm_action(ctx, conf_embed):
+            return
 
-    try:
-        user = await self.bot.fetch_user(warn.member)
-    except (NotFound, HTTPException):
-        raise CommandError(t.user_not_found)
+        try:
+            user = await self.bot.fetch_user(warn.member)
+        except (NotFound, HTTPException):
+            raise CommandError(t.user_not_found)
 
-    server_embed = Embed(title=t.warn, description=t.warn_deleted_response, colour=Colors.ModTools)
-    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+        user_embed = Embed(title=t.warn, description=t.warn_edited(warn.reason, reason), colour=Colors.ModTools)
+        server_embed = Embed(title=t.warn, description=t.warn_edited_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-    if await ModSettings.send_delete_user_message.get():
-        user_embed = Embed(title=t.warn, description=t.warn_deleted(warn.reason), colour=Colors.ModTools)
+        await Warn.edit(warn_id, ctx.author.id, await get_mod_level(ctx.author), reason)
 
         try:
             await user.send(embed=user_embed)
         except (Forbidden, HTTPException):
             server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
             server_embed.colour = Colors.error
+        await reply(ctx, embed=server_embed)
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.warn,
+            title=t.log_warn_edited,
+            member=user,
+            reason=reason,
+        )
+
+    @commands.command(aliases=["warn_delete"])
+    @ModPermission.warn.check
+    @guild_only()
+    @docs(t.commands.delete_warn)
+    async def delete_warn(self, ctx: Context, warn_id: int):
+        warn = await get_and_compare_entry(Warn, warn_id, ctx.author)
+
+        conf_embed = Embed(
+            title=t.confirmation, description=t.confirm_warn_delete(warn.member_name, warn.id), color=Colors.ModTools
+        )
 
-    await reply(ctx, embed=server_embed)
-    await send_to_changelog_mod(
-        guild=ctx.guild,
-        message=ctx.message,
-        colour=Colors.warn,
-        title=t.log_warn_deleted,
-        member=user,
-        reason=warn.reason,
-    )
+        if not await confirm_action(ctx, conf_embed):
+            return
 
+        await Warn.delete(warn_id)
 
-@commands.command()
-@ModPermission.mute.check
-@guild_only()
-@docs(t.commands.mute)
-async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConverter, *, reason: str):
-    user: Union[Member, User]
+        try:
+            user = await self.bot.fetch_user(warn.member)
+        except (NotFound, HTTPException):
+            raise CommandError(t.user_not_found)
 
-    time: Optional[int]
-    minutes = time
+        server_embed = Embed(title=t.warn, description=t.warn_deleted_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-    if len(reason) > 900:
-        raise CommandError(t.reason_too_long)
+        if await ModSettings.send_delete_user_message.get():
+            user_embed = Embed(title=t.warn, description=t.warn_deleted(warn.reason), colour=Colors.ModTools)
 
-    mute_role: Role = await get_mute_role(ctx.guild)
+            try:
+                await user.send(embed=user_embed)
+            except (Forbidden, HTTPException):
+                server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
+                server_embed.colour = Colors.error
+
+        await reply(ctx, embed=server_embed)
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.warn,
+            title=t.log_warn_deleted,
+            member=user,
+            reason=warn.reason,
+        )
 
-    if user == self.bot.user or await is_teamler(user):
-        raise UserCommandError(user, t.cannot_mute)
+    @commands.command()
+    @ModPermission.mute.check
+    @guild_only()
+    @docs(t.commands.mute)
+    async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConverter, *, reason: str):
+        user: Union[Member, User]
 
-    if isinstance(user, Member):
-        await user.add_roles(mute_role)
-        await user.move_to(None)
+        time: Optional[int]
+        minutes = time
 
-    if await db.exists(filter_by(Mute, active=True, member=user.id)):
-        raise UserCommandError(user, t.already_muted)
+        if len(reason) > 900:
+            raise CommandError(t.reason_too_long)
 
-    attachments = ctx.message.attachments
-    evidence = attachments[0] if attachments else None
-    evidence_url = evidence.url if attachments else None
+        mute_role: Role = await get_mute_role(ctx.guild)
 
-    if not evidence:
-        if not await confirm_no_evidence(ctx):
-            return
+        if user == self.bot.user or await is_teamler(user):
+            raise UserCommandError(user, t.cannot_mute)
 
-    user_embed = Embed(title=t.mute, colour=Colors.ModTools)
-    server_embed = Embed(title=t.mute, description=t.muted_response, colour=Colors.ModTools)
-    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-
-    await Mute.create(
-        user.id,
-        str(user),
-        ctx.author.id,
-        await get_mod_level(ctx.author),
-        minutes if minutes is not None else -1,
-        reason,
-        evidence_url,
-    )
-
-    await invalidate_entry_cache()
-
-    await send_to_changelog_mod(
-        guild=ctx.guild,
-        message=ctx.message,
-        colour=Colors.mute,
-        title=t.log_muted,
-        member=user,
-        reason=reason,
-        duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
-        evidence=evidence,
-    )
-
-    if minutes is not None:
-        user_embed.description = t.muted(ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason)
-    else:
-        user_embed.description = t.muted_inf(ctx.author.mention, ctx.guild.name, reason)
+        if isinstance(user, Member):
+            await user.add_roles(mute_role)
+            await user.move_to(None)
 
-    try:
-        await user.send(embed=user_embed)
-    except (Forbidden, HTTPException):
-        server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-        server_embed.colour = Colors.error
+        if await db.exists(filter_by(Mute, active=True, member=user.id)):
+            raise UserCommandError(user, t.already_muted)
 
-    await reply(ctx, embed=server_embed)
+        attachments = ctx.message.attachments
+        evidence = attachments[0] if attachments else None
+        evidence_url = evidence.url if attachments else None
 
+        if not evidence:
+            if not await confirm_no_evidence(ctx):
+                return
 
-@commands.group(aliases=["mute_edit"])
-@ModPermission.mute.check
-@guild_only()
-@docs(t.commands.edit_mute)
-async def edit_mute(self, ctx):
-    if ctx.invoked_subcommand is None:
-        raise UserInputError
+        user_embed = Embed(title=t.mute, colour=Colors.ModTools)
+        server_embed = Embed(title=t.mute, description=t.muted_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+
+        await Mute.create(
+            user.id,
+            str(user),
+            ctx.author.id,
+            await get_mod_level(ctx.author),
+            minutes if minutes is not None else -1,
+            reason,
+            evidence_url,
+        )
 
+        await invalidate_entry_cache()
+
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.mute,
+            title=t.log_muted,
+            member=user,
+            reason=reason,
+            duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
+            evidence=evidence,
+        )
 
-@edit_mute.command(name="reason", aliases=["r"])
-@docs(t.commands.edit_mute_reason)
-async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
-    mute = await get_and_compare_entry(Mute, mute_id, ctx.author)
+        if minutes is not None:
+            user_embed.description = t.muted(ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason)
+        else:
+            user_embed.description = t.muted_inf(ctx.author.mention, ctx.guild.name, reason)
 
-    if len(reason) > 900:
-        raise CommandError(t.reason_too_long)
+        try:
+            await user.send(embed=user_embed)
+        except (Forbidden, HTTPException):
+            server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
+            server_embed.colour = Colors.error
 
-    conf_embed = Embed(
-        title=t.confirmation, description=t.confirm_mute_edit.reason(mute.reason, reason), color=Colors.ModTools
-    )
+        await reply(ctx, embed=server_embed)
 
-    if not await confirm_action(ctx, conf_embed):
-        return
+    @commands.group(aliases=["mute_edit"])
+    @ModPermission.mute.check
+    @guild_only()
+    @docs(t.commands.edit_mute)
+    async def edit_mute(self, ctx):
+        if ctx.invoked_subcommand is None:
+            raise UserInputError
 
-    try:
-        user = await self.bot.fetch_user(mute.member)
-    except (NotFound, HTTPException):
-        raise CommandError(t.user_not_found)
-
-    user_embed = Embed(title=t.mute, description=t.mute_edited.reason(mute.reason, reason), colour=Colors.ModTools)
-    server_embed = Embed(title=t.mute, description=t.mute_edited_response, colour=Colors.ModTools)
-    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-
-    await Mute.edit_reason(mute_id, ctx.author.id, await get_mod_level(ctx.author), reason)
-
-    try:
-        await user.send(embed=user_embed)
-    except (Forbidden, HTTPException):
-        server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-        server_embed.colour = Colors.error
-    await reply(ctx, embed=server_embed)
-    await send_to_changelog_mod(
-        guild=ctx.guild,
-        message=ctx.message,
-        colour=Colors.mute,
-        title=t.log_mute_edited,
-        member=user,
-        reason=reason,
-    )
-
-
-@edit_mute.command(name="duration", aliases=["d"])
-@docs(t.commands.edit_mute_duration)
-async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time: DurationConverter):
-    user: Union[Member, User]
-    time: Optional[int]
-    minutes = time
-
-    active_mutes: List[Mute] = sorted(
-        await db.all(filter_by(Mute, active=True, member=user.id)), key=lambda active_mute: active_mute.timestamp
-    )
-
-    if not active_mutes:
-        raise CommandError(t.not_muted)
-
-    mute = active_mutes[0]
-
-    if not await compare_mod_level(ctx.author, mute.mod_level) or not ctx.author.id == mute.mod:
-        raise CommandError(tg.permission_denied)
+    @edit_mute.command(name="reason", aliases=["r"])
+    @docs(t.commands.edit_mute_reason)
+    async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
+        mute = await get_and_compare_entry(Mute, mute_id, ctx.author)
 
-    if mute.minutes == minutes or (mute.minutes == -1 and minutes is None):
-        raise CommandError(t.already_muted)
+        if len(reason) > 900:
+            raise CommandError(t.reason_too_long)
 
-    conf_embed = Embed(title=t.confirmation, color=Colors.ModTools)
+        conf_embed = Embed(
+            title=t.confirmation, description=t.confirm_mute_edit.reason(mute.reason, reason), color=Colors.ModTools
+        )
 
-    old_time = t.infinity if mute.minutes == -1 else time_to_units(mute.minutes)
+        if not await confirm_action(ctx, conf_embed):
+            return
 
-    if minutes is None:
-        conf_embed.description = t.confirm_mute_edit.duration(old_time, t.infinity)
-    else:
-        conf_embed.description = t.confirm_mute_edit.duration(old_time, time_to_units(minutes))
+        try:
+            user = await self.bot.fetch_user(mute.member)
+        except (NotFound, HTTPException):
+            raise CommandError(t.user_not_found)
 
-    if not await confirm_action(ctx, conf_embed):
-        return
+        user_embed = Embed(title=t.mute, description=t.mute_edited.reason(mute.reason, reason), colour=Colors.ModTools)
+        server_embed = Embed(title=t.mute, description=t.mute_edited_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-    for active_mute in active_mutes[1:]:
-        await Mute.delete(active_mute.id)
-
-    user_embed = Embed(title=t.mute, colour=Colors.ModTools)
-    server_embed = Embed(title=t.mute, description=t.mute_edited_response, colour=Colors.ModTools)
-    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-
-    await Mute.edit_duration(mute.id, ctx.author.id, await get_mod_level(ctx.author), minutes)
-
-    await invalidate_entry_cache()
-
-    user_embed.description = t.mute_edited.duration(
-        time_to_units(mute.minutes), t.infinity if minutes is None else time_to_units(minutes)
-    )
-    await send_to_changelog_mod(
-        guild=ctx.guild,
-        message=ctx.message,
-        colour=Colors.mute,
-        title=t.log_mute_edited,
-        member=user,
-        reason=Mute.reason,
-        duration=t.log_field.infinity if minutes is None else time_to_units(minutes),
-    )
-
-    try:
-        await user.send(embed=user_embed)
-    except (Forbidden, HTTPException):
-        server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-        server_embed.colour = Colors.error
-    await reply(ctx, embed=server_embed)
-
-
-@commands.command(aliases=["mute_delete"])
-@ModPermission.mute.check
-@guild_only()
-@docs(t.commands.delete_mute)
-async def delete_mute(self, ctx: Context, mute_id: int):
-    mute = await get_and_compare_entry(Mute, mute_id, ctx.author)
-
-    conf_embed = Embed(
-        title=t.confirmation, description=t.confirm_mute_delete(mute.member_name, mute.id), color=Colors.ModTools
-    )
-
-    if not await confirm_action(ctx, conf_embed):
-        return
+        await Mute.edit_reason(mute_id, ctx.author.id, await get_mod_level(ctx.author), reason)
 
-    active_mutes: List[Mute] = await db.all(filter_by(Mute, active=True, member=mute.member))
+        try:
+            await user.send(embed=user_embed)
+        except (Forbidden, HTTPException):
+            server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
+            server_embed.colour = Colors.error
+        await reply(ctx, embed=server_embed)
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.mute,
+            title=t.log_mute_edited,
+            member=user,
+            reason=reason,
+        )
+
+    @edit_mute.command(name="duration", aliases=["d"])
+    @docs(t.commands.edit_mute_duration)
+    async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time: DurationConverter):
+        user: Union[Member, User]
+        time: Optional[int]
+        minutes = time
 
-    if len(active_mutes) == 1 and mute in active_mutes:
-        user = ctx.guild.get_member(mute.member)
-        if user is not None:
-            if (mute_role := await get_mute_role(ctx.guild)) in user.roles:
-                await user.remove_roles(mute_role)
+        active_mutes: List[Mute] = sorted(
+            await db.all(filter_by(Mute, active=True, member=user.id)), key=lambda active_mute: active_mute.timestamp
+        )
 
-    try:
-        user = await self.bot.fetch_user(mute.member)
-    except (NotFound, HTTPException):
-        raise CommandError(t.user_not_found)
+        if not active_mutes:
+            raise CommandError(t.not_muted)
 
-    await Mute.delete(mute_id)
+        mute = active_mutes[0]
+
+        if not await compare_mod_level(ctx.author, mute.mod_level) or not ctx.author.id == mute.mod:
+            raise CommandError(tg.permission_denied)
 
-    await invalidate_entry_cache()
+        if mute.minutes == minutes or (mute.minutes == -1 and minutes is None):
+            raise CommandError(t.already_muted)
 
-    server_embed = Embed(title=t.mute, description=t.mute_deleted_response, colour=Colors.ModTools)
-    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+        conf_embed = Embed(title=t.confirmation, color=Colors.ModTools)
 
-    if await ModSettings.send_delete_user_message.get():
-        user_embed = Embed(title=t.warn, colour=Colors.ModTools)
+        old_time = t.infinity if mute.minutes == -1 else time_to_units(mute.minutes)
 
-        if mute.minutes == -1:
-            user_embed.description = t.mute_deleted.inf(mute.reason)
+        if minutes is None:
+            conf_embed.description = t.confirm_mute_edit.duration(old_time, t.infinity)
         else:
-            user_embed.description = t.mute_deleted.not_inf(time_to_units(mute.minutes), mute.reason)
+            conf_embed.description = t.confirm_mute_edit.duration(old_time, time_to_units(minutes))
+
+        if not await confirm_action(ctx, conf_embed):
+            return
+
+        for active_mute in active_mutes[1:]:
+            await Mute.delete(active_mute.id)
+
+        user_embed = Embed(title=t.mute, colour=Colors.ModTools)
+        server_embed = Embed(title=t.mute, description=t.mute_edited_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+
+        await Mute.edit_duration(mute.id, ctx.author.id, await get_mod_level(ctx.author), minutes)
+
+        await invalidate_entry_cache()
+
+        user_embed.description = t.mute_edited.duration(
+            time_to_units(mute.minutes), t.infinity if minutes is None else time_to_units(minutes)
+        )
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.mute,
+            title=t.log_mute_edited,
+            member=user,
+            reason=Mute.reason,
+            duration=t.log_field.infinity if minutes is None else time_to_units(minutes),
+        )
 
         try:
             await user.send(embed=user_embed)
         except (Forbidden, HTTPException):
             server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
             server_embed.colour = Colors.error
+        await reply(ctx, embed=server_embed)
+
+    @commands.command(aliases=["mute_delete"])
+    @ModPermission.mute.check
+    @guild_only()
+    @docs(t.commands.delete_mute)
+    async def delete_mute(self, ctx: Context, mute_id: int):
+        mute = await get_and_compare_entry(Mute, mute_id, ctx.author)
 
-    await reply(ctx, embed=server_embed)
+        conf_embed = Embed(
+            title=t.confirmation, description=t.confirm_mute_delete(mute.member_name, mute.id), color=Colors.ModTools
+        )
+
+        if not await confirm_action(ctx, conf_embed):
+            return
 
-    await send_to_changelog_mod(
-        guild=ctx.guild,
-        message=ctx.message,
-        colour=Colors.mute,
-        title=t.log_mute_deleted,
-        member=user,
-        reason=mute.reason,
-        duration=t.log_field_infinity if mute.minutes == -1 else time_to_units(mute.minutes),
-    )
+        active_mutes: List[Mute] = await db.all(filter_by(Mute, active=True, member=mute.member))
 
+        if len(active_mutes) == 1 and mute in active_mutes:
+            user = ctx.guild.get_member(mute.member)
+            if user is not None:
+                if (mute_role := await get_mute_role(ctx.guild)) in user.roles:
+                    await user.remove_roles(mute_role)
 
-@commands.command()
-@ModPermission.mute.check
-@guild_only()
-@docs(t.commands.unmute)
-async def unmute(self, ctx: Context, user: UserMemberConverter, *, reason: str):
-    user: Union[Member, User]
+        try:
+            user = await self.bot.fetch_user(mute.member)
+        except (NotFound, HTTPException):
+            raise CommandError(t.user_not_found)
 
-    if len(reason) > 900:
-        raise CommandError(t.reason_too_long)
+        await Mute.delete(mute_id)
 
-    mute_role: Role = await get_mute_role(ctx.guild)
+        await invalidate_entry_cache()
 
-    was_muted = False
-    if isinstance(user, Member) and mute_role in user.roles:
-        was_muted = True
-        await user.remove_roles(mute_role)
+        server_embed = Embed(title=t.mute, description=t.mute_deleted_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-    minutes = 0
-    async for mute in await db.stream(filter_by(Mute, active=True, member=user.id)):
-        if not await compare_mod_level(ctx.author, mute.mod_level) or not ctx.author.id == mute.mod:
-            raise CommandError(tg.permission_denied)
+        if await ModSettings.send_delete_user_message.get():
+            user_embed = Embed(title=t.warn, colour=Colors.ModTools)
+
+            if mute.minutes == -1:
+                user_embed.description = t.mute_deleted.inf(mute.reason)
+            else:
+                user_embed.description = t.mute_deleted.not_inf(time_to_units(mute.minutes), mute.reason)
+
+            try:
+                await user.send(embed=user_embed)
+            except (Forbidden, HTTPException):
+                server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
+                server_embed.colour = Colors.error
+
+        await reply(ctx, embed=server_embed)
+
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.mute,
+            title=t.log_mute_deleted,
+            member=user,
+            reason=mute.reason,
+            duration=t.log_field_infinity if mute.minutes == -1 else time_to_units(mute.minutes),
+        )
 
-        await Mute.deactivate(mute.id, ctx.author.id, reason)
+    @commands.command()
+    @ModPermission.mute.check
+    @guild_only()
+    @docs(t.commands.unmute)
+    async def unmute(self, ctx: Context, user: UserMemberConverter, *, reason: str):
+        user: Union[Member, User]
+
+        if len(reason) > 900:
+            raise CommandError(t.reason_too_long)
+
+        mute_role: Role = await get_mute_role(ctx.guild)
+
+        was_muted = False
+        if isinstance(user, Member) and mute_role in user.roles:
+            was_muted = True
+            await user.remove_roles(mute_role)
+
+        minutes = 0
+        async for mute in await db.stream(filter_by(Mute, active=True, member=user.id)):
+            if not await compare_mod_level(ctx.author, mute.mod_level) or not ctx.author.id == mute.mod:
+                raise CommandError(tg.permission_denied)
+
+            await Mute.deactivate(mute.id, ctx.author.id, reason)
+
+            was_muted = True
+
+            if mute.minutes > minutes or mute.minutes == -1:
+                minutes = mute.minutes
+
+        if not was_muted:
+            raise UserCommandError(user, t.not_muted)
+
+        await invalidate_entry_cache()
+
+        server_embed = Embed(title=t.unmute, description=t.unmuted_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+        await reply(ctx, embed=server_embed)
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.unmute,
+            title=t.log_unmuted,
+            member=user,
+            reason=reason,
+            duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
+            mod=ctx.author,
+            original_reason=mute.reason,
+        )
 
-        was_muted = True
+    @commands.command()
+    @ModPermission.kick.check
+    @guild_only()
+    @docs(t.commands.kick)
+    async def kick(self, ctx: Context, member: Member, *, reason: str):
+        if len(reason) > 900:
+            raise CommandError(t.reason_too_long)
 
-        if mute.minutes > minutes or mute.minutes == -1:
-            minutes = mute.minutes
+        if member == self.bot.user or await is_teamler(member):
+            raise UserCommandError(member, t.cannot_kick)
 
-    if not was_muted:
-        raise UserCommandError(user, t.not_muted)
+        if not ctx.guild.me.guild_permissions.kick_members:
+            raise CommandError(t.cannot_kick_permissions)
 
-    await invalidate_entry_cache()
+        if member.top_role >= ctx.guild.me.top_role or member.id == ctx.guild.owner_id:
+            raise UserCommandError(member, t.cannot_kick)
 
-    server_embed = Embed(title=t.unmute, description=t.unmuted_response, colour=Colors.ModTools)
-    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-    await reply(ctx, embed=server_embed)
-    await send_to_changelog_mod(
-        guild=ctx.guild,
-        message=ctx.message,
-        colour=Colors.unmute,
-        title=t.log_unmuted,
-        member=user,
-        reason=reason,
-        duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
-        mod=ctx.author,
-        original_reason=mute.reason,
-    )
+        attachments = ctx.message.attachments
+        evidence = attachments[0] if attachments else None
+        evidence_url = evidence.url if attachments else None
 
+        if not evidence:
+            if not await confirm_no_evidence(ctx):
+                return
 
-@commands.command()
-@ModPermission.kick.check
-@guild_only()
-@docs(t.commands.kick)
-async def kick(self, ctx: Context, member: Member, *, reason: str):
-    if len(reason) > 900:
-        raise CommandError(t.reason_too_long)
+        await Kick.create(member.id, str(member), ctx.author.id, await get_mod_level(ctx.author), reason, evidence_url)
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.kick,
+            title=t.log_kicked,
+            member=member,
+            reason=reason,
+            evidence=evidence,
+        )
 
-    if member == self.bot.user or await is_teamler(member):
-        raise UserCommandError(member, t.cannot_kick)
+        user_embed = Embed(
+            title=t.kick,
+            colour=Colors.ModTools,
+            description=t.kicked(ctx.author.mention, ctx.guild.name, reason),
+        )
 
-    if not ctx.guild.me.guild_permissions.kick_members:
-        raise CommandError(t.cannot_kick_permissions)
+        server_embed = Embed(title=t.kick, description=t.kicked_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(member), icon_url=member.display_avatar.url)
 
-    if member.top_role >= ctx.guild.me.top_role or member.id == ctx.guild.owner_id:
-        raise UserCommandError(member, t.cannot_kick)
+        try:
+            await member.send(embed=user_embed)
+        except (Forbidden, HTTPException):
+            server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
+            server_embed.colour = Colors.error
 
-    attachments = ctx.message.attachments
-    evidence = attachments[0] if attachments else None
-    evidence_url = evidence.url if attachments else None
+        await member.kick(reason=reason)
+        await revoke_verification(member)
 
-    if not evidence:
-        if not await confirm_no_evidence(ctx):
-            return
+        await reply(ctx, embed=server_embed)
 
-    await Kick.create(member.id, str(member), ctx.author.id, await get_mod_level(ctx.author), reason, evidence_url)
-    await send_to_changelog_mod(
-        guild=ctx.guild,
-        message=ctx.message,
-        colour=Colors.kick,
-        title=t.log_kicked,
-        member=member,
-        reason=reason,
-        evidence=evidence,
-    )
-
-    user_embed = Embed(
-        title=t.kick,
-        colour=Colors.ModTools,
-        description=t.kicked(ctx.author.mention, ctx.guild.name, reason),
-    )
-
-    server_embed = Embed(title=t.kick, description=t.kicked_response, colour=Colors.ModTools)
-    server_embed.set_author(name=str(member), icon_url=member.display_avatar.url)
-
-    try:
-        await member.send(embed=user_embed)
-    except (Forbidden, HTTPException):
-        server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-        server_embed.colour = Colors.error
-
-    await member.kick(reason=reason)
-    await revoke_verification(member)
-
-    await reply(ctx, embed=server_embed)
-
-
-@commands.command(aliases=["kick_edit"])
-@ModPermission.kick.check
-@guild_only()
-@docs(t.commands.edit_kick)
-async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
-    kick = await get_and_compare_entry(Kick, kick_id, ctx.author)
-
-    if len(reason) > 900:
-        raise CommandError(t.reason_too_long)
-
-    conf_embed = Embed(
-        title=t.confirmation, description=t.confirm_kick_edit(kick.reason, reason), color=Colors.ModTools
-    )
-
-    if not await confirm_action(ctx, conf_embed):
-        return
+    @commands.command(aliases=["kick_edit"])
+    @ModPermission.kick.check
+    @guild_only()
+    @docs(t.commands.edit_kick)
+    async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
+        kick = await get_and_compare_entry(Kick, kick_id, ctx.author)
 
-    try:
-        user = await self.bot.fetch_user(kick.member)
-    except (NotFound, HTTPException):
-        raise CommandError(t.user_not_found)
-
-    user_embed = Embed(title=t.kick, description=t.kick_edited(kick.reason, reason), colour=Colors.ModTools)
-    server_embed = Embed(title=t.kick, description=t.kick_edited_reponse, colour=Colors.ModTools)
-    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-
-    await Kick.edit(kick_id, ctx.author.id, await get_mod_level(ctx.author), reason)
-
-    try:
-        await user.send(embed=user_embed)
-    except (Forbidden, HTTPException):
-        server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-        server_embed.colour = Colors.error
-    await reply(ctx, embed=server_embed)
-    await send_to_changelog_mod(
-        guild=ctx.guild,
-        message=ctx.message,
-        colour=Colors.kick,
-        title=t.log_kick_edited,
-        member=user,
-        reason=reason,
-    )
-
-
-@commands.command(aliases=["kick_delete"])
-@ModPermission.kick.check
-@guild_only()
-@docs(t.commands.delete_kick)
-async def delete_kick(self, ctx: Context, kick_id: int):
-    kick = await get_and_compare_entry(Kick, kick_id, ctx.author)
-
-    conf_embed = Embed(
-        title=t.confirmation, description=t.confirm_kick_delete(kick.member_name, kick.id), color=Colors.ModTools
-    )
-
-    if not await confirm_action(ctx, conf_embed):
-        return
+        if len(reason) > 900:
+            raise CommandError(t.reason_too_long)
 
-    await Kick.delete(kick_id)
+        conf_embed = Embed(
+            title=t.confirmation, description=t.confirm_kick_edit(kick.reason, reason), color=Colors.ModTools
+        )
+
+        if not await confirm_action(ctx, conf_embed):
+            return
 
-    try:
-        user = await self.bot.fetch_user(kick.member)
-    except (NotFound, HTTPException):
-        raise CommandError(t.user_not_found)
+        try:
+            user = await self.bot.fetch_user(kick.member)
+        except (NotFound, HTTPException):
+            raise CommandError(t.user_not_found)
 
-    server_embed = Embed(title=t.warn, description=t.kick_deleted_response, colour=Colors.ModTools)
-    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+        user_embed = Embed(title=t.kick, description=t.kick_edited(kick.reason, reason), colour=Colors.ModTools)
+        server_embed = Embed(title=t.kick, description=t.kick_edited_reponse, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-    if await ModSettings.send_delete_user_message.get():
-        user_embed = Embed(title=t.kick, description=t.kick_deleted(kick.reason), colour=Colors.ModTools)
+        await Kick.edit(kick_id, ctx.author.id, await get_mod_level(ctx.author), reason)
 
         try:
             await user.send(embed=user_embed)
         except (Forbidden, HTTPException):
             server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
             server_embed.colour = Colors.error
+        await reply(ctx, embed=server_embed)
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.kick,
+            title=t.log_kick_edited,
+            member=user,
+            reason=reason,
+        )
 
-    await reply(ctx, embed=server_embed)
-    await send_to_changelog_mod(
-        guild=ctx.guild,
-        message=ctx.message,
-        colour=Colors.kick,
-        title=t.log_kick_deleted,
-        member=user,
-        reason=kick.reason,
-    )
-
-
-@commands.command()
-@ModPermission.ban.check
-@guild_only()
-@docs(t.commands.ban)
-async def ban(self, ctx: Context, user: UserMemberConverter, time: DurationConverter, delete_days: int, *, reason: str):
-    time: Optional[int]
-    minutes = time
-
-    user: Union[Member, User]
-
-    if not ctx.guild.me.guild_permissions.ban_members:
-        raise CommandError(t.cannot_ban_permissions)
-
-    if len(reason) > 900:
-        raise CommandError(t.reason_too_long)
-    if not 0 <= delete_days <= 7:
-        raise CommandError(tg.invalid_duration)
-
-    if user == self.bot.user or await is_teamler(user):
-        raise UserCommandError(user, t.cannot_ban)
-    if isinstance(user, Member) and (user.top_role >= ctx.guild.me.top_role or user.id == ctx.guild.owner_id):
-        raise UserCommandError(user, t.cannot_ban)
-
-    active_bans: List[Ban] = await db.all(filter_by(Ban, active=True, member=user.id))
-    if active_bans:
-        raise UserCommandError(user, t.already_banned)
-
-    active_mutes: List[Mute] = await db.all(filter_by(Mute, active=True, member=user.id))
-    for mute in active_mutes:
-        await Mute.deactivate(mute.id, ctx.author.id, t.cancelled_by_ban)
-
-    attachments = ctx.message.attachments
-    evidence = attachments[0] if attachments else None
-    evidence_url = evidence.url if attachments else None
-
-    if not evidence:
-        if not await confirm_no_evidence(ctx):
-            return
+    @commands.command(aliases=["kick_delete"])
+    @ModPermission.kick.check
+    @guild_only()
+    @docs(t.commands.delete_kick)
+    async def delete_kick(self, ctx: Context, kick_id: int):
+        kick = await get_and_compare_entry(Kick, kick_id, ctx.author)
 
-    user_embed = Embed(title=t.ban, colour=Colors.ModTools)
-    server_embed = Embed(title=t.ban, description=t.banned_response, colour=Colors.ModTools)
-    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-
-    if active_mutes:
-        server_embed.description += f"\n\n{t.previously_muted}"
-
-    await Ban.create(
-        user.id,
-        str(user),
-        ctx.author.id,
-        await get_mod_level(ctx.author),
-        minutes if minutes is not None else -1,
-        reason,
-        evidence_url,
-    )
-
-    await invalidate_entry_cache()
-
-    await send_to_changelog_mod(
-        guild=ctx.guild,
-        message=ctx.message,
-        colour=Colors.ban,
-        title=t.log_banned,
-        member=user,
-        reason=reason,
-        duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
-        evidence=evidence,
-    )
-
-    if minutes is not None:
-        user_embed.description = t.banned(ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason)
+        conf_embed = Embed(
+            title=t.confirmation, description=t.confirm_kick_delete(kick.member_name, kick.id), color=Colors.ModTools
+        )
 
-    else:
-        user_embed.description = t.banned_inf(ctx.author.mention, ctx.guild.name, reason)
+        if not await confirm_action(ctx, conf_embed):
+            return
 
-    try:
-        await user.send(embed=user_embed)
-    except (Forbidden, HTTPException):
-        server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-        server_embed.colour = Colors.error
+        await Kick.delete(kick_id)
 
-    await ctx.guild.ban(user, delete_message_days=delete_days, reason=reason)
-    await revoke_verification(user)
+        try:
+            user = await self.bot.fetch_user(kick.member)
+        except (NotFound, HTTPException):
+            raise CommandError(t.user_not_found)
 
-    await reply(ctx, embed=server_embed)
+        server_embed = Embed(title=t.warn, description=t.kick_deleted_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
+        if await ModSettings.send_delete_user_message.get():
+            user_embed = Embed(title=t.kick, description=t.kick_deleted(kick.reason), colour=Colors.ModTools)
 
-@commands.group(aliases=["ban_edit"])
-@ModPermission.mute.check
-@guild_only()
-@docs(t.commands.edit_ban)
-async def edit_ban(self, ctx):
-    if ctx.invoked_subcommand is None:
-        raise UserInputError
+            try:
+                await user.send(embed=user_embed)
+            except (Forbidden, HTTPException):
+                server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
+                server_embed.colour = Colors.error
+
+        await reply(ctx, embed=server_embed)
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.kick,
+            title=t.log_kick_deleted,
+            member=user,
+            reason=kick.reason,
+        )
 
+    @commands.command()
+    @ModPermission.ban.check
+    @guild_only()
+    @docs(t.commands.ban)
+    async def ban(
+        self, ctx: Context, user: UserMemberConverter, time: DurationConverter, delete_days: int, *, reason: str
+    ):
+        time: Optional[int]
+        minutes = time
+
+        user: Union[Member, User]
+
+        if not ctx.guild.me.guild_permissions.ban_members:
+            raise CommandError(t.cannot_ban_permissions)
+
+        if len(reason) > 900:
+            raise CommandError(t.reason_too_long)
+        if not 0 <= delete_days <= 7:
+            raise CommandError(tg.invalid_duration)
+
+        if user == self.bot.user or await is_teamler(user):
+            raise UserCommandError(user, t.cannot_ban)
+        if isinstance(user, Member) and (user.top_role >= ctx.guild.me.top_role or user.id == ctx.guild.owner_id):
+            raise UserCommandError(user, t.cannot_ban)
+
+        active_bans: List[Ban] = await db.all(filter_by(Ban, active=True, member=user.id))
+        if active_bans:
+            raise UserCommandError(user, t.already_banned)
+
+        active_mutes: List[Mute] = await db.all(filter_by(Mute, active=True, member=user.id))
+        for mute in active_mutes:
+            await Mute.deactivate(mute.id, ctx.author.id, t.cancelled_by_ban)
+
+        attachments = ctx.message.attachments
+        evidence = attachments[0] if attachments else None
+        evidence_url = evidence.url if attachments else None
+
+        if not evidence:
+            if not await confirm_no_evidence(ctx):
+                return
 
-@edit_ban.command(name="reason", aliases=["r"])
-@docs(t.commands.edit_ban_reason)
-async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
-    ban = await get_and_compare_entry(Ban, ban_id, ctx.author)
+        user_embed = Embed(title=t.ban, colour=Colors.ModTools)
+        server_embed = Embed(title=t.ban, description=t.banned_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+
+        if active_mutes:
+            server_embed.description += f"\n\n{t.previously_muted}"
+
+        await Ban.create(
+            user.id,
+            str(user),
+            ctx.author.id,
+            await get_mod_level(ctx.author),
+            minutes if minutes is not None else -1,
+            reason,
+            evidence_url,
+        )
 
-    if len(reason) > 900:
-        raise CommandError(t.reason_too_long)
+        await invalidate_entry_cache()
+
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.ban,
+            title=t.log_banned,
+            member=user,
+            reason=reason,
+            duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
+            evidence=evidence,
+        )
 
-    conf_embed = Embed(
-        title=t.confirmation, description=t.confirm_ban_edit.reason(ban.reason, reason), color=Colors.ModTools
-    )
+        if minutes is not None:
+            user_embed.description = t.banned(ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason)
 
-    if not await confirm_action(ctx, conf_embed):
-        return
+        else:
+            user_embed.description = t.banned_inf(ctx.author.mention, ctx.guild.name, reason)
 
-    try:
-        user = await self.bot.fetch_user(ban.member)
-    except (NotFound, HTTPException):
-        raise CommandError(t.user_not_found)
+        try:
+            await user.send(embed=user_embed)
+        except (Forbidden, HTTPException):
+            server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
+            server_embed.colour = Colors.error
 
-    user_embed = Embed(title=t.ban, description=t.ban_edited.reason(ban.reason, reason), colour=Colors.ModTools)
-    server_embed = Embed(title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools)
-    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+        await ctx.guild.ban(user, delete_message_days=delete_days, reason=reason)
+        await revoke_verification(user)
 
-    await Ban.edit_reason(ban_id, ctx.author.id, await get_mod_level(ctx.author), reason)
+        await reply(ctx, embed=server_embed)
 
-    try:
-        await user.send(embed=user_embed)
-    except (Forbidden, HTTPException):
-        server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-        server_embed.colour = Colors.error
-    await reply(ctx, embed=server_embed)
-    await send_to_changelog_mod(
-        guild=ctx.guild, message=ctx.message, colour=Colors.ban, title=t.log_ban_edited, member=user, reason=reason
-    )
+    @commands.group(aliases=["ban_edit"])
+    @ModPermission.mute.check
+    @guild_only()
+    @docs(t.commands.edit_ban)
+    async def edit_ban(self, ctx):
+        if ctx.invoked_subcommand is None:
+            raise UserInputError
 
+    @edit_ban.command(name="reason", aliases=["r"])
+    @docs(t.commands.edit_ban_reason)
+    async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
+        ban = await get_and_compare_entry(Ban, ban_id, ctx.author)
 
-@edit_ban.command(name="duration", aliases=["d"])
-@docs(t.commands.edit_ban_duration)
-async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time: DurationConverter):
-    user: Union[Member, User]
-    time: Optional[int]
-    minutes = time
+        if len(reason) > 900:
+            raise CommandError(t.reason_too_long)
 
-    active_bans: List[Ban] = sorted(
-        await db.all(filter_by(Ban, active=True, member=user.id)), key=lambda active_ban: active_ban.timestamp
-    )
+        conf_embed = Embed(
+            title=t.confirmation, description=t.confirm_ban_edit.reason(ban.reason, reason), color=Colors.ModTools
+        )
 
-    if not active_bans:
-        raise CommandError(t.not_banned)
+        if not await confirm_action(ctx, conf_embed):
+            return
 
-    ban = active_bans[0]
+        try:
+            user = await self.bot.fetch_user(ban.member)
+        except (NotFound, HTTPException):
+            raise CommandError(t.user_not_found)
 
-    if not await compare_mod_level(ctx.author, ban.mod_level) or not ctx.author.id == ban.mod:
-        raise CommandError(tg.permission_denied)
+        user_embed = Embed(title=t.ban, description=t.ban_edited.reason(ban.reason, reason), colour=Colors.ModTools)
+        server_embed = Embed(title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-    if ban.minutes == minutes or (ban.minutes == -1 and minutes is None):
-        raise CommandError(t.already_banned)
+        await Ban.edit_reason(ban_id, ctx.author.id, await get_mod_level(ctx.author), reason)
 
-    conf_embed = Embed(title=t.confirmation, color=Colors.ModTools)
+        try:
+            await user.send(embed=user_embed)
+        except (Forbidden, HTTPException):
+            server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
+            server_embed.colour = Colors.error
+        await reply(ctx, embed=server_embed)
+        await send_to_changelog_mod(
+            guild=ctx.guild, message=ctx.message, colour=Colors.ban, title=t.log_ban_edited, member=user, reason=reason
+        )
 
-    old_time = t.infinity if ban.minutes == -1 else time_to_units(ban.minutes)
+    @edit_ban.command(name="duration", aliases=["d"])
+    @docs(t.commands.edit_ban_duration)
+    async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time: DurationConverter):
+        user: Union[Member, User]
+        time: Optional[int]
+        minutes = time
 
-    if minutes is None:
-        conf_embed.description = t.confirm_ban_edit.duration(old_time, t.infinity)
-    else:
-        conf_embed.description = t.confirm_ban_edit.duration(old_time, time_to_units(minutes))
+        active_bans: List[Ban] = sorted(
+            await db.all(filter_by(Ban, active=True, member=user.id)), key=lambda active_ban: active_ban.timestamp
+        )
 
-    if not await confirm_action(ctx, conf_embed):
-        return
+        if not active_bans:
+            raise CommandError(t.not_banned)
 
-    for ban in active_bans[1:]:
-        await Ban.delete(ban.id)
-
-    user_embed = Embed(title=t.ban, colour=Colors.ModTools)
-    server_embed = Embed(title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools)
-    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-
-    await Ban.edit_duration(ban.id, ctx.author.id, await get_mod_level(ctx.author), minutes)
-
-    await invalidate_entry_cache()
-
-    user_embed.description = t.ban_edited.duration(
-        time_to_units(ban.minutes), t.infinity if minutes is None else time_to_units(minutes)
-    )
-    await send_to_changelog_mod(
-        guild=ctx.guild,
-        message=ctx.message,
-        colour=Colors.ban,
-        title=t.log_ban_edited,
-        member=user,
-        reason=ban.reason,
-        duration=t.log_field.infinity if minutes is None else time_to_units(minutes),
-    )
-
-    try:
-        await user.send(embed=user_embed)
-    except (Forbidden, HTTPException):
-        server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-        server_embed.colour = Colors.error
-    await reply(ctx, embed=server_embed)
-
-
-@commands.command(aliases=["ban_delete"])
-@ModPermission.ban.check
-@guild_only()
-@docs(t.commands.delete_ban)
-async def delete_ban(self, ctx: Context, ban_id: int):
-    ban = await get_and_compare_entry(Ban, ban_id, ctx.author)
-
-    conf_embed = Embed(
-        title=t.confirmation, description=t.confirm_ban_delete(ban.member_name, ban.id), color=Colors.ModTools
-    )
-
-    if not await confirm_action(ctx, conf_embed):
-        return
+        ban = active_bans[0]
 
-    active_bans: List[Ban] = await db.all(filter_by(Ban, active=True, member=ban.member))
+        if not await compare_mod_level(ctx.author, ban.mod_level) or not ctx.author.id == ban.mod:
+            raise CommandError(tg.permission_denied)
 
-    if len(active_bans) == 1 and ban in active_bans:
-        user = ctx.guild.get_member(ban.member)
-        if user is not None:
-            try:
-                await ctx.guild.unban(user, reason="Ban deleted")
-            except HTTPException:
-                pass
+        if ban.minutes == minutes or (ban.minutes == -1 and minutes is None):
+            raise CommandError(t.already_banned)
 
-    try:
-        user = await self.bot.fetch_user(ban.member)
-    except (NotFound, HTTPException):
-        raise CommandError(t.user_not_found)
+        conf_embed = Embed(title=t.confirmation, color=Colors.ModTools)
 
-    await Ban.delete(ban_id)
+        old_time = t.infinity if ban.minutes == -1 else time_to_units(ban.minutes)
 
-    await invalidate_entry_cache()
+        if minutes is None:
+            conf_embed.description = t.confirm_ban_edit.duration(old_time, t.infinity)
+        else:
+            conf_embed.description = t.confirm_ban_edit.duration(old_time, time_to_units(minutes))
 
-    server_embed = Embed(title=t.mute, description=t.ban_deleted_response, colour=Colors.ModTools)
+        if not await confirm_action(ctx, conf_embed):
+            return
 
-    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+        for ban in active_bans[1:]:
+            await Ban.delete(ban.id)
 
-    if await ModSettings.send_delete_user_message.get():
         user_embed = Embed(title=t.ban, colour=Colors.ModTools)
+        server_embed = Embed(title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-        if ban.minutes == -1:
-            user_embed.description = t.ban_deleted.inf(ban.reason)
-        else:
-            user_embed.description = t.ban_deleted.not_inf(time_to_units(ban.minutes), ban.reason)
+        await Ban.edit_duration(ban.id, ctx.author.id, await get_mod_level(ctx.author), minutes)
+
+        await invalidate_entry_cache()
+
+        user_embed.description = t.ban_edited.duration(
+            time_to_units(ban.minutes), t.infinity if minutes is None else time_to_units(minutes)
+        )
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.ban,
+            title=t.log_ban_edited,
+            member=user,
+            reason=ban.reason,
+            duration=t.log_field.infinity if minutes is None else time_to_units(minutes),
+        )
 
         try:
             await user.send(embed=user_embed)
         except (Forbidden, HTTPException):
             server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
             server_embed.colour = Colors.error
+        await reply(ctx, embed=server_embed)
 
-    await reply(ctx, embed=server_embed)
+    @commands.command(aliases=["ban_delete"])
+    @ModPermission.ban.check
+    @guild_only()
+    @docs(t.commands.delete_ban)
+    async def delete_ban(self, ctx: Context, ban_id: int):
+        ban = await get_and_compare_entry(Ban, ban_id, ctx.author)
 
-    await send_to_changelog_mod(
-        guild=ctx.guild,
-        message=ctx.message,
-        colour=Colors.ban,
-        title=t.log_ban_deleted,
-        member=user,
-        reason=ban.reason,
-        duration=t.log_field_infinity if ban.minutes == -1 else time_to_units(ban.minutes),
-    )
+        conf_embed = Embed(
+            title=t.confirmation, description=t.confirm_ban_delete(ban.member_name, ban.id), color=Colors.ModTools
+        )
 
+        if not await confirm_action(ctx, conf_embed):
+            return
 
-@commands.command()
-@ModPermission.ban.check
-@guild_only()
-@docs(t.commands.unban)
-async def unban(self, ctx: Context, user: UserMemberConverter, *, reason: str):
-    user: Union[Member, User]
+        active_bans: List[Ban] = await db.all(filter_by(Ban, active=True, member=ban.member))
 
-    if len(reason) > 900:
-        raise CommandError(t.reason_too_long)
+        if len(active_bans) == 1 and ban in active_bans:
+            user = ctx.guild.get_member(ban.member)
+            if user is not None:
+                try:
+                    await ctx.guild.unban(user, reason="Ban deleted")
+                except HTTPException:
+                    pass
 
-    if not ctx.guild.me.guild_permissions.ban_members:
-        raise CommandError(t.cannot_unban_permissions)
+        try:
+            user = await self.bot.fetch_user(ban.member)
+        except (NotFound, HTTPException):
+            raise CommandError(t.user_not_found)
 
-    was_banned = True
-    try:
-        await ctx.guild.unban(user, reason=reason)
-    except HTTPException:
-        was_banned = False
+        await Ban.delete(ban_id)
 
-    minutes = 0
-    async for ban in await db.stream(filter_by(Ban, active=True, member=user.id)):
-        if not await compare_mod_level(ctx.author, ban.mod_level) or not ctx.author.id == ban.mod:
-            raise CommandError(tg.permission_denied)
+        await invalidate_entry_cache()
 
-        await Ban.deactivate(ban.id, ctx.author.id, reason)
+        server_embed = Embed(title=t.mute, description=t.ban_deleted_response, colour=Colors.ModTools)
 
-        was_banned = True
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+
+        if await ModSettings.send_delete_user_message.get():
+            user_embed = Embed(title=t.ban, colour=Colors.ModTools)
 
-        if ban.minutes > minutes or ban.minutes == -1:
-            minutes = ban.minutes
-
-    if not was_banned:
-        raise UserCommandError(user, t.not_banned)
-
-    await invalidate_entry_cache()
-
-    server_embed = Embed(title=t.unban, description=t.unbanned_response, colour=Colors.ModTools)
-    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-    await reply(ctx, embed=server_embed)
-    await send_to_changelog_mod(
-        guild=ctx.guild,
-        message=ctx.message,
-        colour=Colors.unban,
-        title=t.log_unbanned,
-        member=user,
-        reason=reason,
-        duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
-        mod=ctx.author,
-        original_reason=ban.reason,
-    )
+            if ban.minutes == -1:
+                user_embed.description = t.ban_deleted.inf(ban.reason)
+            else:
+                user_embed.description = t.ban_deleted.not_inf(time_to_units(ban.minutes), ban.reason)
+
+            try:
+                await user.send(embed=user_embed)
+            except (Forbidden, HTTPException):
+                server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
+                server_embed.colour = Colors.error
+
+        await reply(ctx, embed=server_embed)
+
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.ban,
+            title=t.log_ban_deleted,
+            member=user,
+            reason=ban.reason,
+            duration=t.log_field_infinity if ban.minutes == -1 else time_to_units(ban.minutes),
+        )
+
+    @commands.command()
+    @ModPermission.ban.check
+    @guild_only()
+    @docs(t.commands.unban)
+    async def unban(self, ctx: Context, user: UserMemberConverter, *, reason: str):
+        user: Union[Member, User]
+
+        if len(reason) > 900:
+            raise CommandError(t.reason_too_long)
+
+        if not ctx.guild.me.guild_permissions.ban_members:
+            raise CommandError(t.cannot_unban_permissions)
+
+        was_banned = True
+        try:
+            await ctx.guild.unban(user, reason=reason)
+        except HTTPException:
+            was_banned = False
+
+        minutes = 0
+        async for ban in await db.stream(filter_by(Ban, active=True, member=user.id)):
+            if not await compare_mod_level(ctx.author, ban.mod_level) or not ctx.author.id == ban.mod:
+                raise CommandError(tg.permission_denied)
+
+            await Ban.deactivate(ban.id, ctx.author.id, reason)
+
+            was_banned = True
+
+            if ban.minutes > minutes or ban.minutes == -1:
+                minutes = ban.minutes
+
+        if not was_banned:
+            raise UserCommandError(user, t.not_banned)
+
+        await invalidate_entry_cache()
+
+        server_embed = Embed(title=t.unban, description=t.unbanned_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+        await reply(ctx, embed=server_embed)
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.unban,
+            title=t.log_unbanned,
+            member=user,
+            reason=reason,
+            duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
+            mod=ctx.author,
+            original_reason=ban.reason,
+        )

From 54700b51750d3d705c874e899f112d04e120e338 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Mon, 11 Apr 2022 21:29:59 +0200
Subject: [PATCH 099/120] Fixed amazingly stupid indents I defnitely did not
 made myself

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 1662 ++++++++++++++++++++---------------------
 1 file changed, 822 insertions(+), 840 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index de250976b..16058342a 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -495,1016 +495,998 @@ def wrap_entry(
 
         return out
 
+    async def on_member_join(self, member: Member):
+        mute_role: Optional[Role] = member.guild.get_role(await RoleSettings.get("mute"))
+        if mute_role is None:
+            return
 
-async def on_member_join(self, member: Member):
-    mute_role: Optional[Role] = member.guild.get_role(await RoleSettings.get("mute"))
-    if mute_role is None:
-        return
-
-    if await db.exists(filter_by(Mute, active=True, member=member.id)):
-        await member.add_roles(mute_role)
+        if await db.exists(filter_by(Mute, active=True, member=member.id)):
+            await member.add_roles(mute_role)
 
+    async def on_member_ban(self, guild: Guild, member: Member):
+        search_limit = 100
+        for i in range(10, 1, -1):
 
-async def on_member_ban(self, guild: Guild, member: Member):
-    search_limit = 100
-    for i in range(10, 1, -1):
+            try:
+                entry: AuditLogEntry
+                async for entry in guild.audit_logs(limit=search_limit, action=AuditLogAction.ban):
+                    if entry.user == self.bot.user:
+                        continue
+
+                    if member.id != entry.target.id:
+                        continue
+
+                    if entry.reason:
+                        await Ban.create(
+                            entry.target.id,
+                            str(entry.target),
+                            entry.user.id,
+                            await get_mod_level(entry.user),
+                            -1,
+                            entry.reason,
+                            None,
+                        )
 
-        try:
-            entry: AuditLogEntry
-            async for entry in guild.audit_logs(limit=search_limit, action=AuditLogAction.ban):
-                if entry.user == self.bot.user:
-                    continue
+                        await send_to_changelog_mod(
+                            guild=guild,
+                            message=None,
+                            colour=Colors.ban,
+                            title=t.log_banned,
+                            member=entry.target,
+                            reason=entry.reason,
+                            duration=t.log_field.infinity,
+                        )
 
-                if member.id != entry.target.id:
-                    continue
+                    else:
+                        await send_alert(guild, t.alert_member_banned(str(entry.target), str(entry.user)))
 
-                if entry.reason:
-                    await Ban.create(
-                        entry.target.id,
-                        str(entry.target),
-                        entry.user.id,
-                        await get_mod_level(entry.user),
-                        -1,
-                        entry.reason,
-                        None,
-                    )
+                    return
 
-                    await send_to_changelog_mod(
-                        guild=guild,
-                        message=None,
-                        colour=Colors.ban,
-                        title=t.log_banned,
-                        member=entry.target,
-                        reason=entry.reason,
-                        duration=t.log_field.infinity,
-                    )
+            except Forbidden:
+                await send_alert(guild, t.cannot_fetch_audit_logs)
 
-                else:
-                    await send_alert(guild, t.alert_member_banned(str(entry.target), str(entry.user)))
+            await sleep(delay=i * 10)
+            search_limit -= i * 10
 
-                return
+    @commands.command()
+    @guild_only()
+    @ModPermission.modtools_write.check
+    @docs(t.commands.send_delete_message)
+    async def send_delete_message(self, ctx: Context, send: Optional[bool] = None):
+        embed = Embed(title=t.modtools, color=Colors.ModTools)
 
-        except Forbidden:
-            await send_alert(guild, t.cannot_fetch_audit_logs)
+        if send is None:
+            send = await ModSettings.send_delete_user_message.get()
+            embed.description = t.current_send_delete_message[send]
+        else:
+            await ModSettings.send_delete_user_message.set(send)
+            embed.description = t.configured_send_delete_message[send]
 
-        await sleep(delay=i * 10)
-        search_limit -= i * 10
+        await reply(ctx, embed=embed)
+        await send_to_changelog(ctx.guild, t.configured_send_delete_message[send])
 
+    @commands.command()
+    @docs(t.commands.report)
+    async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
+        user: Union[Member, User]
 
-@commands.command()
-@guild_only()
-@ModPermission.modtools_write.check
-@docs(t.commands.send_delete_message)
-async def send_delete_message(self, ctx: Context, send: Optional[bool] = None):
-    embed = Embed(title=t.modtools, color=Colors.ModTools)
+        if len(reason) > 900:
+            raise CommandError(t.reason_too_long)
 
-    if send is None:
-        send = await ModSettings.send_delete_user_message.get()
-        embed.description = t.current_send_delete_message[send]
-    else:
-        await ModSettings.send_delete_user_message.set(send)
-        embed.description = t.configured_send_delete_message[send]
+        if user == self.bot.user:
+            raise UserCommandError(user, t.cannot_report)
+        if user == ctx.author:
+            raise UserCommandError(user, t.no_self_report)
 
-    await reply(ctx, embed=embed)
-    await send_to_changelog(ctx.guild, t.configured_send_delete_message[send])
+        conf_embed = Embed(
+            title=t.confirmation, description=t.confirm_report(user.mention, reason), color=Colors.ModTools
+        )
 
+        if not await confirm_action(ctx, conf_embed, t.report_confirmed, t.report_canceled):
+            return
 
-@commands.command()
-@docs(t.commands.report)
-async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
-    user: Union[Member, User]
+        attachments = ctx.message.attachments
+        evidence = attachments[0] if attachments else None
+        evidence_url = evidence.url if attachments else None
 
-    if len(reason) > 900:
-        raise CommandError(t.reason_too_long)
+        await Report.create(user.id, str(user), ctx.author.id, reason, evidence_url)
+        server_embed = Embed(title=t.report, description=t.reported_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+        await reply(ctx, embed=server_embed)
 
-    if user == self.bot.user:
-        raise UserCommandError(user, t.cannot_report)
-    if user == ctx.author:
-        raise UserCommandError(user, t.no_self_report)
+        alert_embed = Embed(
+            title=t.report,
+            description=t.alert_report(ctx.author.mention, user.mention, reason),
+            color=Colors.report,
+            timestamp=utcnow(),
+        )
 
-    conf_embed = Embed(title=t.confirmation, description=t.confirm_report(user.mention, reason), color=Colors.ModTools)
+        if type(ctx.channel) in (Thread, TextChannel):
+            alert_embed.add_field(
+                name=t.log_field.channel, value=t.jump_url(ctx.channel.mention, ctx.message.jump_url), inline=True
+            )
+        if evidence:
+            alert_embed.add_field(
+                name=t.log_field.evidence, value=t.image_link(evidence.filename, evidence_url), inline=True
+            )
 
-    if not await confirm_action(ctx, conf_embed, t.report_confirmed, t.report_canceled):
-        return
+        await send_alert(self.bot.guilds[0], alert_embed)
 
-    attachments = ctx.message.attachments
-    evidence = attachments[0] if attachments else None
-    evidence_url = evidence.url if attachments else None
-
-    await Report.create(user.id, str(user), ctx.author.id, reason, evidence_url)
-    server_embed = Embed(title=t.report, description=t.reported_response, colour=Colors.ModTools)
-    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-    await reply(ctx, embed=server_embed)
-
-    alert_embed = Embed(
-        title=t.report,
-        description=t.alert_report(ctx.author.mention, user.mention, reason),
-        color=Colors.report,
-        timestamp=utcnow(),
-    )
-
-    if type(ctx.channel) in (Thread, TextChannel):
-        alert_embed.add_field(
-            name=t.log_field.channel, value=t.jump_url(ctx.channel.mention, ctx.message.jump_url), inline=True
-        )
-    if evidence:
-        alert_embed.add_field(
-            name=t.log_field.evidence, value=t.image_link(evidence.filename, evidence_url), inline=True
-        )
+    @commands.command()
+    @ModPermission.warn.check
+    @guild_only()
+    @docs(t.commands.warn)
+    async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
+        user: Union[Member, User]
 
-    await send_alert(self.bot.guilds[0], alert_embed)
+        if len(reason) > 900:
+            raise CommandError(t.reason_too_long)
 
+        if user == self.bot.user:
+            raise UserCommandError(user, t.cannot_warn)
 
-@commands.command()
-@ModPermission.warn.check
-@guild_only()
-@docs(t.commands.warn)
-async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
-    user: Union[Member, User]
+        attachments = ctx.message.attachments
+        evidence = attachments[0] if attachments else None
+        evidence_url = evidence.url if attachments else None
 
-    if len(reason) > 900:
-        raise CommandError(t.reason_too_long)
+        if not evidence:
+            if not await confirm_no_evidence(ctx):
+                return
 
-    if user == self.bot.user:
-        raise UserCommandError(user, t.cannot_warn)
+        user_embed = Embed(
+            title=t.warn, colour=Colors.ModTools, description=t.warned(ctx.author.mention, ctx.guild.name, reason)
+        )
 
-    attachments = ctx.message.attachments
-    evidence = attachments[0] if attachments else None
-    evidence_url = evidence.url if attachments else None
+        server_embed = Embed(title=t.warn, description=t.warned_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+        try:
+            await user.send(embed=user_embed)
+        except (Forbidden, HTTPException):
+            server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
+            server_embed.colour = Colors.error
+        await Warn.create(user.id, str(user), ctx.author.id, await get_mod_level(ctx.author), reason, evidence_url)
+        await reply(ctx, embed=server_embed)
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.warn,
+            title=t.log_warned,
+            member=user,
+            reason=reason,
+            evidence=evidence,
+        )
 
-    if not evidence:
-        if not await confirm_no_evidence(ctx):
-            return
+    @commands.command(aliases=["warn_edit"])
+    @ModPermission.warn.check
+    @guild_only()
+    @docs(t.commands.edit_warn)
+    async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
+        warn = await get_and_compare_entry(Warn, warn_id, ctx.author)
 
-    user_embed = Embed(
-        title=t.warn, colour=Colors.ModTools, description=t.warned(ctx.author.mention, ctx.guild.name, reason)
-    )
-
-    server_embed = Embed(title=t.warn, description=t.warned_response, colour=Colors.ModTools)
-    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-    try:
-        await user.send(embed=user_embed)
-    except (Forbidden, HTTPException):
-        server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-        server_embed.colour = Colors.error
-    await Warn.create(user.id, str(user), ctx.author.id, await get_mod_level(ctx.author), reason, evidence_url)
-    await reply(ctx, embed=server_embed)
-    await send_to_changelog_mod(
-        guild=ctx.guild,
-        message=ctx.message,
-        colour=Colors.warn,
-        title=t.log_warned,
-        member=user,
-        reason=reason,
-        evidence=evidence,
-    )
-
-
-@commands.command(aliases=["warn_edit"])
-@ModPermission.warn.check
-@guild_only()
-@docs(t.commands.edit_warn)
-async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
-    warn = await get_and_compare_entry(Warn, warn_id, ctx.author)
-
-    if len(reason) > 900:
-        raise CommandError(t.reason_too_long)
-
-    conf_embed = Embed(
-        title=t.confirmation, description=t.confirm_warn_edit(warn.reason, reason), color=Colors.ModTools
-    )
-
-    if not await confirm_action(ctx, conf_embed):
-        return
+        if len(reason) > 900:
+            raise CommandError(t.reason_too_long)
 
-    try:
-        user = await self.bot.fetch_user(warn.member)
-    except (NotFound, HTTPException):
-        raise CommandError(t.user_not_found)
-
-    user_embed = Embed(title=t.warn, description=t.warn_edited(warn.reason, reason), colour=Colors.ModTools)
-    server_embed = Embed(title=t.warn, description=t.warn_edited_response, colour=Colors.ModTools)
-    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-
-    await Warn.edit(warn_id, ctx.author.id, await get_mod_level(ctx.author), reason)
-
-    try:
-        await user.send(embed=user_embed)
-    except (Forbidden, HTTPException):
-        server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-        server_embed.colour = Colors.error
-    await reply(ctx, embed=server_embed)
-    await send_to_changelog_mod(
-        guild=ctx.guild,
-        message=ctx.message,
-        colour=Colors.warn,
-        title=t.log_warn_edited,
-        member=user,
-        reason=reason,
-    )
-
-
-@commands.command(aliases=["warn_delete"])
-@ModPermission.warn.check
-@guild_only()
-@docs(t.commands.delete_warn)
-async def delete_warn(self, ctx: Context, warn_id: int):
-    warn = await get_and_compare_entry(Warn, warn_id, ctx.author)
-
-    conf_embed = Embed(
-        title=t.confirmation, description=t.confirm_warn_delete(warn.member_name, warn.id), color=Colors.ModTools
-    )
-
-    if not await confirm_action(ctx, conf_embed):
-        return
+        conf_embed = Embed(
+            title=t.confirmation, description=t.confirm_warn_edit(warn.reason, reason), color=Colors.ModTools
+        )
 
-    await Warn.delete(warn_id)
+        if not await confirm_action(ctx, conf_embed):
+            return
 
-    try:
-        user = await self.bot.fetch_user(warn.member)
-    except (NotFound, HTTPException):
-        raise CommandError(t.user_not_found)
+        try:
+            user = await self.bot.fetch_user(warn.member)
+        except (NotFound, HTTPException):
+            raise CommandError(t.user_not_found)
 
-    server_embed = Embed(title=t.warn, description=t.warn_deleted_response, colour=Colors.ModTools)
-    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+        user_embed = Embed(title=t.warn, description=t.warn_edited(warn.reason, reason), colour=Colors.ModTools)
+        server_embed = Embed(title=t.warn, description=t.warn_edited_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-    if await ModSettings.send_delete_user_message.get():
-        user_embed = Embed(title=t.warn, description=t.warn_deleted(warn.reason), colour=Colors.ModTools)
+        await Warn.edit(warn_id, ctx.author.id, await get_mod_level(ctx.author), reason)
 
         try:
             await user.send(embed=user_embed)
         except (Forbidden, HTTPException):
             server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
             server_embed.colour = Colors.error
+        await reply(ctx, embed=server_embed)
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.warn,
+            title=t.log_warn_edited,
+            member=user,
+            reason=reason,
+        )
+
+    @commands.command(aliases=["warn_delete"])
+    @ModPermission.warn.check
+    @guild_only()
+    @docs(t.commands.delete_warn)
+    async def delete_warn(self, ctx: Context, warn_id: int):
+        warn = await get_and_compare_entry(Warn, warn_id, ctx.author)
+
+        conf_embed = Embed(
+            title=t.confirmation, description=t.confirm_warn_delete(warn.member_name, warn.id), color=Colors.ModTools
+        )
 
-    await reply(ctx, embed=server_embed)
-    await send_to_changelog_mod(
-        guild=ctx.guild,
-        message=ctx.message,
-        colour=Colors.warn,
-        title=t.log_warn_deleted,
-        member=user,
-        reason=warn.reason,
-    )
+        if not await confirm_action(ctx, conf_embed):
+            return
 
+        await Warn.delete(warn_id)
 
-@commands.command()
-@ModPermission.mute.check
-@guild_only()
-@docs(t.commands.mute)
-async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConverter, *, reason: str):
-    user: Union[Member, User]
+        try:
+            user = await self.bot.fetch_user(warn.member)
+        except (NotFound, HTTPException):
+            raise CommandError(t.user_not_found)
 
-    time: Optional[int]
-    minutes = time
+        server_embed = Embed(title=t.warn, description=t.warn_deleted_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-    if len(reason) > 900:
-        raise CommandError(t.reason_too_long)
+        if await ModSettings.send_delete_user_message.get():
+            user_embed = Embed(title=t.warn, description=t.warn_deleted(warn.reason), colour=Colors.ModTools)
 
-    mute_role: Role = await get_mute_role(ctx.guild)
+            try:
+                await user.send(embed=user_embed)
+            except (Forbidden, HTTPException):
+                server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
+                server_embed.colour = Colors.error
+
+        await reply(ctx, embed=server_embed)
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.warn,
+            title=t.log_warn_deleted,
+            member=user,
+            reason=warn.reason,
+        )
 
-    if user == self.bot.user or await is_teamler(user):
-        raise UserCommandError(user, t.cannot_mute)
+    @commands.command()
+    @ModPermission.mute.check
+    @guild_only()
+    @docs(t.commands.mute)
+    async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConverter, *, reason: str):
+        user: Union[Member, User]
 
-    if isinstance(user, Member):
-        await user.add_roles(mute_role)
-        await user.move_to(None)
+        time: Optional[int]
+        minutes = time
 
-    if await db.exists(filter_by(Mute, active=True, member=user.id)):
-        raise UserCommandError(user, t.already_muted)
+        if len(reason) > 900:
+            raise CommandError(t.reason_too_long)
 
-    attachments = ctx.message.attachments
-    evidence = attachments[0] if attachments else None
-    evidence_url = evidence.url if attachments else None
+        mute_role: Role = await get_mute_role(ctx.guild)
 
-    if not evidence:
-        if not await confirm_no_evidence(ctx):
-            return
+        if user == self.bot.user or await is_teamler(user):
+            raise UserCommandError(user, t.cannot_mute)
 
-    user_embed = Embed(title=t.mute, colour=Colors.ModTools)
-    server_embed = Embed(title=t.mute, description=t.muted_response, colour=Colors.ModTools)
-    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-
-    await Mute.create(
-        user.id,
-        str(user),
-        ctx.author.id,
-        await get_mod_level(ctx.author),
-        minutes if minutes is not None else -1,
-        reason,
-        evidence_url,
-    )
-
-    await invalidate_entry_cache()
-
-    await send_to_changelog_mod(
-        guild=ctx.guild,
-        message=ctx.message,
-        colour=Colors.mute,
-        title=t.log_muted,
-        member=user,
-        reason=reason,
-        duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
-        evidence=evidence,
-    )
-
-    if minutes is not None:
-        user_embed.description = t.muted(ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason)
-    else:
-        user_embed.description = t.muted_inf(ctx.author.mention, ctx.guild.name, reason)
+        if isinstance(user, Member):
+            await user.add_roles(mute_role)
+            await user.move_to(None)
 
-    try:
-        await user.send(embed=user_embed)
-    except (Forbidden, HTTPException):
-        server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-        server_embed.colour = Colors.error
+        if await db.exists(filter_by(Mute, active=True, member=user.id)):
+            raise UserCommandError(user, t.already_muted)
 
-    await reply(ctx, embed=server_embed)
+        attachments = ctx.message.attachments
+        evidence = attachments[0] if attachments else None
+        evidence_url = evidence.url if attachments else None
 
+        if not evidence:
+            if not await confirm_no_evidence(ctx):
+                return
 
-@commands.group(aliases=["mute_edit"])
-@ModPermission.mute.check
-@guild_only()
-@docs(t.commands.edit_mute)
-async def edit_mute(self, ctx):
-    if ctx.invoked_subcommand is None:
-        raise UserInputError
+        user_embed = Embed(title=t.mute, colour=Colors.ModTools)
+        server_embed = Embed(title=t.mute, description=t.muted_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+
+        await Mute.create(
+            user.id,
+            str(user),
+            ctx.author.id,
+            await get_mod_level(ctx.author),
+            minutes if minutes is not None else -1,
+            reason,
+            evidence_url,
+        )
 
+        await invalidate_entry_cache()
+
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.mute,
+            title=t.log_muted,
+            member=user,
+            reason=reason,
+            duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
+            evidence=evidence,
+        )
 
-@edit_mute.command(name="reason", aliases=["r"])
-@docs(t.commands.edit_mute_reason)
-async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
-    mute = await get_and_compare_entry(Mute, mute_id, ctx.author)
+        if minutes is not None:
+            user_embed.description = t.muted(ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason)
+        else:
+            user_embed.description = t.muted_inf(ctx.author.mention, ctx.guild.name, reason)
 
-    if len(reason) > 900:
-        raise CommandError(t.reason_too_long)
+        try:
+            await user.send(embed=user_embed)
+        except (Forbidden, HTTPException):
+            server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
+            server_embed.colour = Colors.error
 
-    conf_embed = Embed(
-        title=t.confirmation, description=t.confirm_mute_edit.reason(mute.reason, reason), color=Colors.ModTools
-    )
+        await reply(ctx, embed=server_embed)
 
-    if not await confirm_action(ctx, conf_embed):
-        return
+    @commands.group(aliases=["mute_edit"])
+    @ModPermission.mute.check
+    @guild_only()
+    @docs(t.commands.edit_mute)
+    async def edit_mute(self, ctx):
+        if ctx.invoked_subcommand is None:
+            raise UserInputError
 
-    try:
-        user = await self.bot.fetch_user(mute.member)
-    except (NotFound, HTTPException):
-        raise CommandError(t.user_not_found)
-
-    user_embed = Embed(title=t.mute, description=t.mute_edited.reason(mute.reason, reason), colour=Colors.ModTools)
-    server_embed = Embed(title=t.mute, description=t.mute_edited_response, colour=Colors.ModTools)
-    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-
-    await Mute.edit_reason(mute_id, ctx.author.id, await get_mod_level(ctx.author), reason)
-
-    try:
-        await user.send(embed=user_embed)
-    except (Forbidden, HTTPException):
-        server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-        server_embed.colour = Colors.error
-    await reply(ctx, embed=server_embed)
-    await send_to_changelog_mod(
-        guild=ctx.guild,
-        message=ctx.message,
-        colour=Colors.mute,
-        title=t.log_mute_edited,
-        member=user,
-        reason=reason,
-    )
-
-
-@edit_mute.command(name="duration", aliases=["d"])
-@docs(t.commands.edit_mute_duration)
-async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time: DurationConverter):
-    user: Union[Member, User]
-    time: Optional[int]
-    minutes = time
-
-    active_mutes: List[Mute] = sorted(
-        await db.all(filter_by(Mute, active=True, member=user.id)), key=lambda active_mute: active_mute.timestamp
-    )
-
-    if not active_mutes:
-        raise CommandError(t.not_muted)
-
-    mute = active_mutes[0]
-
-    if not await compare_mod_level(ctx.author, mute.mod_level) or not ctx.author.id == mute.mod:
-        raise CommandError(tg.permission_denied)
+    @edit_mute.command(name="reason", aliases=["r"])
+    @docs(t.commands.edit_mute_reason)
+    async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
+        mute = await get_and_compare_entry(Mute, mute_id, ctx.author)
 
-    if mute.minutes == minutes or (mute.minutes == -1 and minutes is None):
-        raise CommandError(t.already_muted)
+        if len(reason) > 900:
+            raise CommandError(t.reason_too_long)
 
-    conf_embed = Embed(title=t.confirmation, color=Colors.ModTools)
+        conf_embed = Embed(
+            title=t.confirmation, description=t.confirm_mute_edit.reason(mute.reason, reason), color=Colors.ModTools
+        )
 
-    old_time = t.infinity if mute.minutes == -1 else time_to_units(mute.minutes)
+        if not await confirm_action(ctx, conf_embed):
+            return
 
-    if minutes is None:
-        conf_embed.description = t.confirm_mute_edit.duration(old_time, t.infinity)
-    else:
-        conf_embed.description = t.confirm_mute_edit.duration(old_time, time_to_units(minutes))
+        try:
+            user = await self.bot.fetch_user(mute.member)
+        except (NotFound, HTTPException):
+            raise CommandError(t.user_not_found)
 
-    if not await confirm_action(ctx, conf_embed):
-        return
+        user_embed = Embed(title=t.mute, description=t.mute_edited.reason(mute.reason, reason), colour=Colors.ModTools)
+        server_embed = Embed(title=t.mute, description=t.mute_edited_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-    for active_mute in active_mutes[1:]:
-        await Mute.delete(active_mute.id)
-
-    user_embed = Embed(title=t.mute, colour=Colors.ModTools)
-    server_embed = Embed(title=t.mute, description=t.mute_edited_response, colour=Colors.ModTools)
-    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-
-    await Mute.edit_duration(mute.id, ctx.author.id, await get_mod_level(ctx.author), minutes)
-
-    await invalidate_entry_cache()
-
-    user_embed.description = t.mute_edited.duration(
-        time_to_units(mute.minutes), t.infinity if minutes is None else time_to_units(minutes)
-    )
-    await send_to_changelog_mod(
-        guild=ctx.guild,
-        message=ctx.message,
-        colour=Colors.mute,
-        title=t.log_mute_edited,
-        member=user,
-        reason=Mute.reason,
-        duration=t.log_field.infinity if minutes is None else time_to_units(minutes),
-    )
-
-    try:
-        await user.send(embed=user_embed)
-    except (Forbidden, HTTPException):
-        server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-        server_embed.colour = Colors.error
-    await reply(ctx, embed=server_embed)
-
-
-@commands.command(aliases=["mute_delete"])
-@ModPermission.mute.check
-@guild_only()
-@docs(t.commands.delete_mute)
-async def delete_mute(self, ctx: Context, mute_id: int):
-    mute = await get_and_compare_entry(Mute, mute_id, ctx.author)
-
-    conf_embed = Embed(
-        title=t.confirmation, description=t.confirm_mute_delete(mute.member_name, mute.id), color=Colors.ModTools
-    )
-
-    if not await confirm_action(ctx, conf_embed):
-        return
+        await Mute.edit_reason(mute_id, ctx.author.id, await get_mod_level(ctx.author), reason)
 
-    active_mutes: List[Mute] = await db.all(filter_by(Mute, active=True, member=mute.member))
+        try:
+            await user.send(embed=user_embed)
+        except (Forbidden, HTTPException):
+            server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
+            server_embed.colour = Colors.error
+        await reply(ctx, embed=server_embed)
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.mute,
+            title=t.log_mute_edited,
+            member=user,
+            reason=reason,
+        )
+
+    @edit_mute.command(name="duration", aliases=["d"])
+    @docs(t.commands.edit_mute_duration)
+    async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time: DurationConverter):
+        user: Union[Member, User]
+        time: Optional[int]
+        minutes = time
 
-    if len(active_mutes) == 1 and mute in active_mutes:
-        user = ctx.guild.get_member(mute.member)
-        if user is not None:
-            if (mute_role := await get_mute_role(ctx.guild)) in user.roles:
-                await user.remove_roles(mute_role)
+        active_mutes: List[Mute] = sorted(
+            await db.all(filter_by(Mute, active=True, member=user.id)), key=lambda active_mute: active_mute.timestamp
+        )
 
-    try:
-        user = await self.bot.fetch_user(mute.member)
-    except (NotFound, HTTPException):
-        raise CommandError(t.user_not_found)
+        if not active_mutes:
+            raise CommandError(t.not_muted)
 
-    await Mute.delete(mute_id)
+        mute = active_mutes[0]
+
+        if not await compare_mod_level(ctx.author, mute.mod_level) or not ctx.author.id == mute.mod:
+            raise CommandError(tg.permission_denied)
 
-    await invalidate_entry_cache()
+        if mute.minutes == minutes or (mute.minutes == -1 and minutes is None):
+            raise CommandError(t.already_muted)
 
-    server_embed = Embed(title=t.mute, description=t.mute_deleted_response, colour=Colors.ModTools)
-    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+        conf_embed = Embed(title=t.confirmation, color=Colors.ModTools)
 
-    if await ModSettings.send_delete_user_message.get():
-        user_embed = Embed(title=t.warn, colour=Colors.ModTools)
+        old_time = t.infinity if mute.minutes == -1 else time_to_units(mute.minutes)
 
-        if mute.minutes == -1:
-            user_embed.description = t.mute_deleted.inf(mute.reason)
+        if minutes is None:
+            conf_embed.description = t.confirm_mute_edit.duration(old_time, t.infinity)
         else:
-            user_embed.description = t.mute_deleted.not_inf(time_to_units(mute.minutes), mute.reason)
+            conf_embed.description = t.confirm_mute_edit.duration(old_time, time_to_units(minutes))
+
+        if not await confirm_action(ctx, conf_embed):
+            return
+
+        for active_mute in active_mutes[1:]:
+            await Mute.delete(active_mute.id)
+
+        user_embed = Embed(title=t.mute, colour=Colors.ModTools)
+        server_embed = Embed(title=t.mute, description=t.mute_edited_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+
+        await Mute.edit_duration(mute.id, ctx.author.id, await get_mod_level(ctx.author), minutes)
+
+        await invalidate_entry_cache()
+
+        user_embed.description = t.mute_edited.duration(
+            time_to_units(mute.minutes), t.infinity if minutes is None else time_to_units(minutes)
+        )
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.mute,
+            title=t.log_mute_edited,
+            member=user,
+            reason=Mute.reason,
+            duration=t.log_field.infinity if minutes is None else time_to_units(minutes),
+        )
 
         try:
             await user.send(embed=user_embed)
         except (Forbidden, HTTPException):
             server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
             server_embed.colour = Colors.error
+        await reply(ctx, embed=server_embed)
+
+    @commands.command(aliases=["mute_delete"])
+    @ModPermission.mute.check
+    @guild_only()
+    @docs(t.commands.delete_mute)
+    async def delete_mute(self, ctx: Context, mute_id: int):
+        mute = await get_and_compare_entry(Mute, mute_id, ctx.author)
 
-    await reply(ctx, embed=server_embed)
+        conf_embed = Embed(
+            title=t.confirmation, description=t.confirm_mute_delete(mute.member_name, mute.id), color=Colors.ModTools
+        )
+
+        if not await confirm_action(ctx, conf_embed):
+            return
 
-    await send_to_changelog_mod(
-        guild=ctx.guild,
-        message=ctx.message,
-        colour=Colors.mute,
-        title=t.log_mute_deleted,
-        member=user,
-        reason=mute.reason,
-        duration=t.log_field_infinity if mute.minutes == -1 else time_to_units(mute.minutes),
-    )
+        active_mutes: List[Mute] = await db.all(filter_by(Mute, active=True, member=mute.member))
 
+        if len(active_mutes) == 1 and mute in active_mutes:
+            user = ctx.guild.get_member(mute.member)
+            if user is not None:
+                if (mute_role := await get_mute_role(ctx.guild)) in user.roles:
+                    await user.remove_roles(mute_role)
 
-@commands.command()
-@ModPermission.mute.check
-@guild_only()
-@docs(t.commands.unmute)
-async def unmute(self, ctx: Context, user: UserMemberConverter, *, reason: str):
-    user: Union[Member, User]
+        try:
+            user = await self.bot.fetch_user(mute.member)
+        except (NotFound, HTTPException):
+            raise CommandError(t.user_not_found)
 
-    if len(reason) > 900:
-        raise CommandError(t.reason_too_long)
+        await Mute.delete(mute_id)
 
-    mute_role: Role = await get_mute_role(ctx.guild)
+        await invalidate_entry_cache()
 
-    was_muted = False
-    if isinstance(user, Member) and mute_role in user.roles:
-        was_muted = True
-        await user.remove_roles(mute_role)
+        server_embed = Embed(title=t.mute, description=t.mute_deleted_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-    minutes = 0
-    async for mute in await db.stream(filter_by(Mute, active=True, member=user.id)):
-        if not await compare_mod_level(ctx.author, mute.mod_level) or not ctx.author.id == mute.mod:
-            raise CommandError(tg.permission_denied)
+        if await ModSettings.send_delete_user_message.get():
+            user_embed = Embed(title=t.warn, colour=Colors.ModTools)
+
+            if mute.minutes == -1:
+                user_embed.description = t.mute_deleted.inf(mute.reason)
+            else:
+                user_embed.description = t.mute_deleted.not_inf(time_to_units(mute.minutes), mute.reason)
+
+            try:
+                await user.send(embed=user_embed)
+            except (Forbidden, HTTPException):
+                server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
+                server_embed.colour = Colors.error
+
+        await reply(ctx, embed=server_embed)
+
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.mute,
+            title=t.log_mute_deleted,
+            member=user,
+            reason=mute.reason,
+            duration=t.log_field_infinity if mute.minutes == -1 else time_to_units(mute.minutes),
+        )
 
-        await Mute.deactivate(mute.id, ctx.author.id, reason)
+    @commands.command()
+    @ModPermission.mute.check
+    @guild_only()
+    @docs(t.commands.unmute)
+    async def unmute(self, ctx: Context, user: UserMemberConverter, *, reason: str):
+        user: Union[Member, User]
+
+        if len(reason) > 900:
+            raise CommandError(t.reason_too_long)
+
+        mute_role: Role = await get_mute_role(ctx.guild)
+
+        was_muted = False
+        if isinstance(user, Member) and mute_role in user.roles:
+            was_muted = True
+            await user.remove_roles(mute_role)
+
+        minutes = 0
+        async for mute in await db.stream(filter_by(Mute, active=True, member=user.id)):
+            if not await compare_mod_level(ctx.author, mute.mod_level) or not ctx.author.id == mute.mod:
+                raise CommandError(tg.permission_denied)
+
+            await Mute.deactivate(mute.id, ctx.author.id, reason)
+
+            was_muted = True
+
+            if mute.minutes > minutes or mute.minutes == -1:
+                minutes = mute.minutes
+
+        if not was_muted:
+            raise UserCommandError(user, t.not_muted)
+
+        await invalidate_entry_cache()
+
+        server_embed = Embed(title=t.unmute, description=t.unmuted_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+        await reply(ctx, embed=server_embed)
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.unmute,
+            title=t.log_unmuted,
+            member=user,
+            reason=reason,
+            duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
+            mod=ctx.author,
+            original_reason=mute.reason,
+        )
 
-        was_muted = True
+    @commands.command()
+    @ModPermission.kick.check
+    @guild_only()
+    @docs(t.commands.kick)
+    async def kick(self, ctx: Context, member: Member, *, reason: str):
+        if len(reason) > 900:
+            raise CommandError(t.reason_too_long)
 
-        if mute.minutes > minutes or mute.minutes == -1:
-            minutes = mute.minutes
+        if member == self.bot.user or await is_teamler(member):
+            raise UserCommandError(member, t.cannot_kick)
 
-    if not was_muted:
-        raise UserCommandError(user, t.not_muted)
+        if not ctx.guild.me.guild_permissions.kick_members:
+            raise CommandError(t.cannot_kick_permissions)
 
-    await invalidate_entry_cache()
+        if member.top_role >= ctx.guild.me.top_role or member.id == ctx.guild.owner_id:
+            raise UserCommandError(member, t.cannot_kick)
 
-    server_embed = Embed(title=t.unmute, description=t.unmuted_response, colour=Colors.ModTools)
-    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-    await reply(ctx, embed=server_embed)
-    await send_to_changelog_mod(
-        guild=ctx.guild,
-        message=ctx.message,
-        colour=Colors.unmute,
-        title=t.log_unmuted,
-        member=user,
-        reason=reason,
-        duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
-        mod=ctx.author,
-        original_reason=mute.reason,
-    )
+        attachments = ctx.message.attachments
+        evidence = attachments[0] if attachments else None
+        evidence_url = evidence.url if attachments else None
 
+        if not evidence:
+            if not await confirm_no_evidence(ctx):
+                return
 
-@commands.command()
-@ModPermission.kick.check
-@guild_only()
-@docs(t.commands.kick)
-async def kick(self, ctx: Context, member: Member, *, reason: str):
-    if len(reason) > 900:
-        raise CommandError(t.reason_too_long)
+        await Kick.create(member.id, str(member), ctx.author.id, await get_mod_level(ctx.author), reason, evidence_url)
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.kick,
+            title=t.log_kicked,
+            member=member,
+            reason=reason,
+            evidence=evidence,
+        )
 
-    if member == self.bot.user or await is_teamler(member):
-        raise UserCommandError(member, t.cannot_kick)
+        user_embed = Embed(
+            title=t.kick,
+            colour=Colors.ModTools,
+            description=t.kicked(ctx.author.mention, ctx.guild.name, reason),
+        )
 
-    if not ctx.guild.me.guild_permissions.kick_members:
-        raise CommandError(t.cannot_kick_permissions)
+        server_embed = Embed(title=t.kick, description=t.kicked_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(member), icon_url=member.display_avatar.url)
 
-    if member.top_role >= ctx.guild.me.top_role or member.id == ctx.guild.owner_id:
-        raise UserCommandError(member, t.cannot_kick)
+        try:
+            await member.send(embed=user_embed)
+        except (Forbidden, HTTPException):
+            server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
+            server_embed.colour = Colors.error
 
-    attachments = ctx.message.attachments
-    evidence = attachments[0] if attachments else None
-    evidence_url = evidence.url if attachments else None
+        await member.kick(reason=reason)
+        await revoke_verification(member)
 
-    if not evidence:
-        if not await confirm_no_evidence(ctx):
-            return
+        await reply(ctx, embed=server_embed)
 
-    await Kick.create(member.id, str(member), ctx.author.id, await get_mod_level(ctx.author), reason, evidence_url)
-    await send_to_changelog_mod(
-        guild=ctx.guild,
-        message=ctx.message,
-        colour=Colors.kick,
-        title=t.log_kicked,
-        member=member,
-        reason=reason,
-        evidence=evidence,
-    )
-
-    user_embed = Embed(
-        title=t.kick,
-        colour=Colors.ModTools,
-        description=t.kicked(ctx.author.mention, ctx.guild.name, reason),
-    )
-
-    server_embed = Embed(title=t.kick, description=t.kicked_response, colour=Colors.ModTools)
-    server_embed.set_author(name=str(member), icon_url=member.display_avatar.url)
-
-    try:
-        await member.send(embed=user_embed)
-    except (Forbidden, HTTPException):
-        server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-        server_embed.colour = Colors.error
-
-    await member.kick(reason=reason)
-    await revoke_verification(member)
-
-    await reply(ctx, embed=server_embed)
-
-
-@commands.command(aliases=["kick_edit"])
-@ModPermission.kick.check
-@guild_only()
-@docs(t.commands.edit_kick)
-async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
-    kick = await get_and_compare_entry(Kick, kick_id, ctx.author)
-
-    if len(reason) > 900:
-        raise CommandError(t.reason_too_long)
-
-    conf_embed = Embed(
-        title=t.confirmation, description=t.confirm_kick_edit(kick.reason, reason), color=Colors.ModTools
-    )
-
-    if not await confirm_action(ctx, conf_embed):
-        return
+    @commands.command(aliases=["kick_edit"])
+    @ModPermission.kick.check
+    @guild_only()
+    @docs(t.commands.edit_kick)
+    async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
+        kick = await get_and_compare_entry(Kick, kick_id, ctx.author)
 
-    try:
-        user = await self.bot.fetch_user(kick.member)
-    except (NotFound, HTTPException):
-        raise CommandError(t.user_not_found)
-
-    user_embed = Embed(title=t.kick, description=t.kick_edited(kick.reason, reason), colour=Colors.ModTools)
-    server_embed = Embed(title=t.kick, description=t.kick_edited_reponse, colour=Colors.ModTools)
-    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-
-    await Kick.edit(kick_id, ctx.author.id, await get_mod_level(ctx.author), reason)
-
-    try:
-        await user.send(embed=user_embed)
-    except (Forbidden, HTTPException):
-        server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-        server_embed.colour = Colors.error
-    await reply(ctx, embed=server_embed)
-    await send_to_changelog_mod(
-        guild=ctx.guild,
-        message=ctx.message,
-        colour=Colors.kick,
-        title=t.log_kick_edited,
-        member=user,
-        reason=reason,
-    )
-
-
-@commands.command(aliases=["kick_delete"])
-@ModPermission.kick.check
-@guild_only()
-@docs(t.commands.delete_kick)
-async def delete_kick(self, ctx: Context, kick_id: int):
-    kick = await get_and_compare_entry(Kick, kick_id, ctx.author)
-
-    conf_embed = Embed(
-        title=t.confirmation, description=t.confirm_kick_delete(kick.member_name, kick.id), color=Colors.ModTools
-    )
-
-    if not await confirm_action(ctx, conf_embed):
-        return
+        if len(reason) > 900:
+            raise CommandError(t.reason_too_long)
 
-    await Kick.delete(kick_id)
+        conf_embed = Embed(
+            title=t.confirmation, description=t.confirm_kick_edit(kick.reason, reason), color=Colors.ModTools
+        )
+
+        if not await confirm_action(ctx, conf_embed):
+            return
 
-    try:
-        user = await self.bot.fetch_user(kick.member)
-    except (NotFound, HTTPException):
-        raise CommandError(t.user_not_found)
+        try:
+            user = await self.bot.fetch_user(kick.member)
+        except (NotFound, HTTPException):
+            raise CommandError(t.user_not_found)
 
-    server_embed = Embed(title=t.warn, description=t.kick_deleted_response, colour=Colors.ModTools)
-    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+        user_embed = Embed(title=t.kick, description=t.kick_edited(kick.reason, reason), colour=Colors.ModTools)
+        server_embed = Embed(title=t.kick, description=t.kick_edited_reponse, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-    if await ModSettings.send_delete_user_message.get():
-        user_embed = Embed(title=t.kick, description=t.kick_deleted(kick.reason), colour=Colors.ModTools)
+        await Kick.edit(kick_id, ctx.author.id, await get_mod_level(ctx.author), reason)
 
         try:
             await user.send(embed=user_embed)
         except (Forbidden, HTTPException):
             server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
             server_embed.colour = Colors.error
+        await reply(ctx, embed=server_embed)
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.kick,
+            title=t.log_kick_edited,
+            member=user,
+            reason=reason,
+        )
 
-    await reply(ctx, embed=server_embed)
-    await send_to_changelog_mod(
-        guild=ctx.guild,
-        message=ctx.message,
-        colour=Colors.kick,
-        title=t.log_kick_deleted,
-        member=user,
-        reason=kick.reason,
-    )
-
-
-@commands.command()
-@ModPermission.ban.check
-@guild_only()
-@docs(t.commands.ban)
-async def ban(self, ctx: Context, user: UserMemberConverter, time: DurationConverter, delete_days: int, *, reason: str):
-    time: Optional[int]
-    minutes = time
-
-    user: Union[Member, User]
-
-    if not ctx.guild.me.guild_permissions.ban_members:
-        raise CommandError(t.cannot_ban_permissions)
-
-    if len(reason) > 900:
-        raise CommandError(t.reason_too_long)
-    if not 0 <= delete_days <= 7:
-        raise CommandError(tg.invalid_duration)
-
-    if user == self.bot.user or await is_teamler(user):
-        raise UserCommandError(user, t.cannot_ban)
-    if isinstance(user, Member) and (user.top_role >= ctx.guild.me.top_role or user.id == ctx.guild.owner_id):
-        raise UserCommandError(user, t.cannot_ban)
-
-    active_bans: List[Ban] = await db.all(filter_by(Ban, active=True, member=user.id))
-    if active_bans:
-        raise UserCommandError(user, t.already_banned)
-
-    active_mutes: List[Mute] = await db.all(filter_by(Mute, active=True, member=user.id))
-    for mute in active_mutes:
-        await Mute.deactivate(mute.id, ctx.author.id, t.cancelled_by_ban)
-
-    attachments = ctx.message.attachments
-    evidence = attachments[0] if attachments else None
-    evidence_url = evidence.url if attachments else None
-
-    if not evidence:
-        if not await confirm_no_evidence(ctx):
-            return
+    @commands.command(aliases=["kick_delete"])
+    @ModPermission.kick.check
+    @guild_only()
+    @docs(t.commands.delete_kick)
+    async def delete_kick(self, ctx: Context, kick_id: int):
+        kick = await get_and_compare_entry(Kick, kick_id, ctx.author)
 
-    user_embed = Embed(title=t.ban, colour=Colors.ModTools)
-    server_embed = Embed(title=t.ban, description=t.banned_response, colour=Colors.ModTools)
-    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-
-    if active_mutes:
-        server_embed.description += f"\n\n{t.previously_muted}"
-
-    await Ban.create(
-        user.id,
-        str(user),
-        ctx.author.id,
-        await get_mod_level(ctx.author),
-        minutes if minutes is not None else -1,
-        reason,
-        evidence_url,
-    )
-
-    await invalidate_entry_cache()
-
-    await send_to_changelog_mod(
-        guild=ctx.guild,
-        message=ctx.message,
-        colour=Colors.ban,
-        title=t.log_banned,
-        member=user,
-        reason=reason,
-        duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
-        evidence=evidence,
-    )
-
-    if minutes is not None:
-        user_embed.description = t.banned(ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason)
+        conf_embed = Embed(
+            title=t.confirmation, description=t.confirm_kick_delete(kick.member_name, kick.id), color=Colors.ModTools
+        )
 
-    else:
-        user_embed.description = t.banned_inf(ctx.author.mention, ctx.guild.name, reason)
+        if not await confirm_action(ctx, conf_embed):
+            return
 
-    try:
-        await user.send(embed=user_embed)
-    except (Forbidden, HTTPException):
-        server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-        server_embed.colour = Colors.error
+        await Kick.delete(kick_id)
 
-    await ctx.guild.ban(user, delete_message_days=delete_days, reason=reason)
-    await revoke_verification(user)
+        try:
+            user = await self.bot.fetch_user(kick.member)
+        except (NotFound, HTTPException):
+            raise CommandError(t.user_not_found)
 
-    await reply(ctx, embed=server_embed)
+        server_embed = Embed(title=t.warn, description=t.kick_deleted_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
+        if await ModSettings.send_delete_user_message.get():
+            user_embed = Embed(title=t.kick, description=t.kick_deleted(kick.reason), colour=Colors.ModTools)
 
-@commands.group(aliases=["ban_edit"])
-@ModPermission.mute.check
-@guild_only()
-@docs(t.commands.edit_ban)
-async def edit_ban(self, ctx):
-    if ctx.invoked_subcommand is None:
-        raise UserInputError
+            try:
+                await user.send(embed=user_embed)
+            except (Forbidden, HTTPException):
+                server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
+                server_embed.colour = Colors.error
+
+        await reply(ctx, embed=server_embed)
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.kick,
+            title=t.log_kick_deleted,
+            member=user,
+            reason=kick.reason,
+        )
 
+    @commands.command()
+    @ModPermission.ban.check
+    @guild_only()
+    @docs(t.commands.ban)
+    async def ban(
+        self, ctx: Context, user: UserMemberConverter, time: DurationConverter, delete_days: int, *, reason: str
+    ):
+        time: Optional[int]
+        minutes = time
+
+        user: Union[Member, User]
+
+        if not ctx.guild.me.guild_permissions.ban_members:
+            raise CommandError(t.cannot_ban_permissions)
+
+        if len(reason) > 900:
+            raise CommandError(t.reason_too_long)
+        if not 0 <= delete_days <= 7:
+            raise CommandError(tg.invalid_duration)
+
+        if user == self.bot.user or await is_teamler(user):
+            raise UserCommandError(user, t.cannot_ban)
+        if isinstance(user, Member) and (user.top_role >= ctx.guild.me.top_role or user.id == ctx.guild.owner_id):
+            raise UserCommandError(user, t.cannot_ban)
+
+        active_bans: List[Ban] = await db.all(filter_by(Ban, active=True, member=user.id))
+        if active_bans:
+            raise UserCommandError(user, t.already_banned)
+
+        active_mutes: List[Mute] = await db.all(filter_by(Mute, active=True, member=user.id))
+        for mute in active_mutes:
+            await Mute.deactivate(mute.id, ctx.author.id, t.cancelled_by_ban)
+
+        attachments = ctx.message.attachments
+        evidence = attachments[0] if attachments else None
+        evidence_url = evidence.url if attachments else None
+
+        if not evidence:
+            if not await confirm_no_evidence(ctx):
+                return
 
-@edit_ban.command(name="reason", aliases=["r"])
-@docs(t.commands.edit_ban_reason)
-async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
-    ban = await get_and_compare_entry(Ban, ban_id, ctx.author)
+        user_embed = Embed(title=t.ban, colour=Colors.ModTools)
+        server_embed = Embed(title=t.ban, description=t.banned_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+
+        if active_mutes:
+            server_embed.description += f"\n\n{t.previously_muted}"
+
+        await Ban.create(
+            user.id,
+            str(user),
+            ctx.author.id,
+            await get_mod_level(ctx.author),
+            minutes if minutes is not None else -1,
+            reason,
+            evidence_url,
+        )
 
-    if len(reason) > 900:
-        raise CommandError(t.reason_too_long)
+        await invalidate_entry_cache()
+
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.ban,
+            title=t.log_banned,
+            member=user,
+            reason=reason,
+            duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
+            evidence=evidence,
+        )
 
-    conf_embed = Embed(
-        title=t.confirmation, description=t.confirm_ban_edit.reason(ban.reason, reason), color=Colors.ModTools
-    )
+        if minutes is not None:
+            user_embed.description = t.banned(ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason)
 
-    if not await confirm_action(ctx, conf_embed):
-        return
+        else:
+            user_embed.description = t.banned_inf(ctx.author.mention, ctx.guild.name, reason)
 
-    try:
-        user = await self.bot.fetch_user(ban.member)
-    except (NotFound, HTTPException):
-        raise CommandError(t.user_not_found)
+        try:
+            await user.send(embed=user_embed)
+        except (Forbidden, HTTPException):
+            server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
+            server_embed.colour = Colors.error
 
-    user_embed = Embed(title=t.ban, description=t.ban_edited.reason(ban.reason, reason), colour=Colors.ModTools)
-    server_embed = Embed(title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools)
-    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+        await ctx.guild.ban(user, delete_message_days=delete_days, reason=reason)
+        await revoke_verification(user)
 
-    await Ban.edit_reason(ban_id, ctx.author.id, await get_mod_level(ctx.author), reason)
+        await reply(ctx, embed=server_embed)
 
-    try:
-        await user.send(embed=user_embed)
-    except (Forbidden, HTTPException):
-        server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-        server_embed.colour = Colors.error
-    await reply(ctx, embed=server_embed)
-    await send_to_changelog_mod(
-        guild=ctx.guild, message=ctx.message, colour=Colors.ban, title=t.log_ban_edited, member=user, reason=reason
-    )
+    @commands.group(aliases=["ban_edit"])
+    @ModPermission.mute.check
+    @guild_only()
+    @docs(t.commands.edit_ban)
+    async def edit_ban(self, ctx):
+        if ctx.invoked_subcommand is None:
+            raise UserInputError
 
+    @edit_ban.command(name="reason", aliases=["r"])
+    @docs(t.commands.edit_ban_reason)
+    async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
+        ban = await get_and_compare_entry(Ban, ban_id, ctx.author)
 
-@edit_ban.command(name="duration", aliases=["d"])
-@docs(t.commands.edit_ban_duration)
-async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time: DurationConverter):
-    user: Union[Member, User]
-    time: Optional[int]
-    minutes = time
+        if len(reason) > 900:
+            raise CommandError(t.reason_too_long)
 
-    active_bans: List[Ban] = sorted(
-        await db.all(filter_by(Ban, active=True, member=user.id)), key=lambda active_ban: active_ban.timestamp
-    )
+        conf_embed = Embed(
+            title=t.confirmation, description=t.confirm_ban_edit.reason(ban.reason, reason), color=Colors.ModTools
+        )
 
-    if not active_bans:
-        raise CommandError(t.not_banned)
+        if not await confirm_action(ctx, conf_embed):
+            return
 
-    ban = active_bans[0]
+        try:
+            user = await self.bot.fetch_user(ban.member)
+        except (NotFound, HTTPException):
+            raise CommandError(t.user_not_found)
 
-    if not await compare_mod_level(ctx.author, ban.mod_level) or not ctx.author.id == ban.mod:
-        raise CommandError(tg.permission_denied)
+        user_embed = Embed(title=t.ban, description=t.ban_edited.reason(ban.reason, reason), colour=Colors.ModTools)
+        server_embed = Embed(title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-    if ban.minutes == minutes or (ban.minutes == -1 and minutes is None):
-        raise CommandError(t.already_banned)
+        await Ban.edit_reason(ban_id, ctx.author.id, await get_mod_level(ctx.author), reason)
 
-    conf_embed = Embed(title=t.confirmation, color=Colors.ModTools)
+        try:
+            await user.send(embed=user_embed)
+        except (Forbidden, HTTPException):
+            server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
+            server_embed.colour = Colors.error
+        await reply(ctx, embed=server_embed)
+        await send_to_changelog_mod(
+            guild=ctx.guild, message=ctx.message, colour=Colors.ban, title=t.log_ban_edited, member=user, reason=reason
+        )
 
-    old_time = t.infinity if ban.minutes == -1 else time_to_units(ban.minutes)
+    @edit_ban.command(name="duration", aliases=["d"])
+    @docs(t.commands.edit_ban_duration)
+    async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time: DurationConverter):
+        user: Union[Member, User]
+        time: Optional[int]
+        minutes = time
 
-    if minutes is None:
-        conf_embed.description = t.confirm_ban_edit.duration(old_time, t.infinity)
-    else:
-        conf_embed.description = t.confirm_ban_edit.duration(old_time, time_to_units(minutes))
+        active_bans: List[Ban] = sorted(
+            await db.all(filter_by(Ban, active=True, member=user.id)), key=lambda active_ban: active_ban.timestamp
+        )
 
-    if not await confirm_action(ctx, conf_embed):
-        return
+        if not active_bans:
+            raise CommandError(t.not_banned)
 
-    for ban in active_bans[1:]:
-        await Ban.delete(ban.id)
-
-    user_embed = Embed(title=t.ban, colour=Colors.ModTools)
-    server_embed = Embed(title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools)
-    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-
-    await Ban.edit_duration(ban.id, ctx.author.id, await get_mod_level(ctx.author), minutes)
-
-    await invalidate_entry_cache()
-
-    user_embed.description = t.ban_edited.duration(
-        time_to_units(ban.minutes), t.infinity if minutes is None else time_to_units(minutes)
-    )
-    await send_to_changelog_mod(
-        guild=ctx.guild,
-        message=ctx.message,
-        colour=Colors.ban,
-        title=t.log_ban_edited,
-        member=user,
-        reason=ban.reason,
-        duration=t.log_field.infinity if minutes is None else time_to_units(minutes),
-    )
-
-    try:
-        await user.send(embed=user_embed)
-    except (Forbidden, HTTPException):
-        server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-        server_embed.colour = Colors.error
-    await reply(ctx, embed=server_embed)
-
-
-@commands.command(aliases=["ban_delete"])
-@ModPermission.ban.check
-@guild_only()
-@docs(t.commands.delete_ban)
-async def delete_ban(self, ctx: Context, ban_id: int):
-    ban = await get_and_compare_entry(Ban, ban_id, ctx.author)
-
-    conf_embed = Embed(
-        title=t.confirmation, description=t.confirm_ban_delete(ban.member_name, ban.id), color=Colors.ModTools
-    )
-
-    if not await confirm_action(ctx, conf_embed):
-        return
+        ban = active_bans[0]
 
-    active_bans: List[Ban] = await db.all(filter_by(Ban, active=True, member=ban.member))
+        if not await compare_mod_level(ctx.author, ban.mod_level) or not ctx.author.id == ban.mod:
+            raise CommandError(tg.permission_denied)
 
-    if len(active_bans) == 1 and ban in active_bans:
-        user = ctx.guild.get_member(ban.member)
-        if user is not None:
-            try:
-                await ctx.guild.unban(user, reason="Ban deleted")
-            except HTTPException:
-                pass
+        if ban.minutes == minutes or (ban.minutes == -1 and minutes is None):
+            raise CommandError(t.already_banned)
 
-    try:
-        user = await self.bot.fetch_user(ban.member)
-    except (NotFound, HTTPException):
-        raise CommandError(t.user_not_found)
+        conf_embed = Embed(title=t.confirmation, color=Colors.ModTools)
 
-    await Ban.delete(ban_id)
+        old_time = t.infinity if ban.minutes == -1 else time_to_units(ban.minutes)
 
-    await invalidate_entry_cache()
+        if minutes is None:
+            conf_embed.description = t.confirm_ban_edit.duration(old_time, t.infinity)
+        else:
+            conf_embed.description = t.confirm_ban_edit.duration(old_time, time_to_units(minutes))
 
-    server_embed = Embed(title=t.mute, description=t.ban_deleted_response, colour=Colors.ModTools)
+        if not await confirm_action(ctx, conf_embed):
+            return
 
-    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+        for ban in active_bans[1:]:
+            await Ban.delete(ban.id)
 
-    if await ModSettings.send_delete_user_message.get():
         user_embed = Embed(title=t.ban, colour=Colors.ModTools)
+        server_embed = Embed(title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-        if ban.minutes == -1:
-            user_embed.description = t.ban_deleted.inf(ban.reason)
-        else:
-            user_embed.description = t.ban_deleted.not_inf(time_to_units(ban.minutes), ban.reason)
+        await Ban.edit_duration(ban.id, ctx.author.id, await get_mod_level(ctx.author), minutes)
+
+        await invalidate_entry_cache()
+
+        user_embed.description = t.ban_edited.duration(
+            time_to_units(ban.minutes), t.infinity if minutes is None else time_to_units(minutes)
+        )
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.ban,
+            title=t.log_ban_edited,
+            member=user,
+            reason=ban.reason,
+            duration=t.log_field.infinity if minutes is None else time_to_units(minutes),
+        )
 
         try:
             await user.send(embed=user_embed)
         except (Forbidden, HTTPException):
             server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
             server_embed.colour = Colors.error
+        await reply(ctx, embed=server_embed)
 
-    await reply(ctx, embed=server_embed)
+    @commands.command(aliases=["ban_delete"])
+    @ModPermission.ban.check
+    @guild_only()
+    @docs(t.commands.delete_ban)
+    async def delete_ban(self, ctx: Context, ban_id: int):
+        ban = await get_and_compare_entry(Ban, ban_id, ctx.author)
 
-    await send_to_changelog_mod(
-        guild=ctx.guild,
-        message=ctx.message,
-        colour=Colors.ban,
-        title=t.log_ban_deleted,
-        member=user,
-        reason=ban.reason,
-        duration=t.log_field_infinity if ban.minutes == -1 else time_to_units(ban.minutes),
-    )
+        conf_embed = Embed(
+            title=t.confirmation, description=t.confirm_ban_delete(ban.member_name, ban.id), color=Colors.ModTools
+        )
 
+        if not await confirm_action(ctx, conf_embed):
+            return
 
-@commands.command()
-@ModPermission.ban.check
-@guild_only()
-@docs(t.commands.unban)
-async def unban(self, ctx: Context, user: UserMemberConverter, *, reason: str):
-    user: Union[Member, User]
+        active_bans: List[Ban] = await db.all(filter_by(Ban, active=True, member=ban.member))
 
-    if len(reason) > 900:
-        raise CommandError(t.reason_too_long)
+        if len(active_bans) == 1 and ban in active_bans:
+            user = ctx.guild.get_member(ban.member)
+            if user is not None:
+                try:
+                    await ctx.guild.unban(user, reason="Ban deleted")
+                except HTTPException:
+                    pass
 
-    if not ctx.guild.me.guild_permissions.ban_members:
-        raise CommandError(t.cannot_unban_permissions)
+        try:
+            user = await self.bot.fetch_user(ban.member)
+        except (NotFound, HTTPException):
+            raise CommandError(t.user_not_found)
 
-    was_banned = True
-    try:
-        await ctx.guild.unban(user, reason=reason)
-    except HTTPException:
-        was_banned = False
+        await Ban.delete(ban_id)
 
-    minutes = 0
-    async for ban in await db.stream(filter_by(Ban, active=True, member=user.id)):
-        if not await compare_mod_level(ctx.author, ban.mod_level) or not ctx.author.id == ban.mod:
-            raise CommandError(tg.permission_denied)
+        await invalidate_entry_cache()
 
-        await Ban.deactivate(ban.id, ctx.author.id, reason)
+        server_embed = Embed(title=t.mute, description=t.ban_deleted_response, colour=Colors.ModTools)
 
-        was_banned = True
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+
+        if await ModSettings.send_delete_user_message.get():
+            user_embed = Embed(title=t.ban, colour=Colors.ModTools)
 
-        if ban.minutes > minutes or ban.minutes == -1:
-            minutes = ban.minutes
-
-    if not was_banned:
-        raise UserCommandError(user, t.not_banned)
-
-    await invalidate_entry_cache()
-
-    server_embed = Embed(title=t.unban, description=t.unbanned_response, colour=Colors.ModTools)
-    server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-    await reply(ctx, embed=server_embed)
-    await send_to_changelog_mod(
-        guild=ctx.guild,
-        message=ctx.message,
-        colour=Colors.unban,
-        title=t.log_unbanned,
-        member=user,
-        reason=reason,
-        duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
-        mod=ctx.author,
-        original_reason=ban.reason,
-    )
+            if ban.minutes == -1:
+                user_embed.description = t.ban_deleted.inf(ban.reason)
+            else:
+                user_embed.description = t.ban_deleted.not_inf(time_to_units(ban.minutes), ban.reason)
+
+            try:
+                await user.send(embed=user_embed)
+            except (Forbidden, HTTPException):
+                server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
+                server_embed.colour = Colors.error
+
+        await reply(ctx, embed=server_embed)
+
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.ban,
+            title=t.log_ban_deleted,
+            member=user,
+            reason=ban.reason,
+            duration=t.log_field_infinity if ban.minutes == -1 else time_to_units(ban.minutes),
+        )
+
+    @commands.command()
+    @ModPermission.ban.check
+    @guild_only()
+    @docs(t.commands.unban)
+    async def unban(self, ctx: Context, user: UserMemberConverter, *, reason: str):
+        user: Union[Member, User]
+
+        if len(reason) > 900:
+            raise CommandError(t.reason_too_long)
+
+        if not ctx.guild.me.guild_permissions.ban_members:
+            raise CommandError(t.cannot_unban_permissions)
+
+        was_banned = True
+        try:
+            await ctx.guild.unban(user, reason=reason)
+        except HTTPException:
+            was_banned = False
+
+        minutes = 0
+        async for ban in await db.stream(filter_by(Ban, active=True, member=user.id)):
+            if not await compare_mod_level(ctx.author, ban.mod_level) or not ctx.author.id == ban.mod:
+                raise CommandError(tg.permission_denied)
+
+            await Ban.deactivate(ban.id, ctx.author.id, reason)
+
+            was_banned = True
+
+            if ban.minutes > minutes or ban.minutes == -1:
+                minutes = ban.minutes
+
+        if not was_banned:
+            raise UserCommandError(user, t.not_banned)
+
+        await invalidate_entry_cache()
+
+        server_embed = Embed(title=t.unban, description=t.unbanned_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+        await reply(ctx, embed=server_embed)
+        await send_to_changelog_mod(
+            guild=ctx.guild,
+            message=ctx.message,
+            colour=Colors.unban,
+            title=t.log_unbanned,
+            member=user,
+            reason=reason,
+            duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
+            mod=ctx.author,
+            original_reason=ban.reason,
+        )

From c5dc1feef5bccc62b1b82ca9fc54d3c6affd9f9d Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Sat, 16 Apr 2022 10:45:25 +0200
Subject: [PATCH 100/120] Fixed typing

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py    | 79 ++++++++++++++++++++--------------------
 moderation/mod/models.py | 44 +++++++++++-----------
 2 files changed, 61 insertions(+), 62 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 16058342a..4601b4956 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -1,8 +1,9 @@
 import re
+from asyncio import sleep
 from datetime import datetime, timedelta
-from dateutil.relativedelta import relativedelta
-from typing import Optional, Union, List, Tuple, Type
+from typing import List, Tuple, Type, TypeVar
 
+from dateutil.relativedelta import relativedelta
 from discord import (
     Role,
     Guild,
@@ -19,16 +20,15 @@
     TextChannel,
     Thread,
 )
-from discord.utils import utcnow
 from discord.ext import commands, tasks
 from discord.ext.commands import guild_only, Context, CommandError, Converter, BadArgument, UserInputError
-from asyncio import sleep
+from discord.utils import utcnow
 
 from PyDrocsid.cog import Cog
 from PyDrocsid.command import reply, UserCommandError, confirm, docs
 from PyDrocsid.config import Config
 from PyDrocsid.converter import UserMemberConverter
-from PyDrocsid.database import db, filter_by, db_wrapper, Base, select
+from PyDrocsid.database import db, filter_by, db_wrapper, Base as DBBase
 from PyDrocsid.environment import CACHE_TTL
 from PyDrocsid.redis import redis
 from PyDrocsid.settings import RoleSettings
@@ -51,10 +51,11 @@
 
 tg = t.g
 t = t.mod
+TBase = TypeVar("TBase", bound=DBBase)
 
 
 class DurationConverter(Converter):
-    async def convert(self, ctx, argument: str) -> Optional[int]:
+    async def convert(self, ctx, argument: str) -> int | None:
         if argument.lower() in ("inf", "perm", "permanent", "-1", "∞"):
             return None
         if (match := re.match(r"^(\d+w)?(\d+d)?(\d+h)?(\d+m)?$", argument)) is None:
@@ -74,7 +75,7 @@ async def convert(self, ctx, argument: str) -> Optional[int]:
 
 
 async def load_entries():
-    async def fill(db_model: Type[Base]):
+    async def fill(db_model: Type[TBase]):
         async with redis.pipeline() as pipe:
             await pipe.delete(entry_key := f"mod_entries:{db_model.__tablename__}")
 
@@ -102,7 +103,7 @@ async def invalidate_entry_cache():
     await redis.delete("mod_entries_loaded")
 
 
-def time_to_units(minutes: Union[int, float]) -> str:
+def time_to_units(minutes: int | float) -> str:
     _keys = ("years", "months", "days", "hours", "minutes")
 
     rd = relativedelta(
@@ -117,13 +118,13 @@ def get_func(key, value):
 
 
 async def get_mute_role(guild: Guild) -> Role:
-    mute_role: Optional[Role] = guild.get_role(await RoleSettings.get("mute"))
+    mute_role: Role | None = guild.get_role(await RoleSettings.get("mute"))
     if mute_role is None:
         await send_alert(guild, t.mute_role_not_set)
     return mute_role
 
 
-def show_evidence(evidence: Optional[str]) -> str:
+def show_evidence(evidence: str | None) -> str:
     return t.ulog.evidence(evidence) if evidence else ""
 
 
@@ -135,7 +136,7 @@ async def compare_mod_level(mod: Member, mod_level: int) -> bool:
     return await get_mod_level(mod) > mod_level or mod == mod.guild.owner
 
 
-async def get_and_compare_entry(entry_format: Type[Base], entry_id: int, mod: Member):
+async def get_and_compare_entry(entry_format: Type[TBase], entry_id: int, mod: Member) -> TBase:
     entry = await db.get(entry_format, id=entry_id)
     if entry is None:
         raise CommandError(getattr(t.not_found, entry_format.__tablename__))
@@ -168,16 +169,16 @@ async def confirm_no_evidence(ctx: Context):
 
 async def send_to_changelog_mod(
     guild: Guild,
-    message: Optional[Message],
+    message: Message | None,
     colour: int,
     title: str,
-    member: Union[Member, User, Tuple[int, str]],
+    member: Member | User | Tuple[int, str],
     reason: str,
     *,
-    duration: Optional[str] = None,
-    evidence: Optional[Attachment] = None,
-    mod: Optional[Union[Member, User]] = None,
-    original_reason: Optional[str] = None,
+    duration: str | None = None,
+    evidence: Attachment | None = None,
+    mod: Member | User | None = None,
+    original_reason: str | None = None,
 ):
     embed = Embed(title=title, colour=colour, timestamp=utcnow())
 
@@ -220,10 +221,10 @@ class ModCog(Cog, name="Mod Tools"):
 
     async def on_ready(self):
         guild: Guild = self.bot.guilds[0]
-        mute_role: Optional[Role] = guild.get_role(await RoleSettings.get("mute"))
+        mute_role: Role | None = guild.get_role(await RoleSettings.get("mute"))
         if mute_role is not None:
             async for mute in await db.stream(filter_by(Mute, active=True)):
-                member: Optional[Member] = guild.get_member(mute.member)
+                member: Member | None = guild.get_member(mute.member)
                 if member is not None:
                     await member.add_roles(mute_role)
 
@@ -265,7 +266,7 @@ async def mod_loop(self):
                     reason=t.log_unbanned_expired,
                 )
 
-        mute_role: Optional[Role] = guild.get_role(await RoleSettings.get("mute"))
+        mute_role: Role | None = guild.get_role(await RoleSettings.get("mute"))
         if mute_role is None:
             return
 
@@ -357,8 +358,8 @@ def wrap_time_entry(
             mod: int,
             reason: str,
             evidence: str,
-            minutes: Optional[int] = None,
-            entry_id: Optional[int] = None,
+            minutes: int | None = None,
+            entry_id: int | None = None,
         ) -> str:
             args = [f"<@{mod}>"]
 
@@ -380,9 +381,7 @@ def wrap_time_entry(
 
             return translation(*args)
 
-        def wrap_entry(
-            translation, user: int, reason: str, evidence: Optional[str], entry_id: Optional[int] = None
-        ) -> str:
+        def wrap_entry(translation, user: int, reason: str, evidence: str | None, entry_id: int | None = None) -> str:
             if entry_id:
                 return translation.id_on(f"<@{user}>", reason, entry_id, show_evidence(evidence))
             else:
@@ -496,7 +495,7 @@ def wrap_entry(
         return out
 
     async def on_member_join(self, member: Member):
-        mute_role: Optional[Role] = member.guild.get_role(await RoleSettings.get("mute"))
+        mute_role: Role | None = member.guild.get_role(await RoleSettings.get("mute"))
         if mute_role is None:
             return
 
@@ -552,7 +551,7 @@ async def on_member_ban(self, guild: Guild, member: Member):
     @guild_only()
     @ModPermission.modtools_write.check
     @docs(t.commands.send_delete_message)
-    async def send_delete_message(self, ctx: Context, send: Optional[bool] = None):
+    async def send_delete_message(self, ctx: Context, send: bool | None = None):
         embed = Embed(title=t.modtools, color=Colors.ModTools)
 
         if send is None:
@@ -568,7 +567,7 @@ async def send_delete_message(self, ctx: Context, send: Optional[bool] = None):
     @commands.command()
     @docs(t.commands.report)
     async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
-        user: Union[Member, User]
+        user: Member | User
 
         if len(reason) > 900:
             raise CommandError(t.reason_too_long)
@@ -617,7 +616,7 @@ async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
     @guild_only()
     @docs(t.commands.warn)
     async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
-        user: Union[Member, User]
+        user: Member | User
 
         if len(reason) > 900:
             raise CommandError(t.reason_too_long)
@@ -747,9 +746,9 @@ async def delete_warn(self, ctx: Context, warn_id: int):
     @guild_only()
     @docs(t.commands.mute)
     async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConverter, *, reason: str):
-        user: Union[Member, User]
+        user: Member | User
 
-        time: Optional[int]
+        time: int | None
         minutes = time
 
         if len(reason) > 900:
@@ -867,8 +866,8 @@ async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
     @edit_mute.command(name="duration", aliases=["d"])
     @docs(t.commands.edit_mute_duration)
     async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time: DurationConverter):
-        user: Union[Member, User]
-        time: Optional[int]
+        user: Member | User
+        time: int | None
         minutes = time
 
         active_mutes: List[Mute] = sorted(
@@ -994,7 +993,7 @@ async def delete_mute(self, ctx: Context, mute_id: int):
     @guild_only()
     @docs(t.commands.unmute)
     async def unmute(self, ctx: Context, user: UserMemberConverter, *, reason: str):
-        user: Union[Member, User]
+        user: Member | User
 
         if len(reason) > 900:
             raise CommandError(t.reason_too_long)
@@ -1187,10 +1186,10 @@ async def delete_kick(self, ctx: Context, kick_id: int):
     async def ban(
         self, ctx: Context, user: UserMemberConverter, time: DurationConverter, delete_days: int, *, reason: str
     ):
-        time: Optional[int]
+        time: int | None
         minutes = time
 
-        user: Union[Member, User]
+        user: Member | User
 
         if not ctx.guild.me.guild_permissions.ban_members:
             raise CommandError(t.cannot_ban_permissions)
@@ -1263,7 +1262,7 @@ async def ban(
             server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
             server_embed.colour = Colors.error
 
-        await ctx.guild.ban(user, delete_message_days=delete_days, reason=reason)
+        await ctx.guild.ban(user, reason=reason, delete_message_days=delete_days)
         await revoke_verification(user)
 
         await reply(ctx, embed=server_embed)
@@ -1315,8 +1314,8 @@ async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
     @edit_ban.command(name="duration", aliases=["d"])
     @docs(t.commands.edit_ban_duration)
     async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time: DurationConverter):
-        user: Union[Member, User]
-        time: Optional[int]
+        user: Member | User
+        time: int | None
         minutes = time
 
         active_bans: List[Ban] = sorted(
@@ -1445,7 +1444,7 @@ async def delete_ban(self, ctx: Context, ban_id: int):
     @guild_only()
     @docs(t.commands.unban)
     async def unban(self, ctx: Context, user: UserMemberConverter, *, reason: str):
-        user: Union[Member, User]
+        user: Member | User
 
         if len(reason) > 900:
             raise CommandError(t.reason_too_long)
diff --git a/moderation/mod/models.py b/moderation/mod/models.py
index 4934d576b..f668cd3d7 100644
--- a/moderation/mod/models.py
+++ b/moderation/mod/models.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Union, Optional, Type
+from typing import TYPE_CHECKING
 from datetime import datetime
 
 from sqlalchemy import Column, Integer, BigInteger, Text, Boolean
@@ -10,22 +10,22 @@
 from discord.utils import utcnow
 
 
-class ModBase:
-    id: Union[Column, int] = Column(Integer, primary_key=True, unique=True, autoincrement=True)
-    member: Union[Column, int] = Column(BigInteger)
-    member_name: Union[Column, str] = Column(Text)
-    timestamp: Union[Column, datetime] = Column(UTCDateTime)
-    reason: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
-    evidence: Union[Column, str] = Column(Text(collation="utf8mb4_bin"))
+class ModBase(Base if TYPE_CHECKING else object):
+    id: Column | int = Column(Integer, primary_key=True, unique=True, autoincrement=True)
+    member: Column | int = Column(BigInteger)
+    member_name: Column | str = Column(Text)
+    timestamp: Column | datetime = Column(UTCDateTime)
+    reason: Column | str = Column(Text(collation="utf8mb4_bin"))
+    evidence: Column | str = Column(Text(collation="utf8mb4_bin"))
 
 
 class Punishment(ModBase):
-    mod: Union[Column, int] = Column(BigInteger)
-    mod_level: Union[Column, int] = Column(Integer)
+    mod: Column | int = Column(BigInteger)
+    mod_level: Column | int = Column(Integer)
 
     @classmethod
     async def create(
-        cls, member: int, member_name: str, mod: int, mod_level: int, reason: str, evidence: Optional[str]
+        cls, member: int, member_name: str, mod: int | None, mod_level: int | None, reason: str | None, evidence: str | None
     ) -> Punishment:
         row = cls(
             member=member,
@@ -53,17 +53,17 @@ async def delete(cls, entry_id: int):
 
 
 class TimedPunishment(ModBase):
-    mod: Union[Column, int] = Column(BigInteger)
-    mod_level: Union[Column, int] = Column(Integer)
-    minutes: Union[Column, int] = Column(Integer)
-    active: Union[Column, bool] = Column(Boolean)
-    deactivation_timestamp: Union[Column, Optional[datetime]] = Column(UTCDateTime, nullable=True)
-    deactivate_mod: Union[Column, Optional[int]] = Column(BigInteger, nullable=True)
-    deactivate_reason: Union[Column, Optional[str]] = Column(Text(collation="utf8mb4_bin"), nullable=True)
+    mod: Column | int = Column(BigInteger)
+    mod_level: Column | int = Column(Integer)
+    minutes: Column | int = Column(Integer)
+    active: Column | bool = Column(Boolean)
+    deactivation_timestamp: Column | datetime | None = Column(UTCDateTime, nullable=True)
+    deactivate_mod: Column | int | None = Column(BigInteger, nullable=True)
+    deactivate_reason: Column | str | None = Column(Text(collation="utf8mb4_bin"), nullable=True)
 
     @classmethod
     async def create(
-        cls, member: int, member_name: str, mod: int, mod_level: int, minutes: int, reason: str, evidence: Optional[str]
+        cls, member: int, member_name: str, mod: int, mod_level: int, minutes: int, reason: str, evidence: str | None
     ) -> TimedPunishment:
         row = cls(
             member=member,
@@ -83,7 +83,7 @@ async def create(
         return row
 
     @classmethod
-    async def deactivate(cls, mute_id: int, deactivate_mod: int = None, reason: str = None) -> "TimedPunishment":
+    async def deactivate(cls, mute_id: int, deactivate_mod: int = None, reason: str = None) -> TimedPunishment:
         row: TimedPunishment = await db.get(cls, id=mute_id)
         row.active = False
         row.deactivation_timestamp = utcnow()
@@ -114,10 +114,10 @@ async def delete(cls, entry_id: int):
 class Report(ModBase, Base):
     __tablename__ = "report"
 
-    reporter: Union[Column, int] = Column(BigInteger)
+    reporter: Column | int = Column(BigInteger)
 
     @staticmethod
-    async def create(member: int, member_name: str, reporter: int, reason: str, evidence: Optional[str]) -> Report:
+    async def create(member: int, member_name: str, reporter: int, reason: str, evidence: str | None) -> Report:
         row = Report(
             member=member,
             member_name=member_name,

From 7a897a58535c815a4610dd57b1c711d8fd0b2069 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Sat, 16 Apr 2022 10:47:02 +0200
Subject: [PATCH 101/120] Improved code style

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/models.py | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/moderation/mod/models.py b/moderation/mod/models.py
index f668cd3d7..71519704c 100644
--- a/moderation/mod/models.py
+++ b/moderation/mod/models.py
@@ -25,7 +25,13 @@ class Punishment(ModBase):
 
     @classmethod
     async def create(
-        cls, member: int, member_name: str, mod: int | None, mod_level: int | None, reason: str | None, evidence: str | None
+        cls,
+        member: int,
+        member_name: str,
+        mod: int | None,
+        mod_level: int | None,
+        reason: str | None,
+        evidence: str | None,
     ) -> Punishment:
         row = cls(
             member=member,

From 3d9a2a7e1a300ad62aaba11fb7faf1aa63a81412 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Mon, 2 May 2022 21:07:49 +0200
Subject: [PATCH 102/120] Removed code duplicates

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py              | 889 +++++++++++------------------
 moderation/mod/translations/en.yml | 186 +++---
 2 files changed, 432 insertions(+), 643 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 4601b4956..fb78f55e6 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -1,7 +1,7 @@
 import re
 from asyncio import sleep
 from datetime import datetime, timedelta
-from typing import List, Tuple, Type, TypeVar
+from typing import List, Tuple, Type, TypeVar, Any, Callable, Awaitable
 
 from dateutil.relativedelta import relativedelta
 from discord import (
@@ -124,6 +124,14 @@ async def get_mute_role(guild: Guild) -> Role:
     return mute_role
 
 
+def extract_evidence(message: Message) -> Tuple[Attachment | None, str | None]:
+    attachments = message.attachments
+    evidence = attachments[0] if attachments else None
+    evidence_url = evidence.url if attachments else None
+
+    return evidence, evidence_url
+
+
 def show_evidence(evidence: str | None) -> str:
     return t.ulog.evidence(evidence) if evidence else ""
 
@@ -564,124 +572,83 @@ async def send_delete_message(self, ctx: Context, send: bool | None = None):
         await reply(ctx, embed=embed)
         await send_to_changelog(ctx.guild, t.configured_send_delete_message[send])
 
-    @commands.command()
-    @docs(t.commands.report)
-    async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
-        user: Member | User
-
-        if len(reason) > 900:
-            raise CommandError(t.reason_too_long)
-
-        if user == self.bot.user:
-            raise UserCommandError(user, t.cannot_report)
-        if user == ctx.author:
-            raise UserCommandError(user, t.no_self_report)
-
-        conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_report(user.mention, reason), color=Colors.ModTools
-        )
-
-        if not await confirm_action(ctx, conf_embed, t.report_confirmed, t.report_canceled):
-            return
-
-        attachments = ctx.message.attachments
-        evidence = attachments[0] if attachments else None
-        evidence_url = evidence.url if attachments else None
-
-        await Report.create(user.id, str(user), ctx.author.id, reason, evidence_url)
-        server_embed = Embed(title=t.report, description=t.reported_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-        await reply(ctx, embed=server_embed)
-
-        alert_embed = Embed(
-            title=t.report,
-            description=t.alert_report(ctx.author.mention, user.mention, reason),
-            color=Colors.report,
-            timestamp=utcnow(),
-        )
-
-        if type(ctx.channel) in (Thread, TextChannel):
-            alert_embed.add_field(
-                name=t.log_field.channel, value=t.jump_url(ctx.channel.mention, ctx.message.jump_url), inline=True
-            )
-        if evidence:
-            alert_embed.add_field(
-                name=t.log_field.evidence, value=t.image_link(evidence.filename, evidence_url), inline=True
-            )
-
-        await send_alert(self.bot.guilds[0], alert_embed)
-
-    @commands.command()
-    @ModPermission.warn.check
-    @guild_only()
-    @docs(t.commands.warn)
-    async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
+    async def handle_single(
+        self, ctx: Context, user: User | Member, reason: str, translation: Any, model: Type[TBase], color: int
+    ) -> bool:
         user: Member | User
 
         if len(reason) > 900:
             raise CommandError(t.reason_too_long)
 
         if user == self.bot.user:
-            raise UserCommandError(user, t.cannot_warn)
+            raise UserCommandError(user, translation.cannot)
 
-        attachments = ctx.message.attachments
-        evidence = attachments[0] if attachments else None
-        evidence_url = evidence.url if attachments else None
+        evidence, evidence_url = extract_evidence(ctx.message)
 
         if not evidence:
             if not await confirm_no_evidence(ctx):
-                return
+                return False
 
         user_embed = Embed(
-            title=t.warn, colour=Colors.ModTools, description=t.warned(ctx.author.mention, ctx.guild.name, reason)
+            title=translation.action,
+            colour=Colors.ModTools,
+            description=translation.done(ctx.author.mention, ctx.guild.name, reason),
         )
 
-        server_embed = Embed(title=t.warn, description=t.warned_response, colour=Colors.ModTools)
+        server_embed = Embed(title=translation.action, description=translation.response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
         try:
             await user.send(embed=user_embed)
         except (Forbidden, HTTPException):
             server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
             server_embed.colour = Colors.error
-        await Warn.create(user.id, str(user), ctx.author.id, await get_mod_level(ctx.author), reason, evidence_url)
+        await model.create(user.id, str(user), ctx.author.id, await get_mod_level(ctx.author), reason, evidence_url)
         await reply(ctx, embed=server_embed)
         await send_to_changelog_mod(
             guild=ctx.guild,
             message=ctx.message,
-            colour=Colors.warn,
-            title=t.log_warned,
+            colour=color,
+            title=translation.log,
             member=user,
             reason=reason,
             evidence=evidence,
         )
 
-    @commands.command(aliases=["warn_edit"])
-    @ModPermission.warn.check
-    @guild_only()
-    @docs(t.commands.edit_warn)
-    async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
-        warn = await get_and_compare_entry(Warn, warn_id, ctx.author)
+        return True
+
+    async def handle_edit_single(
+        self, ctx: Context, entry_id: int, reason: str, translation: Any, model: Type[TBase], color: int
+    ):
+        entry = await get_and_compare_entry(model, entry_id, ctx.author)
 
         if len(reason) > 900:
             raise CommandError(t.reason_too_long)
 
         conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_warn_edit(warn.reason, reason), color=Colors.ModTools
+            title=t.confirmation, description=translation.confirm_edit(entry.reason, reason), color=Colors.ModTools
         )
 
         if not await confirm_action(ctx, conf_embed):
             return
 
         try:
-            user = await self.bot.fetch_user(warn.member)
+            user = await self.bot.fetch_user(entry.member)
         except (NotFound, HTTPException):
             raise CommandError(t.user_not_found)
 
-        user_embed = Embed(title=t.warn, description=t.warn_edited(warn.reason, reason), colour=Colors.ModTools)
-        server_embed = Embed(title=t.warn, description=t.warn_edited_response, colour=Colors.ModTools)
+        user_embed = Embed(
+            title=translation.action,
+            description=translation.edited(entry.reason, reason),
+            colour=Colors.ModTools,
+        )
+        server_embed = Embed(
+            title=translation.action,
+            description=translation.edited_response,
+            colour=Colors.ModTools,
+        )
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-        await Warn.edit(warn_id, ctx.author.id, await get_mod_level(ctx.author), reason)
+        await model.edit(entry_id, ctx.author.id, await get_mod_level(ctx.author), reason)
 
         try:
             await user.send(embed=user_embed)
@@ -692,38 +659,40 @@ async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
         await send_to_changelog_mod(
             guild=ctx.guild,
             message=ctx.message,
-            colour=Colors.warn,
-            title=t.log_warn_edited,
+            colour=color,
+            title=translation.log_edited,
             member=user,
             reason=reason,
         )
 
-    @commands.command(aliases=["warn_delete"])
-    @ModPermission.warn.check
-    @guild_only()
-    @docs(t.commands.delete_warn)
-    async def delete_warn(self, ctx: Context, warn_id: int):
-        warn = await get_and_compare_entry(Warn, warn_id, ctx.author)
+    async def handle_delete_single(self, ctx: Context, entry_id: int, translation, model: Type[TBase], color: int):
+        entry = await get_and_compare_entry(model, entry_id, ctx.author)
 
         conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_warn_delete(warn.member_name, warn.id), color=Colors.ModTools
+            title=t.confirmation,
+            description=translation.confirm_delete(entry.member_name, entry.id),
+            color=Colors.ModTools,
         )
 
         if not await confirm_action(ctx, conf_embed):
             return
 
-        await Warn.delete(warn_id)
+        await model.delete(entry_id)
 
         try:
-            user = await self.bot.fetch_user(warn.member)
+            user = await self.bot.fetch_user(entry.member)
         except (NotFound, HTTPException):
             raise CommandError(t.user_not_found)
 
-        server_embed = Embed(title=t.warn, description=t.warn_deleted_response, colour=Colors.ModTools)
+        server_embed = Embed(title=translation.action, description=translation.deleted_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
         if await ModSettings.send_delete_user_message.get():
-            user_embed = Embed(title=t.warn, description=t.warn_deleted(warn.reason), colour=Colors.ModTools)
+            user_embed = Embed(
+                title=translation.action,
+                description=translation.deleted(entry.reason),
+                colour=Colors.ModTools,
+            )
 
             try:
                 await user.send(embed=user_embed)
@@ -735,50 +704,43 @@ async def delete_warn(self, ctx: Context, warn_id: int):
         await send_to_changelog_mod(
             guild=ctx.guild,
             message=ctx.message,
-            colour=Colors.warn,
-            title=t.log_warn_deleted,
+            colour=color,
+            title=translation.log_deleted,
             member=user,
-            reason=warn.reason,
+            reason=entry.reason,
         )
 
-    @commands.command()
-    @ModPermission.mute.check
-    @guild_only()
-    @docs(t.commands.mute)
-    async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConverter, *, reason: str):
-        user: Member | User
-
+    async def handle_timed(
+        self,
+        ctx: Context,
+        user: Member | User,
+        time: int | None,
+        reason: str,
+        translation,
+        model: Type[TBase],
+        color: int,
+        embed_addition: str,
+    ) -> bool:
         time: int | None
         minutes = time
 
         if len(reason) > 900:
             raise CommandError(t.reason_too_long)
 
-        mute_role: Role = await get_mute_role(ctx.guild)
-
-        if user == self.bot.user or await is_teamler(user):
-            raise UserCommandError(user, t.cannot_mute)
-
-        if isinstance(user, Member):
-            await user.add_roles(mute_role)
-            await user.move_to(None)
-
-        if await db.exists(filter_by(Mute, active=True, member=user.id)):
-            raise UserCommandError(user, t.already_muted)
+        if await db.exists(filter_by(model, active=True, member=user.id)):
+            raise UserCommandError(user, translation.already_done)
 
-        attachments = ctx.message.attachments
-        evidence = attachments[0] if attachments else None
-        evidence_url = evidence.url if attachments else None
+        evidence, evidence_url = extract_evidence(ctx.message)
 
         if not evidence:
             if not await confirm_no_evidence(ctx):
-                return
+                return False
 
-        user_embed = Embed(title=t.mute, colour=Colors.ModTools)
-        server_embed = Embed(title=t.mute, description=t.muted_response, colour=Colors.ModTools)
+        user_embed = Embed(title=translation.action, colour=Colors.ModTools)
+        server_embed = Embed(title=translation.action, description=translation.response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-        await Mute.create(
+        await model.create(
             user.id,
             str(user),
             ctx.author.id,
@@ -793,8 +755,8 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
         await send_to_changelog_mod(
             guild=ctx.guild,
             message=ctx.message,
-            colour=Colors.mute,
-            title=t.log_muted,
+            colour=color,
+            title=translation.log,
             member=user,
             reason=reason,
             duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
@@ -802,9 +764,16 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
         )
 
         if minutes is not None:
-            user_embed.description = t.muted(ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason)
+            user_embed.description = translation.done(
+                ctx.author.mention,
+                ctx.guild.name,
+                time_to_units(minutes),
+                reason,
+            )
         else:
-            user_embed.description = t.muted_inf(ctx.author.mention, ctx.guild.name, reason)
+            user_embed.description = translation.done_inf(ctx.author.mention, ctx.guild.name, reason)
+
+        server_embed.description = f"{server_embed.description}{embed_addition}"
 
         try:
             await user.send(embed=user_embed)
@@ -814,39 +783,39 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
 
         await reply(ctx, embed=server_embed)
 
-    @commands.group(aliases=["mute_edit"])
-    @ModPermission.mute.check
-    @guild_only()
-    @docs(t.commands.edit_mute)
-    async def edit_mute(self, ctx):
-        if ctx.invoked_subcommand is None:
-            raise UserInputError
+        return True
 
-    @edit_mute.command(name="reason", aliases=["r"])
-    @docs(t.commands.edit_mute_reason)
-    async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
-        mute = await get_and_compare_entry(Mute, mute_id, ctx.author)
+    async def handle_edit_timed_reason(
+        self, ctx: Context, entry_id: int, reason: str, translation: Any, model: Type[TBase], color: int
+    ):
+        entry = await get_and_compare_entry(model, entry_id, ctx.author)
 
         if len(reason) > 900:
             raise CommandError(t.reason_too_long)
 
         conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_mute_edit.reason(mute.reason, reason), color=Colors.ModTools
+            title=t.confirmation,
+            description=translation.confirm_edit.reason(entry.reason, reason),
+            color=Colors.ModTools,
         )
 
         if not await confirm_action(ctx, conf_embed):
             return
 
         try:
-            user = await self.bot.fetch_user(mute.member)
+            user = await self.bot.fetch_user(entry.member)
         except (NotFound, HTTPException):
             raise CommandError(t.user_not_found)
 
-        user_embed = Embed(title=t.mute, description=t.mute_edited.reason(mute.reason, reason), colour=Colors.ModTools)
-        server_embed = Embed(title=t.mute, description=t.mute_edited_response, colour=Colors.ModTools)
+        user_embed = Embed(
+            title=translation.action,
+            description=translation.edited.reason(entry.reason, reason),
+            colour=Colors.ModTools,
+        )
+        server_embed = Embed(title=translation.action, description=translation.edited_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-        await Mute.edit_reason(mute_id, ctx.author.id, await get_mod_level(ctx.author), reason)
+        await model.edit_reason(entry_id, ctx.author.id, await get_mod_level(ctx.author), reason)
 
         try:
             await user.send(embed=user_embed)
@@ -857,67 +826,73 @@ async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
         await send_to_changelog_mod(
             guild=ctx.guild,
             message=ctx.message,
-            colour=Colors.mute,
-            title=t.log_mute_edited,
+            colour=color,
+            title=translation.log_edited,
             member=user,
             reason=reason,
         )
 
-    @edit_mute.command(name="duration", aliases=["d"])
-    @docs(t.commands.edit_mute_duration)
-    async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time: DurationConverter):
+    async def handle_edit_timed_duration(
+        self,
+        ctx: Context,
+        user: User | Member,
+        time: int | None,
+        translation: Any,
+        model: Type[TBase],
+        color: int,
+    ):
         user: Member | User
         time: int | None
         minutes = time
 
-        active_mutes: List[Mute] = sorted(
-            await db.all(filter_by(Mute, active=True, member=user.id)), key=lambda active_mute: active_mute.timestamp
+        active_entries: List[TBase] = sorted(
+            await db.all(filter_by(model, active=True, member=user.id)), key=lambda active_entry: active_entry.timestamp
         )
 
-        if not active_mutes:
-            raise CommandError(t.not_muted)
+        if not active_entries:
+            raise CommandError(translation.not_done)
 
-        mute = active_mutes[0]
+        entry = active_entries[0]
 
-        if not await compare_mod_level(ctx.author, mute.mod_level) or not ctx.author.id == mute.mod:
+        if not await compare_mod_level(ctx.author, entry.mod_level) or not ctx.author.id == entry.mod:
             raise CommandError(tg.permission_denied)
 
-        if mute.minutes == minutes or (mute.minutes == -1 and minutes is None):
-            raise CommandError(t.already_muted)
+        if entry.minutes == minutes or (entry.minutes == -1 and minutes is None):
+            raise CommandError(translation.already_done)
 
         conf_embed = Embed(title=t.confirmation, color=Colors.ModTools)
 
-        old_time = t.infinity if mute.minutes == -1 else time_to_units(mute.minutes)
+        old_time = t.infinity if entry.minutes == -1 else time_to_units(entry.minutes)
 
         if minutes is None:
-            conf_embed.description = t.confirm_mute_edit.duration(old_time, t.infinity)
+            conf_embed.description = translation.confirm_edit.duration(old_time, t.infinity)
         else:
-            conf_embed.description = t.confirm_mute_edit.duration(old_time, time_to_units(minutes))
+            conf_embed.description = translation.confirm_edit.duration(old_time, time_to_units(minutes))
 
         if not await confirm_action(ctx, conf_embed):
             return
 
-        for active_mute in active_mutes[1:]:
-            await Mute.delete(active_mute.id)
+        for active_entry in active_entries[1:]:
+            await model.delete(active_entry.id)
 
-        user_embed = Embed(title=t.mute, colour=Colors.ModTools)
-        server_embed = Embed(title=t.mute, description=t.mute_edited_response, colour=Colors.ModTools)
+        user_embed = Embed(title=translation.action, colour=Colors.ModTools)
+        server_embed = Embed(title=translation.action, description=translation.edited_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-        await Mute.edit_duration(mute.id, ctx.author.id, await get_mod_level(ctx.author), minutes)
+        await model.edit_duration(entry.id, ctx.author.id, await get_mod_level(ctx.author), minutes)
 
         await invalidate_entry_cache()
 
-        user_embed.description = t.mute_edited.duration(
-            time_to_units(mute.minutes), t.infinity if minutes is None else time_to_units(minutes)
+        user_embed.description = translation.edited.duration(
+            time_to_units(entry.minutes), t.infinity if minutes is None else time_to_units(minutes)
         )
         await send_to_changelog_mod(
             guild=ctx.guild,
             message=ctx.message,
-            colour=Colors.mute,
-            title=t.log_mute_edited,
+            colour=color,
+            title=translation.log_edited,
             member=user,
-            reason=Mute.reason,
+            reason=entry.reason,
             duration=t.log_field.infinity if minutes is None else time_to_units(minutes),
         )
 
@@ -928,47 +903,39 @@ async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time
             server_embed.colour = Colors.error
         await reply(ctx, embed=server_embed)
 
-    @commands.command(aliases=["mute_delete"])
-    @ModPermission.mute.check
-    @guild_only()
-    @docs(t.commands.delete_mute)
-    async def delete_mute(self, ctx: Context, mute_id: int):
-        mute = await get_and_compare_entry(Mute, mute_id, ctx.author)
+    async def handle_delete_timed(
+        self, ctx: Context, entry_id: int, translation: Any, model: Type[TBase], color: int
+    ) -> TBase | None:
+        entry = await get_and_compare_entry(model, entry_id, ctx.author)
 
         conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_mute_delete(mute.member_name, mute.id), color=Colors.ModTools
+            title=t.confirmation,
+            description=translation.confirm_delete(entry.member_name, entry.id),
+            color=Colors.ModTools,
         )
 
         if not await confirm_action(ctx, conf_embed):
             return
 
-        active_mutes: List[Mute] = await db.all(filter_by(Mute, active=True, member=mute.member))
-
-        if len(active_mutes) == 1 and mute in active_mutes:
-            user = ctx.guild.get_member(mute.member)
-            if user is not None:
-                if (mute_role := await get_mute_role(ctx.guild)) in user.roles:
-                    await user.remove_roles(mute_role)
-
         try:
-            user = await self.bot.fetch_user(mute.member)
+            user = await self.bot.fetch_user(entry.member)
         except (NotFound, HTTPException):
             raise CommandError(t.user_not_found)
 
-        await Mute.delete(mute_id)
+        await model.delete(entry_id)
 
         await invalidate_entry_cache()
 
-        server_embed = Embed(title=t.mute, description=t.mute_deleted_response, colour=Colors.ModTools)
+        server_embed = Embed(title=translation.action, description=translation.deleted_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
         if await ModSettings.send_delete_user_message.get():
-            user_embed = Embed(title=t.warn, colour=Colors.ModTools)
+            user_embed = Embed(title=translation.action, colour=Colors.ModTools)
 
-            if mute.minutes == -1:
-                user_embed.description = t.mute_deleted.inf(mute.reason)
+            if entry.minutes == -1:
+                user_embed.description = translation.deleted.inf(entry.reason)
             else:
-                user_embed.description = t.mute_deleted.not_inf(time_to_units(mute.minutes), mute.reason)
+                user_embed.description = translation.deleted.not_inf(time_to_units(entry.minutes), entry.reason)
 
             try:
                 await user.send(embed=user_embed)
@@ -981,203 +948,244 @@ async def delete_mute(self, ctx: Context, mute_id: int):
         await send_to_changelog_mod(
             guild=ctx.guild,
             message=ctx.message,
-            colour=Colors.mute,
-            title=t.log_mute_deleted,
+            colour=color,
+            title=translation.log_deleted,
             member=user,
-            reason=mute.reason,
-            duration=t.log_field_infinity if mute.minutes == -1 else time_to_units(mute.minutes),
+            reason=entry.reason,
+            duration=t.log_field_infinity if entry.minutes == -1 else time_to_units(entry.minutes),
         )
 
-    @commands.command()
-    @ModPermission.mute.check
-    @guild_only()
-    @docs(t.commands.unmute)
-    async def unmute(self, ctx: Context, user: UserMemberConverter, *, reason: str):
+        return entry
+
+    async def handle_undo_timed(
+        self,
+        ctx: Context,
+        user: User | Member,
+        reason: str,
+        translation: Any,
+        model: Type[TBase],
+        color: int,
+        undo_function: Callable[[Context, Member | User], Awaitable[bool]],
+    ):
         user: Member | User
 
         if len(reason) > 900:
             raise CommandError(t.reason_too_long)
 
-        mute_role: Role = await get_mute_role(ctx.guild)
-
-        was_muted = False
-        if isinstance(user, Member) and mute_role in user.roles:
-            was_muted = True
-            await user.remove_roles(mute_role)
+        was_done = await undo_function(ctx, user)
 
         minutes = 0
-        async for mute in await db.stream(filter_by(Mute, active=True, member=user.id)):
-            if not await compare_mod_level(ctx.author, mute.mod_level) or not ctx.author.id == mute.mod:
+        async for entry in await db.stream(filter_by(model, active=True, member=user.id)):
+            if not await compare_mod_level(ctx.author, entry.mod_level) or not ctx.author.id == entry.mod:
                 raise CommandError(tg.permission_denied)
 
-            await Mute.deactivate(mute.id, ctx.author.id, reason)
+            await model.deactivate(entry.id, ctx.author.id, reason)
 
-            was_muted = True
+            was_done = True
 
-            if mute.minutes > minutes or mute.minutes == -1:
-                minutes = mute.minutes
+            if entry.minutes > minutes or entry.minutes == -1:
+                minutes = entry.minutes
 
-        if not was_muted:
+        if not was_done:
             raise UserCommandError(user, t.not_muted)
 
         await invalidate_entry_cache()
 
-        server_embed = Embed(title=t.unmute, description=t.unmuted_response, colour=Colors.ModTools)
+        server_embed = Embed(title=translation.undo, description=translation.undo_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
         await reply(ctx, embed=server_embed)
+
         await send_to_changelog_mod(
             guild=ctx.guild,
             message=ctx.message,
-            colour=Colors.unmute,
-            title=t.log_unmuted,
+            colour=color,
+            title=translation.log_undo,
             member=user,
             reason=reason,
             duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
             mod=ctx.author,
-            original_reason=mute.reason,
+            original_reason=entry.reason,
         )
 
     @commands.command()
-    @ModPermission.kick.check
-    @guild_only()
-    @docs(t.commands.kick)
-    async def kick(self, ctx: Context, member: Member, *, reason: str):
+    @docs(t.commands.report)
+    async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
+        user: Member | User
+
         if len(reason) > 900:
             raise CommandError(t.reason_too_long)
 
-        if member == self.bot.user or await is_teamler(member):
-            raise UserCommandError(member, t.cannot_kick)
+        if user == self.bot.user:
+            raise UserCommandError(user, t.cannot_report)
+        if user == ctx.author:
+            raise UserCommandError(user, t.no_self_report)
 
-        if not ctx.guild.me.guild_permissions.kick_members:
-            raise CommandError(t.cannot_kick_permissions)
+        conf_embed = Embed(
+            title=t.confirmation, description=t.confirm_report(user.mention, reason), color=Colors.ModTools
+        )
 
-        if member.top_role >= ctx.guild.me.top_role or member.id == ctx.guild.owner_id:
-            raise UserCommandError(member, t.cannot_kick)
+        if not await confirm_action(ctx, conf_embed, t.report_confirmed, t.report_canceled):
+            return
 
         attachments = ctx.message.attachments
         evidence = attachments[0] if attachments else None
         evidence_url = evidence.url if attachments else None
 
-        if not evidence:
-            if not await confirm_no_evidence(ctx):
-                return
+        await Report.create(user.id, str(user), ctx.author.id, reason, evidence_url)
+        server_embed = Embed(title=t.report, description=t.reported_response, colour=Colors.ModTools)
+        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+        await reply(ctx, embed=server_embed)
 
-        await Kick.create(member.id, str(member), ctx.author.id, await get_mod_level(ctx.author), reason, evidence_url)
-        await send_to_changelog_mod(
-            guild=ctx.guild,
-            message=ctx.message,
-            colour=Colors.kick,
-            title=t.log_kicked,
-            member=member,
-            reason=reason,
-            evidence=evidence,
+        alert_embed = Embed(
+            title=t.report,
+            description=t.alert_report(ctx.author.mention, user.mention, reason),
+            color=Colors.report,
+            timestamp=utcnow(),
         )
 
-        user_embed = Embed(
-            title=t.kick,
-            colour=Colors.ModTools,
-            description=t.kicked(ctx.author.mention, ctx.guild.name, reason),
-        )
+        if type(ctx.channel) in (Thread, TextChannel):
+            alert_embed.add_field(
+                name=t.log_field.channel, value=t.jump_url(ctx.channel.mention, ctx.message.jump_url), inline=True
+            )
+        if evidence:
+            alert_embed.add_field(
+                name=t.log_field.evidence, value=t.image_link(evidence.filename, evidence_url), inline=True
+            )
 
-        server_embed = Embed(title=t.kick, description=t.kicked_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(member), icon_url=member.display_avatar.url)
+        await send_alert(self.bot.guilds[0], alert_embed)
 
-        try:
-            await member.send(embed=user_embed)
-        except (Forbidden, HTTPException):
-            server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-            server_embed.colour = Colors.error
+    @commands.command()
+    @ModPermission.warn.check
+    @guild_only()
+    @docs(t.commands.warn)
+    async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
+        user: User | Member
 
-        await member.kick(reason=reason)
-        await revoke_verification(member)
+        await self.handle_single(ctx, user, reason, t.warn, Warn, Colors.warn)
 
-        await reply(ctx, embed=server_embed)
+    @commands.command(aliases=["warn_edit"])
+    @ModPermission.warn.check
+    @guild_only()
+    @docs(t.commands.edit_warn)
+    async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
+        await self.handle_edit_single(ctx, warn_id, reason, t.warn, Warn, Colors.warn)
 
-    @commands.command(aliases=["kick_edit"])
-    @ModPermission.kick.check
+    @commands.command(aliases=["warn_delete"])
+    @ModPermission.warn.check
     @guild_only()
-    @docs(t.commands.edit_kick)
-    async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
-        kick = await get_and_compare_entry(Kick, kick_id, ctx.author)
+    @docs(t.commands.delete_warn)
+    async def delete_warn(self, ctx: Context, warn_id: int):
+        await self.handle_delete_single(ctx, warn_id, t.warn, Warn, Colors.warn)
 
-        if len(reason) > 900:
-            raise CommandError(t.reason_too_long)
+    @commands.command()
+    @ModPermission.mute.check
+    @guild_only()
+    @docs(t.commands.mute)
+    async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConverter, *, reason: str):
+        user: Member | User
+        time: int | None
 
-        conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_kick_edit(kick.reason, reason), color=Colors.ModTools
-        )
+        if user == self.bot.user or await is_teamler(user):
+            raise UserCommandError(user, t.mute.cannot)
 
-        if not await confirm_action(ctx, conf_embed):
+        if not await self.handle_timed(ctx, user, time, reason, t.mute, Mute, Colors.mute, ""):
             return
 
-        try:
-            user = await self.bot.fetch_user(kick.member)
-        except (NotFound, HTTPException):
-            raise CommandError(t.user_not_found)
+        mute_role: Role = await get_mute_role(ctx.guild)
 
-        user_embed = Embed(title=t.kick, description=t.kick_edited(kick.reason, reason), colour=Colors.ModTools)
-        server_embed = Embed(title=t.kick, description=t.kick_edited_reponse, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+        if isinstance(user, Member):
+            await user.add_roles(mute_role)
+            await user.move_to(None)
 
-        await Kick.edit(kick_id, ctx.author.id, await get_mod_level(ctx.author), reason)
+    @commands.group(aliases=["mute_edit"])
+    @ModPermission.mute.check
+    @guild_only()
+    @docs(t.commands.edit_mute)
+    async def edit_mute(self, ctx):
+        if ctx.invoked_subcommand is None:
+            raise UserInputError
 
-        try:
-            await user.send(embed=user_embed)
-        except (Forbidden, HTTPException):
-            server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-            server_embed.colour = Colors.error
-        await reply(ctx, embed=server_embed)
-        await send_to_changelog_mod(
-            guild=ctx.guild,
-            message=ctx.message,
-            colour=Colors.kick,
-            title=t.log_kick_edited,
-            member=user,
-            reason=reason,
-        )
+    @edit_mute.command(name="reason", aliases=["r"])
+    @docs(t.commands.edit_mute_reason)
+    async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
+        await self.handle_edit_timed_reason(ctx, mute_id, reason, t.mute, Mute, Colors.mute)
 
-    @commands.command(aliases=["kick_delete"])
-    @ModPermission.kick.check
-    @guild_only()
-    @docs(t.commands.delete_kick)
-    async def delete_kick(self, ctx: Context, kick_id: int):
-        kick = await get_and_compare_entry(Kick, kick_id, ctx.author)
+    @edit_mute.command(name="duration", aliases=["d"])
+    @docs(t.commands.edit_mute_duration)
+    async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time: DurationConverter):
+        user: User | Member
+        time: int | None
 
-        conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_kick_delete(kick.member_name, kick.id), color=Colors.ModTools
-        )
+        await self.handle_edit_timed_duration(ctx, user, time, t.mute, Mute, Colors.mute)
 
-        if not await confirm_action(ctx, conf_embed):
+    @commands.command(aliases=["mute_delete"])
+    @ModPermission.mute.check
+    @guild_only()
+    @docs(t.commands.delete_mute)
+    async def delete_mute(self, ctx: Context, mute_id: int):
+        if not (mute := await self.handle_delete_timed(ctx, mute_id, t.mute, Mute, Colors.mute)):
             return
 
-        await Kick.delete(kick_id)
+        active_mutes: List[Mute] = await db.all(filter_by(Mute, active=True, member=mute.member))
 
-        try:
-            user = await self.bot.fetch_user(kick.member)
-        except (NotFound, HTTPException):
-            raise CommandError(t.user_not_found)
+        if len(active_mutes) == 1 and mute in active_mutes:
+            user = ctx.guild.get_member(mute.member)
+            if user is not None:
+                if (mute_role := await get_mute_role(ctx.guild)) in user.roles:
+                    await user.remove_roles(mute_role)
 
-        server_embed = Embed(title=t.warn, description=t.kick_deleted_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
+    @commands.command()
+    @ModPermission.mute.check
+    @guild_only()
+    @docs(t.commands.unmute)
+    async def unmute(self, ctx: Context, user: UserMemberConverter, *, reason: str):
+        user: User | Member
 
-        if await ModSettings.send_delete_user_message.get():
-            user_embed = Embed(title=t.kick, description=t.kick_deleted(kick.reason), colour=Colors.ModTools)
+        async def unmute_inner(context: Context, muted_user: Member | User) -> bool:
+            mute_role: Role = await get_mute_role(context.guild)
 
-            try:
-                await user.send(embed=user_embed)
-            except (Forbidden, HTTPException):
-                server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-                server_embed.colour = Colors.error
+            was_muted = False
+            if isinstance(muted_user, Member) and mute_role in muted_user.roles:
+                was_muted = True
+                await muted_user.remove_roles(mute_role)
 
-        await reply(ctx, embed=server_embed)
-        await send_to_changelog_mod(
-            guild=ctx.guild,
-            message=ctx.message,
-            colour=Colors.kick,
-            title=t.log_kick_deleted,
-            member=user,
-            reason=kick.reason,
-        )
+            return was_muted
+
+        await self.handle_undo_timed(ctx, user, reason, t.mute, Mute, Colors.unmute, unmute_inner)
+
+    @commands.command()
+    @ModPermission.kick.check
+    @guild_only()
+    @docs(t.commands.kick)
+    async def kick(self, ctx: Context, member: Member, *, reason: str):
+        if member == self.bot.user or await is_teamler(member):
+            raise UserCommandError(member, t.cannot_kick)
+
+        if not ctx.guild.me.guild_permissions.kick_members:
+            raise CommandError(t.cannot_kick_permissions)
+
+        if member.top_role >= ctx.guild.me.top_role or member.id == ctx.guild.owner_id:
+            raise UserCommandError(member, t.cannot_kick)
+
+        if not self.handle_single(ctx, member, reason, t.kick, Kick, Colors.kick):
+            return
+
+        await member.kick(reason=reason)
+        await revoke_verification(member)
+
+    @commands.command(aliases=["kick_edit"])
+    @ModPermission.kick.check
+    @guild_only()
+    @docs(t.commands.edit_kick)
+    async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
+        await self.handle_edit_single(ctx, kick_id, reason, t.kick, Kick, Colors.kick)
+
+    @commands.command(aliases=["kick_delete"])
+    @ModPermission.kick.check
+    @guild_only()
+    @docs(t.commands.delete_kick)
+    async def delete_kick(self, ctx: Context, kick_id: int):
+        await self.handle_delete_single(ctx, kick_id, t.kick, Kick, Colors.kick)
 
     @commands.command()
     @ModPermission.ban.check
@@ -1186,87 +1194,31 @@ async def delete_kick(self, ctx: Context, kick_id: int):
     async def ban(
         self, ctx: Context, user: UserMemberConverter, time: DurationConverter, delete_days: int, *, reason: str
     ):
-        time: int | None
-        minutes = time
-
         user: Member | User
+        time: int | None
 
         if not ctx.guild.me.guild_permissions.ban_members:
             raise CommandError(t.cannot_ban_permissions)
 
-        if len(reason) > 900:
-            raise CommandError(t.reason_too_long)
         if not 0 <= delete_days <= 7:
             raise CommandError(tg.invalid_duration)
 
-        if user == self.bot.user or await is_teamler(user):
-            raise UserCommandError(user, t.cannot_ban)
         if isinstance(user, Member) and (user.top_role >= ctx.guild.me.top_role or user.id == ctx.guild.owner_id):
             raise UserCommandError(user, t.cannot_ban)
 
-        active_bans: List[Ban] = await db.all(filter_by(Ban, active=True, member=user.id))
-        if active_bans:
-            raise UserCommandError(user, t.already_banned)
-
         active_mutes: List[Mute] = await db.all(filter_by(Mute, active=True, member=user.id))
-        for mute in active_mutes:
-            await Mute.deactivate(mute.id, ctx.author.id, t.cancelled_by_ban)
-
-        attachments = ctx.message.attachments
-        evidence = attachments[0] if attachments else None
-        evidence_url = evidence.url if attachments else None
 
-        if not evidence:
-            if not await confirm_no_evidence(ctx):
-                return
-
-        user_embed = Embed(title=t.ban, colour=Colors.ModTools)
-        server_embed = Embed(title=t.ban, description=t.banned_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-
-        if active_mutes:
-            server_embed.description += f"\n\n{t.previously_muted}"
-
-        await Ban.create(
-            user.id,
-            str(user),
-            ctx.author.id,
-            await get_mod_level(ctx.author),
-            minutes if minutes is not None else -1,
-            reason,
-            evidence_url,
-        )
-
-        await invalidate_entry_cache()
-
-        await send_to_changelog_mod(
-            guild=ctx.guild,
-            message=ctx.message,
-            colour=Colors.ban,
-            title=t.log_banned,
-            member=user,
-            reason=reason,
-            duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
-            evidence=evidence,
-        )
-
-        if minutes is not None:
-            user_embed.description = t.banned(ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason)
-
-        else:
-            user_embed.description = t.banned_inf(ctx.author.mention, ctx.guild.name, reason)
+        if not await self.handle_timed(
+            ctx, user, time, reason, t.ban, Ban, Colors.ban, f"\n\n{t.ban.previously_muted}" if active_mutes else ""
+        ):
+            return
 
-        try:
-            await user.send(embed=user_embed)
-        except (Forbidden, HTTPException):
-            server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-            server_embed.colour = Colors.error
+        for mute in active_mutes:
+            await Mute.deactivate(mute.id, ctx.author.id, t.cancelled_by_ban)
 
         await ctx.guild.ban(user, reason=reason, delete_message_days=delete_days)
         await revoke_verification(user)
 
-        await reply(ctx, embed=server_embed)
-
     @commands.group(aliases=["ban_edit"])
     @ModPermission.mute.check
     @guild_only()
@@ -1278,116 +1230,22 @@ async def edit_ban(self, ctx):
     @edit_ban.command(name="reason", aliases=["r"])
     @docs(t.commands.edit_ban_reason)
     async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
-        ban = await get_and_compare_entry(Ban, ban_id, ctx.author)
-
-        if len(reason) > 900:
-            raise CommandError(t.reason_too_long)
-
-        conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_ban_edit.reason(ban.reason, reason), color=Colors.ModTools
-        )
-
-        if not await confirm_action(ctx, conf_embed):
-            return
-
-        try:
-            user = await self.bot.fetch_user(ban.member)
-        except (NotFound, HTTPException):
-            raise CommandError(t.user_not_found)
-
-        user_embed = Embed(title=t.ban, description=t.ban_edited.reason(ban.reason, reason), colour=Colors.ModTools)
-        server_embed = Embed(title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-
-        await Ban.edit_reason(ban_id, ctx.author.id, await get_mod_level(ctx.author), reason)
-
-        try:
-            await user.send(embed=user_embed)
-        except (Forbidden, HTTPException):
-            server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-            server_embed.colour = Colors.error
-        await reply(ctx, embed=server_embed)
-        await send_to_changelog_mod(
-            guild=ctx.guild, message=ctx.message, colour=Colors.ban, title=t.log_ban_edited, member=user, reason=reason
-        )
+        await self.handle_edit_timed_reason(ctx, ban_id, reason, t.ban, Ban, Colors.ban)
 
     @edit_ban.command(name="duration", aliases=["d"])
     @docs(t.commands.edit_ban_duration)
     async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time: DurationConverter):
-        user: Member | User
+        user: User | Member
         time: int | None
-        minutes = time
-
-        active_bans: List[Ban] = sorted(
-            await db.all(filter_by(Ban, active=True, member=user.id)), key=lambda active_ban: active_ban.timestamp
-        )
-
-        if not active_bans:
-            raise CommandError(t.not_banned)
-
-        ban = active_bans[0]
-
-        if not await compare_mod_level(ctx.author, ban.mod_level) or not ctx.author.id == ban.mod:
-            raise CommandError(tg.permission_denied)
-
-        if ban.minutes == minutes or (ban.minutes == -1 and minutes is None):
-            raise CommandError(t.already_banned)
-
-        conf_embed = Embed(title=t.confirmation, color=Colors.ModTools)
-
-        old_time = t.infinity if ban.minutes == -1 else time_to_units(ban.minutes)
-
-        if minutes is None:
-            conf_embed.description = t.confirm_ban_edit.duration(old_time, t.infinity)
-        else:
-            conf_embed.description = t.confirm_ban_edit.duration(old_time, time_to_units(minutes))
-
-        if not await confirm_action(ctx, conf_embed):
-            return
-
-        for ban in active_bans[1:]:
-            await Ban.delete(ban.id)
-
-        user_embed = Embed(title=t.ban, colour=Colors.ModTools)
-        server_embed = Embed(title=t.ban, description=t.ban_edited_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-
-        await Ban.edit_duration(ban.id, ctx.author.id, await get_mod_level(ctx.author), minutes)
-
-        await invalidate_entry_cache()
-
-        user_embed.description = t.ban_edited.duration(
-            time_to_units(ban.minutes), t.infinity if minutes is None else time_to_units(minutes)
-        )
-        await send_to_changelog_mod(
-            guild=ctx.guild,
-            message=ctx.message,
-            colour=Colors.ban,
-            title=t.log_ban_edited,
-            member=user,
-            reason=ban.reason,
-            duration=t.log_field.infinity if minutes is None else time_to_units(minutes),
-        )
 
-        try:
-            await user.send(embed=user_embed)
-        except (Forbidden, HTTPException):
-            server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-            server_embed.colour = Colors.error
-        await reply(ctx, embed=server_embed)
+        await self.handle_edit_timed_duration(ctx, user, time, t.ban, Ban, Colors.ban)
 
     @commands.command(aliases=["ban_delete"])
     @ModPermission.ban.check
     @guild_only()
     @docs(t.commands.delete_ban)
     async def delete_ban(self, ctx: Context, ban_id: int):
-        ban = await get_and_compare_entry(Ban, ban_id, ctx.author)
-
-        conf_embed = Embed(
-            title=t.confirmation, description=t.confirm_ban_delete(ban.member_name, ban.id), color=Colors.ModTools
-        )
-
-        if not await confirm_action(ctx, conf_embed):
+        if not (ban := await self.handle_delete_timed(ctx, ban_id, t.ban, Ban, Colors.ban)):
             return
 
         active_bans: List[Ban] = await db.all(filter_by(Ban, active=True, member=ban.member))
@@ -1400,92 +1258,23 @@ async def delete_ban(self, ctx: Context, ban_id: int):
                 except HTTPException:
                     pass
 
-        try:
-            user = await self.bot.fetch_user(ban.member)
-        except (NotFound, HTTPException):
-            raise CommandError(t.user_not_found)
-
-        await Ban.delete(ban_id)
-
-        await invalidate_entry_cache()
-
-        server_embed = Embed(title=t.mute, description=t.ban_deleted_response, colour=Colors.ModTools)
-
-        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-
-        if await ModSettings.send_delete_user_message.get():
-            user_embed = Embed(title=t.ban, colour=Colors.ModTools)
-
-            if ban.minutes == -1:
-                user_embed.description = t.ban_deleted.inf(ban.reason)
-            else:
-                user_embed.description = t.ban_deleted.not_inf(time_to_units(ban.minutes), ban.reason)
-
-            try:
-                await user.send(embed=user_embed)
-            except (Forbidden, HTTPException):
-                server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
-                server_embed.colour = Colors.error
-
-        await reply(ctx, embed=server_embed)
-
-        await send_to_changelog_mod(
-            guild=ctx.guild,
-            message=ctx.message,
-            colour=Colors.ban,
-            title=t.log_ban_deleted,
-            member=user,
-            reason=ban.reason,
-            duration=t.log_field_infinity if ban.minutes == -1 else time_to_units(ban.minutes),
-        )
-
     @commands.command()
     @ModPermission.ban.check
     @guild_only()
     @docs(t.commands.unban)
     async def unban(self, ctx: Context, user: UserMemberConverter, *, reason: str):
-        user: Member | User
-
-        if len(reason) > 900:
-            raise CommandError(t.reason_too_long)
+        user: User | Member
 
         if not ctx.guild.me.guild_permissions.ban_members:
             raise CommandError(t.cannot_unban_permissions)
 
-        was_banned = True
-        try:
-            await ctx.guild.unban(user, reason=reason)
-        except HTTPException:
-            was_banned = False
-
-        minutes = 0
-        async for ban in await db.stream(filter_by(Ban, active=True, member=user.id)):
-            if not await compare_mod_level(ctx.author, ban.mod_level) or not ctx.author.id == ban.mod:
-                raise CommandError(tg.permission_denied)
-
-            await Ban.deactivate(ban.id, ctx.author.id, reason)
-
+        async def unban_inner(context: Context, banned_user: Member | User) -> bool:
             was_banned = True
+            try:
+                await ctx.guild.unban(banned_user, reason=reason)
+            except HTTPException:
+                was_banned = False
 
-            if ban.minutes > minutes or ban.minutes == -1:
-                minutes = ban.minutes
-
-        if not was_banned:
-            raise UserCommandError(user, t.not_banned)
-
-        await invalidate_entry_cache()
+            return was_banned
 
-        server_embed = Embed(title=t.unban, description=t.unbanned_response, colour=Colors.ModTools)
-        server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
-        await reply(ctx, embed=server_embed)
-        await send_to_changelog_mod(
-            guild=ctx.guild,
-            message=ctx.message,
-            colour=Colors.unban,
-            title=t.log_unbanned,
-            member=user,
-            reason=reason,
-            duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
-            mod=ctx.author,
-            original_reason=ban.reason,
-        )
+        await self.handle_undo_timed(ctx, user, reason, t.ban, Ban, Colors.unban, unban_inner)
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index 20601506d..09b71060c 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -92,99 +92,99 @@ confirm_report: "Are you sure you want to report {} for ```\n{}```\n"
 reported_response: "User reported successfully :white_check_mark:"
 alert_report: "{} reported {} because of ```\n{}\n```"
 
-# warns
-warn: ":warning: Warn"
-cannot_warn: This member cannot be warned.
-warned: "{} just warned you on {}:```\n{}\n```"
-warned_response: "User warned successfully :white_check_mark:"
-log_warned: ":warning: Member warned"
-confirm_warn_edit: "Are you sure you want to change this warns reason from ```\n{}\n```to```\n{}\n```"
-warn_edited: "The warn reasonhas been changed from ```\n{}\n```to```\n{}\n```"
-warn_edited_response: ":white_check_mark: The warn reason has been edited"
-log_warn_edited: ":warning: Warn edited"
-confirm_warn_delete: "Are you sure you want to delete this warning for *{}*?\n`(ID: {})`"
-warn_deleted: "Your warn with the reason ```\n{}\n``` has been deleted"
-warn_deleted_response: ":white_check_mark: The warn has been deleted"
-log_warn_deleted: ":warning: Warn deleted"
-
-# mutes
-mute: ":mute: Mute"
-unmute: ":loud_sound: Mute"
-mute_role_not_set: User could not be muted because no mute role is configured.
-cannot_mute: This member cannot be muted.
-already_muted: User is already muted for the given period of time.
-muted: "{} just muted you on {} for {}:```\n{}\n```"
-muted_inf: "{} just muted you on {}:```\n{}\n```"
-muted_response: "User muted successfully :white_check_mark:"
-log_muted: ":mute: Member muted"
-log_unmuted_expired: "Unmuted automatically because the mute time for this user has expired."
-unmuted_response: "User unmuted successfully :white_check_mark:"
-log_unmuted: ":loud_sound: Member unmuted"
-not_muted: User is not muted.
-cannot_assign_mute_role: Cannot manage mute role `@{}` ({})
-confirm_mute_edit:
-  reason: "Are you sure you want to change this mutes reason from ```\n{}\n```to```\n{}\n```"
-  duration: "Are you sure you want to change the mute duration from ```\n{}\n```to```\n{}\n```"
-mute_edited:
-  reason: "The mute reason has been changed from ```\n{}\n```to```\n{}\n```"
-  duration: "The mute duration has been changed from ```\n{}\n```to```\n{}\n```"
-mute_edited_response: ":white_check_mark: The mute has been edited"
-log_mute_edited: ":mute: Mute edited"
-confirm_mute_delete: "Are you sure you want to delete this mute for *{}*?\n`(ID: {})`"
-mute_deleted:
-  inf: "Your mute with the reason ```\n{}\n``` has been deleted"
-  not_inf: "Your mute for {} with the reason ```\n{}\n``` has been deleted"
-mute_deleted_response: ":white_check_mark: The mute has been deleted"
-log_mute_deleted: ":loud_sound: Mute deleted"
-
-# kicks
-kick: ":x: Kick"
-kicked: "{} just kicked you from {}:```\n{}\n```"
-kicked_response: "User kicked successfully :white_check_mark:"
-log_kicked: ":x: Member kicked"
-cannot_kick: This member cannot be kicked.
-cannot_kick_permissions: User could not be kicked because I don't have `kick_members` permission on this server.
-confirm_kick_edit: "Are you sure you want to change this kicks reason from ```\n{}\n```to```\n{}\n```"
-kick_edited: "The kick reason has been changed from ```\n{}\n```to```\n{}\n```"
-kick_edited_reponse: ":white_check_mark: The kick reason has been edited"
-log_kick_edited: ":x: Kick edited"
-confirm_kick_delete: "Are you sure you want to delete this kick of *{}*?\n`(ID: {})`"
-kick_deleted: "Your kick with the reason ```\n{}\n``` has been deleted"
-kick_deleted_response: ":white_check_mark: The kick has been deleted"
-log_kick_deleted: ":x: Kick deleted"
-
-# bans
-ban: ":no_entry: Ban"
-unban: ":white_check_mark: Ban"
-cannot_ban: This member cannot be banned.
-already_banned: This member is already banned for the given period of time.
-cannot_ban_permissions: User could not be banned because I don't have `ban_members` permission on this server.
-banned: "{} just banned you from {} for {}:```\n{}\n```"
-banned_inf: "{} just banned you from {}:```\n{}\n```"
-banned_response: "User banned successfully :white_check_mark:"
-log_banned: ":no_entry: Member Banned"
-log_unbanned_expired: "Unbanned automatically because the ban time for this user has expired."
-not_banned: This member is not banned.
-unbanned_response: "User unbanned. :white_check_mark:"
-log_unbanned: ":white_check_mark: Member Unbanned"
-cannot_unban_permissions: User could not be unbanned because I don't have `ban_members` permission on this server.
-confirm_ban_edit:
-  reason: "Are you sure you want to change this bans reason from ```\n{}\n```to```\n{}\n```"
-  duration: "Are you sure you want to change the bans duration from ```\n{}\n```to```\n{}\n```"
-ban_edited:
-  reason: "The ban reason has been changed from ```\n{}\n```to```\n{}\n```"
-  duration: "The ban duration has been changed from ```\n{}\n```to```\n{}\n```"
-ban_edited_response: ":white_check_mark: The ban has been edited"
-log_ban_edited: ":no_entry: Ban edited"
-confirm_ban_delete: "Are you sure you want to delete this ban of *{}*?\n`(ID: {})`"
-ban_deleted:
-  inf: "Your ban with the reason ```\n{}\n``` has been deleted"
-  not_inf: "Your ban for {} with the reason ```\n{}\n``` has been deleted"
-ban_deleted_response: ":white_check_mark: The ban has been deleted"
-log_ban_deleted: ":white_check_mark: Ban deleted"
-alert_member_banned: "The member {} has been banned through discords ban system by {}"
-cancelled_by_ban: The mute was cancelled because the member has been banned
-previously_muted: The member was prevoiously muted. This mute has now been cancelled.
+warn:
+  action: ":warning: Warn"
+  cannot: This member cannot be warned.
+  done: "{} just warned you on {}:```\n{}\n```"
+  response: "User warned successfully :white_check_mark:"
+  log: ":warning: Member warned"
+  confirm_edit: "Are you sure you want to change this warns reason from ```\n{}\n```to```\n{}\n```"
+  edited: "The warn reason has been changed from ```\n{}\n```to```\n{}\n```"
+  edited_response: ":white_check_mark: The warn reason has been edited"
+  log_edited: ":warning: Warn edited"
+  confirm_delete: "Are you sure you want to delete this warning for *{}*?\n`(ID: {})`"
+  deleted: "Your warn with the reason ```\n{}\n``` has been deleted"
+  deleted_response: ":white_check_mark: The warn has been deleted"
+  log_deleted: ":warning: Warn deleted"
+
+mute:
+  action: ":mute: Mute"
+  undo: ":loud_sound: Mute"
+  cannot: This member cannot be muted.
+  already_done: User is already muted for the given period of time.
+  done: "{} just muted you on {} for {}:```\n{}\n```"
+  done_inf: "{} just muted you on {}:```\n{}\n```"
+  response: "User muted successfully :white_check_mark:"
+  log: ":mute: Member muted"
+  log_undo_expired: "Unmuted automatically because the mute time for this user has expired."
+  undo_response: "User unmuted successfully :white_check_mark:"
+  log_undo: ":loud_sound: Member unmuted"
+  not_done: User is not muted.
+  confirm_edit:
+    reason: "Are you sure you want to change this mutes reason from ```\n{}\n```to```\n{}\n```"
+    duration: "Are you sure you want to change the mute duration from ```\n{}\n```to```\n{}\n```"
+  edited:
+    reason: "The mute reason has been changed from ```\n{}\n```to```\n{}\n```"
+    duration: "The mute duration has been changed from ```\n{}\n```to```\n{}\n```"
+  edited_response: ":white_check_mark: The mute has been edited"
+  log_edited: ":mute: Mute edited"
+  confirm_delete: "Are you sure you want to delete this mute for *{}*?\n`(ID: {})`"
+  deleted:
+    inf: "Your mute with the reason ```\n{}\n``` has been deleted"
+    not_inf: Your mute for {} with the reason ```\n{}\n``` has been deleted"
+  deleted_response: ":white_check_mark: The mute has been deleted"
+  log_deleted: ":loud_sound: Mute deleted"
+  role_not_set: User could not be muted because no mute role is configured.
+  cannot_assign_role: Cannot manage mute role `@{}` ({})
+
+kick:
+  action: ":x: Kick"
+  cannot: This member cannot be kicked.
+  done: "{} just kicked you from {}:```\n{}\n```"
+  response: "User kicked successfully :white_check_mark:"
+  log: ":x: Member kicked"
+  confirm_edit: "Are you sure you want to change this kicks reason from ```\n{}\n```to```\n{}\n```"
+  edited: "The kick reason has been changed from ```\n{}\n```to```\n{}\n```"
+  edited_response: ":white_check_mark: The kick reason has been edited"
+  log_edited: ":x: Kick edited"
+  confirm_delete: "Are you sure you want to delete this kick of *{}*?\n`(ID: {})`"
+  deleted: "Your kick with the reason ```\n{}\n``` has been deleted"
+  deleted_response: ":white_check_mark: The kick has been deleted"
+  log_deleted: ":x: Kick deleted"
+  cannot_permissions: User could not be kicked because I don't have `kick_members` permission on this server.
+
+ban:
+  action: ":no_entry: Ban"
+  undo: ":white_check_mark: Ban"
+  cannot: This member cannot be banned.
+  already_done: This member is already banned for the given period of time.
+  done: "{} just banned you from {} for {}:```\n{}\n```"
+  done_inf: "{} just banned you from {}:```\n{}\n```"
+  response: "User banned successfully :white_check_mark:"
+  log: ":no_entry: Member Banned"
+  log_undo_expired: "Unbanned automatically because the ban time for this user has expired."
+  undo_response: "User unbanned. :white_check_mark:"
+  log_undo: ":white_check_mark: Member Unbanned"
+  not_done: This member is not banned.
+  confirm_edit:
+    reason: "Are you sure you want to change this bans reason from ```\n{}\n```to```\n{}\n```"
+    duration: "Are you sure you want to change the bans duration from ```\n{}\n```to```\n{}\n```"
+  edited:
+    reason: "The ban reason has been changed from ```\n{}\n```to```\n{}\n```"
+    duration: "The ban duration has been changed from ```\n{}\n```to```\n{}\n```"
+  edited_response: ":white_check_mark: The ban has been edited"
+  log_edited: ":no_entry: Ban edited"
+  confirm_delete: "Are you sure you want to delete this ban of *{}*?\n`(ID: {})`"
+  deleted:
+    inf: "Your ban with the reason ```\n{}\n``` has been deleted"
+    not_inf: "Your ban for {} with the reason ```\n{}\n``` has been deleted"
+  deleted_response: ":white_check_mark: The ban has been deleted"
+  log_deleted: ":white_check_mark: Ban deleted"
+  cannot_permissions: User could not be banned because I don't have `ban_members` permission on this server.
+  cannot_undo_permissions: User could not be unbanned because I don't have `ban_members` permission on this server.
+  alert: "The member {} has been banned through discords ban system by {}"
+  cancelled_by: The mute was cancelled because the member has been banned
+  previously_muted: The member was prevoiously muted. This mute has now been cancelled.
 
 reported_cnt: ":speech_balloon:  Reported"
 warned_cnt: ":warning:  Warned"

From 85d89f7e39c9493cdbb78c74240eefa667100bd6 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Thu, 26 May 2022 09:00:32 +0200
Subject: [PATCH 103/120] fixed some minor issues

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 42 ++++++++++++++++++++++--------------------
 1 file changed, 22 insertions(+), 20 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index fb78f55e6..ac5d2b756 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -1,7 +1,7 @@
 import re
 from asyncio import sleep
 from datetime import datetime, timedelta
-from typing import List, Tuple, Type, TypeVar, Any, Callable, Awaitable
+from typing import Tuple, Type, TypeVar, Any, Callable, Awaitable
 
 from dateutil.relativedelta import relativedelta
 from discord import (
@@ -85,7 +85,7 @@ async def fill(db_model: Type[TBase]):
 
                 expiration_timestamp = entry.timestamp + timedelta(minutes=entry.minutes)
 
-                await pipe.hmset(entry_key, {str(entry.id): str(expiration_timestamp)})
+                await pipe.hset(entry_key, str(entry.id), str(expiration_timestamp))
 
             await pipe.expire(entry_key, CACHE_TTL)
             await pipe.execute()
@@ -120,7 +120,7 @@ def get_func(key, value):
 async def get_mute_role(guild: Guild) -> Role:
     mute_role: Role | None = guild.get_role(await RoleSettings.get("mute"))
     if mute_role is None:
-        await send_alert(guild, t.mute_role_not_set)
+        await send_alert(guild, t.mute.role_not_set)
     return mute_role
 
 
@@ -217,7 +217,7 @@ async def send_to_changelog_mod(
         embed.add_field(name=t.log_field.mod, value=f"<@{mod.id}>", inline=True)
 
     if original_reason:
-        embed.add_field(name=t.log_field_original_reason, value=original_reason, inline=True)
+        embed.add_field(name=t.log_field.original_reason, value=original_reason, inline=True)
 
     embed.add_field(name=t.log_field.reason, value=reason, inline=False)
 
@@ -269,9 +269,9 @@ async def mod_loop(self):
                     guild=guild,
                     message=None,
                     colour=Colors.unban,
-                    title=t.log_unbanned,
+                    title=t.ban.log_undo,
                     member=user,
-                    reason=t.log_unbanned_expired,
+                    reason=t.ban.log_undo_expired,
                 )
 
         mute_role: Role | None = guild.get_role(await RoleSettings.get("mute"))
@@ -299,9 +299,9 @@ async def mod_loop(self):
                     guild=guild,
                     message=None,
                     colour=Colors.unmute,
-                    title=t.log_unmuted,
+                    title=t.mute.log_undo,
                     member=member,
-                    reason=t.log_unmuted_expired,
+                    reason=t.mute.log_undo_expired,
                 )
 
                 await Mute.deactivate(mute.id)
@@ -845,7 +845,7 @@ async def handle_edit_timed_duration(
         time: int | None
         minutes = time
 
-        active_entries: List[TBase] = sorted(
+        active_entries: list[TBase] = sorted(
             await db.all(filter_by(model, active=True, member=user.id)), key=lambda active_entry: active_entry.timestamp
         )
 
@@ -987,7 +987,7 @@ async def handle_undo_timed(
                 minutes = entry.minutes
 
         if not was_done:
-            raise UserCommandError(user, t.not_muted)
+            raise UserCommandError(user, translation.not_done)
 
         await invalidate_entry_cache()
 
@@ -1027,9 +1027,7 @@ async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         if not await confirm_action(ctx, conf_embed, t.report_confirmed, t.report_canceled):
             return
 
-        attachments = ctx.message.attachments
-        evidence = attachments[0] if attachments else None
-        evidence_url = evidence.url if attachments else None
+        evidence, evidence_url = extract_evidence(ctx.message)
 
         await Report.create(user.id, str(user), ctx.author.id, reason, evidence_url)
         server_embed = Embed(title=t.report, description=t.reported_response, colour=Colors.ModTools)
@@ -1088,11 +1086,14 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
         if user == self.bot.user or await is_teamler(user):
             raise UserCommandError(user, t.mute.cannot)
 
+        mute_role: Role | None = await get_mute_role(ctx.guild)
+
+        if mute_role is None:
+            raise CommandError(t.mute.role_not_set)
+
         if not await self.handle_timed(ctx, user, time, reason, t.mute, Mute, Colors.mute, ""):
             return
 
-        mute_role: Role = await get_mute_role(ctx.guild)
-
         if isinstance(user, Member):
             await user.add_roles(mute_role)
             await user.move_to(None)
@@ -1126,7 +1127,7 @@ async def delete_mute(self, ctx: Context, mute_id: int):
         if not (mute := await self.handle_delete_timed(ctx, mute_id, t.mute, Mute, Colors.mute)):
             return
 
-        active_mutes: List[Mute] = await db.all(filter_by(Mute, active=True, member=mute.member))
+        active_mutes: list[Mute] = await db.all(filter_by(Mute, active=True, member=mute.member))
 
         if len(active_mutes) == 1 and mute in active_mutes:
             user = ctx.guild.get_member(mute.member)
@@ -1142,12 +1143,13 @@ async def unmute(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         user: User | Member
 
         async def unmute_inner(context: Context, muted_user: Member | User) -> bool:
-            mute_role: Role = await get_mute_role(context.guild)
+            mute_role: Role | None = await get_mute_role(context.guild)
 
             was_muted = False
             if isinstance(muted_user, Member) and mute_role in muted_user.roles:
                 was_muted = True
-                await muted_user.remove_roles(mute_role)
+                if mute_role is not None:
+                    await muted_user.remove_roles(mute_role)
 
             return was_muted
 
@@ -1206,7 +1208,7 @@ async def ban(
         if isinstance(user, Member) and (user.top_role >= ctx.guild.me.top_role or user.id == ctx.guild.owner_id):
             raise UserCommandError(user, t.cannot_ban)
 
-        active_mutes: List[Mute] = await db.all(filter_by(Mute, active=True, member=user.id))
+        active_mutes: list[Mute] = await db.all(filter_by(Mute, active=True, member=user.id))
 
         if not await self.handle_timed(
             ctx, user, time, reason, t.ban, Ban, Colors.ban, f"\n\n{t.ban.previously_muted}" if active_mutes else ""
@@ -1248,7 +1250,7 @@ async def delete_ban(self, ctx: Context, ban_id: int):
         if not (ban := await self.handle_delete_timed(ctx, ban_id, t.ban, Ban, Colors.ban)):
             return
 
-        active_bans: List[Ban] = await db.all(filter_by(Ban, active=True, member=ban.member))
+        active_bans: list[Ban] = await db.all(filter_by(Ban, active=True, member=ban.member))
 
         if len(active_bans) == 1 and ban in active_bans:
             user = ctx.guild.get_member(ban.member)

From ab5680a3e9c3074318849d465096a16a5031ea0d Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Mon, 20 Jun 2022 22:44:54 +0200
Subject: [PATCH 104/120] Fixed breaking changes caused by the library

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py    | 102 ++++++++++++++-------------------------
 moderation/mod/models.py |   9 ++--
 2 files changed, 39 insertions(+), 72 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index ac5d2b756..4c0f5cdb2 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -1,54 +1,57 @@
 import re
 from asyncio import sleep
 from datetime import datetime, timedelta
-from typing import Tuple, Type, TypeVar, Any, Callable, Awaitable
+from typing import Any, Awaitable, Callable, Tuple, Type, TypeVar
 
 from dateutil.relativedelta import relativedelta
 from discord import (
-    Role,
-    Guild,
-    Member,
-    Forbidden,
-    HTTPException,
-    User,
-    Embed,
-    NotFound,
-    Message,
     Attachment,
     AuditLogAction,
     AuditLogEntry,
+    Embed,
+    Forbidden,
+    Guild,
+    HTTPException,
+    Member,
+    Message,
+    NotFound,
+    Role,
     TextChannel,
     Thread,
+    User,
 )
 from discord.ext import commands, tasks
-from discord.ext.commands import guild_only, Context, CommandError, Converter, BadArgument, UserInputError
+from discord.ext.commands import BadArgument, CommandError, Context, Converter, UserInputError, guild_only
 from discord.utils import utcnow
 
 from PyDrocsid.cog import Cog
-from PyDrocsid.command import reply, UserCommandError, confirm, docs
+from PyDrocsid.command import Confirmation, UserCommandError, docs, reply
 from PyDrocsid.config import Config
 from PyDrocsid.converter import UserMemberConverter
-from PyDrocsid.database import db, filter_by, db_wrapper, Base as DBBase
+from PyDrocsid.database import Base as DBBase
+from PyDrocsid.database import db, db_wrapper, filter_by
 from PyDrocsid.environment import CACHE_TTL
 from PyDrocsid.redis import redis
 from PyDrocsid.settings import RoleSettings
 from PyDrocsid.translations import t
-from PyDrocsid.util import is_teamler, check_role_assignable
+from PyDrocsid.util import check_role_assignable, is_teamler
+
 from .colors import Colors
-from .models import Mute, Ban, Report, Warn, Kick
+from .models import Ban, Kick, Mute, Report, Warn
 from .permissions import ModPermission
 from .settings import ModSettings
 from ...contributor import Contributor
 from ...pubsub import (
-    send_to_changelog,
-    send_alert,
-    log_auto_kick,
-    get_userlog_entries,
     get_user_info_entries,
     get_user_status_entries,
+    get_userlog_entries,
+    log_auto_kick,
     revoke_verification,
+    send_alert,
+    send_to_changelog,
 )
 
+
 tg = t.g
 t = t.mod
 TBase = TypeVar("TBase", bound=DBBase)
@@ -158,15 +161,12 @@ async def get_and_compare_entry(entry_format: Type[TBase], entry_id: int, mod: M
 async def confirm_action(
     ctx: Context, embed: Embed, message_confirmed: str = t.edit_confirmed, message_canceled: str = t.edit_canceled
 ) -> bool:
-    async with confirm(ctx, embed) as (result, msg):
-        if not result:
-            embed.description += f"\n\n{message_canceled}"
-            return result
+    if not await Confirmation.run(ctx, embed=embed):
+        embed.description += f"\n\n{message_canceled}"
+        return False
 
-        embed.description += f"\n\n{message_confirmed}"
-        if msg:
-            await msg.delete(delay=5)
-        return result
+    embed.description += f"\n\n{message_confirmed}"
+    return True
 
 
 async def confirm_no_evidence(ctx: Context):
@@ -362,12 +362,7 @@ async def handle_get_userlog_entries(
         self, user_id: int, show_ids: bool, author: Member
     ) -> list[tuple[datetime, str]]:
         def wrap_time_entry(
-            translation,
-            mod: int,
-            reason: str,
-            evidence: str,
-            minutes: int | None = None,
-            entry_id: int | None = None,
+            translation, mod: int, reason: str, evidence: str, minutes: int | None = None, entry_id: int | None = None
         ) -> str:
             args = [f"<@{mod}>"]
 
@@ -637,15 +632,9 @@ async def handle_edit_single(
             raise CommandError(t.user_not_found)
 
         user_embed = Embed(
-            title=translation.action,
-            description=translation.edited(entry.reason, reason),
-            colour=Colors.ModTools,
-        )
-        server_embed = Embed(
-            title=translation.action,
-            description=translation.edited_response,
-            colour=Colors.ModTools,
+            title=translation.action, description=translation.edited(entry.reason, reason), colour=Colors.ModTools
         )
+        server_embed = Embed(title=translation.action, description=translation.edited_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
         await model.edit(entry_id, ctx.author.id, await get_mod_level(ctx.author), reason)
@@ -657,12 +646,7 @@ async def handle_edit_single(
             server_embed.colour = Colors.error
         await reply(ctx, embed=server_embed)
         await send_to_changelog_mod(
-            guild=ctx.guild,
-            message=ctx.message,
-            colour=color,
-            title=translation.log_edited,
-            member=user,
-            reason=reason,
+            guild=ctx.guild, message=ctx.message, colour=color, title=translation.log_edited, member=user, reason=reason
         )
 
     async def handle_delete_single(self, ctx: Context, entry_id: int, translation, model: Type[TBase], color: int):
@@ -689,9 +673,7 @@ async def handle_delete_single(self, ctx: Context, entry_id: int, translation, m
 
         if await ModSettings.send_delete_user_message.get():
             user_embed = Embed(
-                title=translation.action,
-                description=translation.deleted(entry.reason),
-                colour=Colors.ModTools,
+                title=translation.action, description=translation.deleted(entry.reason), colour=Colors.ModTools
             )
 
             try:
@@ -765,10 +747,7 @@ async def handle_timed(
 
         if minutes is not None:
             user_embed.description = translation.done(
-                ctx.author.mention,
-                ctx.guild.name,
-                time_to_units(minutes),
-                reason,
+                ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason
             )
         else:
             user_embed.description = translation.done_inf(ctx.author.mention, ctx.guild.name, reason)
@@ -824,22 +803,11 @@ async def handle_edit_timed_reason(
             server_embed.colour = Colors.error
         await reply(ctx, embed=server_embed)
         await send_to_changelog_mod(
-            guild=ctx.guild,
-            message=ctx.message,
-            colour=color,
-            title=translation.log_edited,
-            member=user,
-            reason=reason,
+            guild=ctx.guild, message=ctx.message, colour=color, title=translation.log_edited, member=user, reason=reason
         )
 
     async def handle_edit_timed_duration(
-        self,
-        ctx: Context,
-        user: User | Member,
-        time: int | None,
-        translation: Any,
-        model: Type[TBase],
-        color: int,
+        self, ctx: Context, user: User | Member, time: int | None, translation: Any, model: Type[TBase], color: int
     ):
         user: Member | User
         time: int | None
diff --git a/moderation/mod/models.py b/moderation/mod/models.py
index 71519704c..ccb4abbeb 100644
--- a/moderation/mod/models.py
+++ b/moderation/mod/models.py
@@ -1,13 +1,12 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
 from datetime import datetime
-
-from sqlalchemy import Column, Integer, BigInteger, Text, Boolean
-
-from PyDrocsid.database import db, UTCDateTime, Base
+from typing import TYPE_CHECKING
 
 from discord.utils import utcnow
+from sqlalchemy import BigInteger, Boolean, Column, Integer, Text
+
+from PyDrocsid.database import Base, UTCDateTime, db
 
 
 class ModBase(Base if TYPE_CHECKING else object):

From 0aa6342aaee18ca3990eab87eee75f884556e58e Mon Sep 17 00:00:00 2001
From: TheCataliasTNT2k <44349750+TheCataliasTNT2k@users.noreply.github.com>
Date: Tue, 21 Jun 2022 00:03:37 +0200
Subject: [PATCH 105/120] reviewed code until `handle_get_userlog_entries` and
 added todos

---
 moderation/mod/cog.py | 143 +++++++++++++++++++++++-------------------
 1 file changed, 78 insertions(+), 65 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 4c0f5cdb2..1a1bdda7e 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -57,12 +57,23 @@
 TBase = TypeVar("TBase", bound=DBBase)
 
 
-class DurationConverter(Converter):
+# TODO
+#  Docstring for all methods, functions and classes
+#  make all functions private, if the are not ment to be used by other
+#  use timeout function for mutes (see actual mod tools)
+#  do not require mute role, update whole code accordingly
+#  assign mute role to all muted members, when mute role gets set
+#  remove mute role from all muted members if mute role gets cleared
+#  to be continued......
+
+
+class DurationConverter(Converter):  # TODO: Move to library
     async def convert(self, ctx, argument: str) -> int | None:
         if argument.lower() in ("inf", "perm", "permanent", "-1", "∞"):
             return None
-        if (match := re.match(r"^(\d+w)?(\d+d)?(\d+h)?(\d+m)?$", argument)) is None:
-            raise BadArgument(tg.invalid_duration)
+        # TODO add new parameters to rest of code
+        if (match := re.match(r"^(\d+y)?(\d+m)?(\d+w)?(\d+d)?(\d+H)?(\d+M)?$", argument)) is None:
+            raise BadArgument(tg.invalid_duration)  # TODO explain suffixes
 
         weeks, days, hours, minutes = [0 if (value := match.group(i)) is None else int(value[:-1]) for i in range(1, 5)]
 
@@ -122,7 +133,7 @@ def get_func(key, value):
 
 async def get_mute_role(guild: Guild) -> Role:
     mute_role: Role | None = guild.get_role(await RoleSettings.get("mute"))
-    if mute_role is None:
+    if not mute_role:
         await send_alert(guild, t.mute.role_not_set)
     return mute_role
 
@@ -144,24 +155,28 @@ async def get_mod_level(mod: Member) -> int:
 
 
 async def compare_mod_level(mod: Member, mod_level: int) -> bool:
-    return await get_mod_level(mod) > mod_level or mod == mod.guild.owner
+    return (
+        await get_mod_level(mod) > mod_level or mod == mod.guild.owner
+    )  # TODO remove, all members have the permission to edit / unban etc if they have the permission set via .p set
 
 
-async def get_and_compare_entry(entry_format: Type[TBase], entry_id: int, mod: Member) -> TBase:
+async def get_and_compare_entry(
+    entry_format: Type[TBase], entry_id: int, mod: Member
+) -> TBase:  # TODO DESCRIPTIVE NAME!?
     entry = await db.get(entry_format, id=entry_id)
     if entry is None:
         raise CommandError(getattr(t.not_found, entry_format.__tablename__))
 
-    if mod.id != entry.mod and not await compare_mod_level(mod, entry.mod_level):
+    if mod.id != entry.mod and not await compare_mod_level(mod, entry.mod_level):  # TODO no longer needed, see above
         raise CommandError(tg.permission_denied)
 
     return entry
 
 
-async def confirm_action(
+async def confirm_action(  # TODO can be removed, "if not await Confirmation().run(ctx, TEXT)" is enough (see constructor for more settings)
     ctx: Context, embed: Embed, message_confirmed: str = t.edit_confirmed, message_canceled: str = t.edit_canceled
 ) -> bool:
-    if not await Confirmation.run(ctx, embed=embed):
+    if not await Confirmation().run(ctx, embed=embed):
         embed.description += f"\n\n{message_canceled}"
         return False
 
@@ -172,7 +187,7 @@ async def confirm_action(
 async def confirm_no_evidence(ctx: Context):
     conf_embed = Embed(title=t.confirmation, description=t.no_evidence, color=Colors.ModTools)
 
-    return await confirm_action(ctx, conf_embed, t.action_confirmed, t.action_cancelled)
+    return await confirm_action(ctx, conf_embed, t.action_confirmed, t.action_cancelled)  # TODO use Confirm().run()
 
 
 async def send_to_changelog_mod(
@@ -241,6 +256,57 @@ async def on_ready(self):
         except RuntimeError:
             self.mod_loop.restart()
 
+    async def on_member_join(self, member: Member):
+        mute_role: Role | None = member.guild.get_role(await RoleSettings.get("mute"))
+        if mute_role is None:
+            return
+
+        if await db.exists(filter_by(Mute, active=True, member=member.id)):
+            await member.add_roles(mute_role)
+
+    async def on_member_ban(self, guild: Guild, member: Member):
+        search_limit = 100
+        for i in range(10, 1, -1):
+            try:
+                entry: AuditLogEntry
+                async for entry in guild.audit_logs(limit=search_limit, action=AuditLogAction.ban):
+                    if entry.user == self.bot.user:
+                        continue
+
+                    if member.id != entry.target.id:
+                        continue
+
+                    if entry.reason:
+                        await Ban.create(
+                            entry.target.id,
+                            str(entry.target),
+                            entry.user.id,
+                            await get_mod_level(entry.user),
+                            -1,
+                            entry.reason,
+                            None,
+                        )
+
+                        await send_to_changelog_mod(
+                            guild=guild,
+                            message=None,
+                            colour=Colors.ban,
+                            title=t.log_banned,
+                            member=entry.target,
+                            reason=entry.reason,
+                            duration=t.log_field.infinity,
+                        )
+
+                    else:
+                        await send_alert(guild, t.alert_member_banned(str(entry.target), str(entry.user)))
+                    return
+
+            except Forbidden:
+                await send_alert(guild, t.cannot_fetch_audit_logs)
+
+            await sleep(i * 10)  # TODO why waiting 100 + 90 + 80 ... seconds?
+            search_limit -= i * 10  # TODO tested!?!? if i <= 8 -> search_limit < 0
+
     @tasks.loop(minutes=1)
     @db_wrapper
     async def mod_loop(self):
@@ -259,7 +325,7 @@ async def mod_loop(self):
                     user = ban.member, ban.member_name
                 except Forbidden:
                     await send_alert(guild, t.cannot_unban_permissions)
-                    continue
+                    continue  # TODO stop "for loop"!?
 
                 await Ban.deactivate(ban.id)
 
@@ -279,7 +345,7 @@ async def mod_loop(self):
             return
 
         try:
-            check_role_assignable(mute_role)
+            check_role_assignable(mute_role)  # TODO move into get_mute_role
         except CommandError:
             await send_alert(guild, t.cannot_assign_mute_role(mute_role, mute_role.id))
             return
@@ -497,59 +563,6 @@ def wrap_entry(translation, user: int, reason: str, evidence: str | None, entry_
 
         return out
 
-    async def on_member_join(self, member: Member):
-        mute_role: Role | None = member.guild.get_role(await RoleSettings.get("mute"))
-        if mute_role is None:
-            return
-
-        if await db.exists(filter_by(Mute, active=True, member=member.id)):
-            await member.add_roles(mute_role)
-
-    async def on_member_ban(self, guild: Guild, member: Member):
-        search_limit = 100
-        for i in range(10, 1, -1):
-
-            try:
-                entry: AuditLogEntry
-                async for entry in guild.audit_logs(limit=search_limit, action=AuditLogAction.ban):
-                    if entry.user == self.bot.user:
-                        continue
-
-                    if member.id != entry.target.id:
-                        continue
-
-                    if entry.reason:
-                        await Ban.create(
-                            entry.target.id,
-                            str(entry.target),
-                            entry.user.id,
-                            await get_mod_level(entry.user),
-                            -1,
-                            entry.reason,
-                            None,
-                        )
-
-                        await send_to_changelog_mod(
-                            guild=guild,
-                            message=None,
-                            colour=Colors.ban,
-                            title=t.log_banned,
-                            member=entry.target,
-                            reason=entry.reason,
-                            duration=t.log_field.infinity,
-                        )
-
-                    else:
-                        await send_alert(guild, t.alert_member_banned(str(entry.target), str(entry.user)))
-
-                    return
-
-            except Forbidden:
-                await send_alert(guild, t.cannot_fetch_audit_logs)
-
-            await sleep(delay=i * 10)
-            search_limit -= i * 10
-
     @commands.command()
     @guild_only()
     @ModPermission.modtools_write.check

From 9c4d5028993e323ee39c0bf41f1267c71ee4ec79 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Tue, 21 Jun 2022 06:58:53 +0200
Subject: [PATCH 106/120] Re-added years and months to the duration converter
 and enhanced its documentation

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py              | 21 ++++++++++++++++-----
 moderation/mod/translations/en.yml |  9 +++++----
 2 files changed, 21 insertions(+), 9 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 1a1bdda7e..78f7a7132 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -68,15 +68,22 @@
 
 
 class DurationConverter(Converter):  # TODO: Move to library
+    """
+    Converter for retrieving simple time spans from a string containing different time units
+    """
+
     async def convert(self, ctx, argument: str) -> int | None:
         if argument.lower() in ("inf", "perm", "permanent", "-1", "∞"):
             return None
-        # TODO add new parameters to rest of code
         if (match := re.match(r"^(\d+y)?(\d+m)?(\d+w)?(\d+d)?(\d+H)?(\d+M)?$", argument)) is None:
-            raise BadArgument(tg.invalid_duration)  # TODO explain suffixes
+            raise BadArgument(t.duration_suffixes)
 
-        weeks, days, hours, minutes = [0 if (value := match.group(i)) is None else int(value[:-1]) for i in range(1, 5)]
+        years, months, weeks, days, hours, minutes = [
+            0 if (value := match.group(i)) is None else int(value[:-1]) for i in range(1, 5)
+        ]
 
+        years += days * 365
+        days += months * 30
         days += weeks * 7
         td = timedelta(days=days, hours=hours, minutes=minutes)
         duration = int(td.total_seconds() / 60)
@@ -173,8 +180,12 @@ async def get_and_compare_entry(
     return entry
 
 
-async def confirm_action(  # TODO can be removed, "if not await Confirmation().run(ctx, TEXT)" is enough (see constructor for more settings)
-    ctx: Context, embed: Embed, message_confirmed: str = t.edit_confirmed, message_canceled: str = t.edit_canceled
+async def confirm_action(
+    # TODO can be removed, "if not await Confirmation().run(ctx, TEXT)" is enough (see constructor for more settings)
+    ctx: Context,
+    embed: Embed,
+    message_confirmed: str = t.edit_confirmed,
+    message_canceled: str = t.edit_canceled,
 ) -> bool:
     if not await Confirmation().run(ctx, embed=embed):
         embed.description += f"\n\n{message_canceled}"
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index 09b71060c..328519bef 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -11,19 +11,19 @@ commands:
   warn: warn a user
   edit_warn: "edit a warn\nget the warn id from the users user log"
   delete_warn: "delete a warn\nget the warn id from the users user log"
-  mute: "mute a user\ntime format: `wdhm`\nset time to `inf` for a permanent mute"
+  mute: "mute a user\ntime format: `ymwdHM`\nset time to `inf` for a permanent mute"
   edit_mute: edit a mute
   edit_mute_reason: "edit a mute reason\nget the mute id from the users user log"
-  edit_mute_duration: "edit a mute duration\ntime format: `wdhm`\nset time to `inf` for a permanent mute"
+  edit_mute_duration: "edit a mute duration\ntime format: `ymwdHM`\nset time to `inf` for a permanent mute"
   delete_mute: "delete a mute\nget the mute id from the users user log"
   unmute: unmute a user
   kick: kick a member
   edit_kick: "edit a kick\nget the kick id from the users user log"
   delete_kick: "delete a kick\nget the kick id from the users user log"
-  ban: "ban a user\ntime format: `wdhm`\nset time to `inf` for a permanent ban"
+  ban: "ban a user\ntime format: `ymwdHM`\nset time to `inf` for a permanent ban"
   edit_ban: edit a ban
   edit_ban_reason: "edit a ban reason\nget the ban id from the users user log"
-  edit_ban_duration: "edit a ban duration\ntime format: `wdhm`\nset time to `inf` for a permanent ban"
+  edit_ban_duration: "edit a ban duration\ntime format: `ymwdHM`\nset time to `inf` for a permanent ban"
   delete_ban: "delete a ban\nget the ban id from the users user log"
   unban: unban a user
 
@@ -62,6 +62,7 @@ not_found:
   ban: No ban with this ID could be found
 
 modtools: Mod tools
+duration_suffixes: "Invalid duration. Please specify a duration using the suffixes y (years), m (months), w (weeks), d (days), H (hours) and M (Minutes).\nYou need to use this exact order, for example: 5y3w2H (5 years, 3 weeks, 2 hours)."
 configured_send_delete_message:
   off: "Sending a message to a user after a warn/mute/kick/ban concerning him has been set to `off`"
   on: "Sending a message to a user after a warn/mute/kick/ban concerning him has been set to `on`"

From c8ccd2939b3655a0e189739003b6e318aece3fe7 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Tue, 21 Jun 2022 07:14:56 +0200
Subject: [PATCH 107/120] Removed on confirmation handler and replaced it with
 the class located in the library

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 29 +++++++----------------------
 1 file changed, 7 insertions(+), 22 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 78f7a7132..a8f0830b0 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -180,25 +180,10 @@ async def get_and_compare_entry(
     return entry
 
 
-async def confirm_action(
-    # TODO can be removed, "if not await Confirmation().run(ctx, TEXT)" is enough (see constructor for more settings)
-    ctx: Context,
-    embed: Embed,
-    message_confirmed: str = t.edit_confirmed,
-    message_canceled: str = t.edit_canceled,
-) -> bool:
-    if not await Confirmation().run(ctx, embed=embed):
-        embed.description += f"\n\n{message_canceled}"
-        return False
-
-    embed.description += f"\n\n{message_confirmed}"
-    return True
-
-
 async def confirm_no_evidence(ctx: Context):
     conf_embed = Embed(title=t.confirmation, description=t.no_evidence, color=Colors.ModTools)
 
-    return await confirm_action(ctx, conf_embed, t.action_confirmed, t.action_cancelled)  # TODO use Confirm().run()
+    return await Confirmation().run(ctx, embed=conf_embed)
 
 
 async def send_to_changelog_mod(
@@ -647,7 +632,7 @@ async def handle_edit_single(
             title=t.confirmation, description=translation.confirm_edit(entry.reason, reason), color=Colors.ModTools
         )
 
-        if not await confirm_action(ctx, conf_embed):
+        if not await Confirmation().run(ctx, embed=conf_embed):
             return
 
         try:
@@ -682,7 +667,7 @@ async def handle_delete_single(self, ctx: Context, entry_id: int, translation, m
             color=Colors.ModTools,
         )
 
-        if not await confirm_action(ctx, conf_embed):
+        if not await Confirmation().run(ctx, embed=conf_embed):
             return
 
         await model.delete(entry_id)
@@ -802,7 +787,7 @@ async def handle_edit_timed_reason(
             color=Colors.ModTools,
         )
 
-        if not await confirm_action(ctx, conf_embed):
+        if not await Confirmation().run(ctx, embed=conf_embed):
             return
 
         try:
@@ -861,7 +846,7 @@ async def handle_edit_timed_duration(
         else:
             conf_embed.description = translation.confirm_edit.duration(old_time, time_to_units(minutes))
 
-        if not await confirm_action(ctx, conf_embed):
+        if not await Confirmation().run(ctx, embed=conf_embed):
             return
 
         for active_entry in active_entries[1:]:
@@ -906,7 +891,7 @@ async def handle_delete_timed(
             color=Colors.ModTools,
         )
 
-        if not await confirm_action(ctx, conf_embed):
+        if not await Confirmation().run(ctx, embed=conf_embed):
             return
 
         try:
@@ -1016,7 +1001,7 @@ async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
             title=t.confirmation, description=t.confirm_report(user.mention, reason), color=Colors.ModTools
         )
 
-        if not await confirm_action(ctx, conf_embed, t.report_confirmed, t.report_canceled):
+        if not await Confirmation().run(ctx, embed=conf_embed):
             return
 
         evidence, evidence_url = extract_evidence(ctx.message)

From 6293f603c87b99e06a9810bf91dc4dd12cf37686 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Wed, 22 Jun 2022 21:50:36 +0200
Subject: [PATCH 108/120] Fixed bugs in mod loop and ban retriever

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index a8f0830b0..f19f48c10 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -125,6 +125,9 @@ async def invalidate_entry_cache():
 
 
 def time_to_units(minutes: int | float) -> str:
+    """
+    Util function to split minutes back into different time units
+    """
     _keys = ("years", "months", "days", "hours", "minutes")
 
     rd = relativedelta(
@@ -300,8 +303,8 @@ async def on_member_ban(self, guild: Guild, member: Member):
             except Forbidden:
                 await send_alert(guild, t.cannot_fetch_audit_logs)
 
-            await sleep(i * 10)  # TODO why waiting 100 + 90 + 80 ... seconds?
-            search_limit -= i * 10  # TODO tested!?!? if i <= 8 -> search_limit < 0
+            await sleep((i * 10) / 100)
+            search_limit = int(search_limit / 2)
 
     @tasks.loop(minutes=1)
     @db_wrapper
@@ -321,7 +324,7 @@ async def mod_loop(self):
                     user = ban.member, ban.member_name
                 except Forbidden:
                     await send_alert(guild, t.cannot_unban_permissions)
-                    continue  # TODO stop "for loop"!?
+                    break
 
                 await Ban.deactivate(ban.id)
 

From 4ec42dc9cd762edde26467541ee2bf5e2ae70bb7 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Wed, 22 Jun 2022 22:05:03 +0200
Subject: [PATCH 109/120] Removed entire mod level comparison functionality
 again..

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py    | 58 ++++++++--------------------------------
 moderation/mod/models.py | 21 +++------------
 2 files changed, 14 insertions(+), 65 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index f19f48c10..325fa44d1 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -26,7 +26,6 @@
 
 from PyDrocsid.cog import Cog
 from PyDrocsid.command import Confirmation, UserCommandError, docs, reply
-from PyDrocsid.config import Config
 from PyDrocsid.converter import UserMemberConverter
 from PyDrocsid.database import Base as DBBase
 from PyDrocsid.database import db, db_wrapper, filter_by
@@ -160,26 +159,11 @@ def show_evidence(evidence: str | None) -> str:
     return t.ulog.evidence(evidence) if evidence else ""
 
 
-async def get_mod_level(mod: Member) -> int:
-    return (await Config.PERMISSION_LEVELS.get_permission_level(mod)).level
-
-
-async def compare_mod_level(mod: Member, mod_level: int) -> bool:
-    return (
-        await get_mod_level(mod) > mod_level or mod == mod.guild.owner
-    )  # TODO remove, all members have the permission to edit / unban etc if they have the permission set via .p set
-
-
-async def get_and_compare_entry(
-    entry_format: Type[TBase], entry_id: int, mod: Member
-) -> TBase:  # TODO DESCRIPTIVE NAME!?
+async def get_database_entry(entry_format: Type[TBase], entry_id: int) -> TBase:
     entry = await db.get(entry_format, id=entry_id)
     if entry is None:
         raise CommandError(getattr(t.not_found, entry_format.__tablename__))
 
-    if mod.id != entry.mod and not await compare_mod_level(mod, entry.mod_level):  # TODO no longer needed, see above
-        raise CommandError(tg.permission_denied)
-
     return entry
 
 
@@ -276,15 +260,7 @@ async def on_member_ban(self, guild: Guild, member: Member):
                         continue
 
                     if entry.reason:
-                        await Ban.create(
-                            entry.target.id,
-                            str(entry.target),
-                            entry.user.id,
-                            await get_mod_level(entry.user),
-                            -1,
-                            entry.reason,
-                            None,
-                        )
+                        await Ban.create(entry.target.id, str(entry.target), entry.user.id, -1, entry.reason, None)
 
                         await send_to_changelog_mod(
                             guild=guild,
@@ -609,7 +585,7 @@ async def handle_single(
         except (Forbidden, HTTPException):
             server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
             server_embed.colour = Colors.error
-        await model.create(user.id, str(user), ctx.author.id, await get_mod_level(ctx.author), reason, evidence_url)
+        await model.create(user.id, str(user), ctx.author.id, reason, evidence_url)
         await reply(ctx, embed=server_embed)
         await send_to_changelog_mod(
             guild=ctx.guild,
@@ -626,7 +602,7 @@ async def handle_single(
     async def handle_edit_single(
         self, ctx: Context, entry_id: int, reason: str, translation: Any, model: Type[TBase], color: int
     ):
-        entry = await get_and_compare_entry(model, entry_id, ctx.author)
+        entry = await get_database_entry(model, entry_id)
 
         if len(reason) > 900:
             raise CommandError(t.reason_too_long)
@@ -649,7 +625,7 @@ async def handle_edit_single(
         server_embed = Embed(title=translation.action, description=translation.edited_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-        await model.edit(entry_id, ctx.author.id, await get_mod_level(ctx.author), reason)
+        await model.edit(entry_id, ctx.author.id, reason)
 
         try:
             await user.send(embed=user_embed)
@@ -662,7 +638,7 @@ async def handle_edit_single(
         )
 
     async def handle_delete_single(self, ctx: Context, entry_id: int, translation, model: Type[TBase], color: int):
-        entry = await get_and_compare_entry(model, entry_id, ctx.author)
+        entry = await get_database_entry(model, entry_id)
 
         conf_embed = Embed(
             title=t.confirmation,
@@ -735,13 +711,7 @@ async def handle_timed(
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
         await model.create(
-            user.id,
-            str(user),
-            ctx.author.id,
-            await get_mod_level(ctx.author),
-            minutes if minutes is not None else -1,
-            reason,
-            evidence_url,
+            user.id, str(user), ctx.author.id, minutes if minutes is not None else -1, reason, evidence_url
         )
 
         await invalidate_entry_cache()
@@ -779,7 +749,7 @@ async def handle_timed(
     async def handle_edit_timed_reason(
         self, ctx: Context, entry_id: int, reason: str, translation: Any, model: Type[TBase], color: int
     ):
-        entry = await get_and_compare_entry(model, entry_id, ctx.author)
+        entry = await get_database_entry(model, entry_id)
 
         if len(reason) > 900:
             raise CommandError(t.reason_too_long)
@@ -806,7 +776,7 @@ async def handle_edit_timed_reason(
         server_embed = Embed(title=translation.action, description=translation.edited_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-        await model.edit_reason(entry_id, ctx.author.id, await get_mod_level(ctx.author), reason)
+        await model.edit_reason(entry_id, ctx.author.id, reason)
 
         try:
             await user.send(embed=user_embed)
@@ -834,9 +804,6 @@ async def handle_edit_timed_duration(
 
         entry = active_entries[0]
 
-        if not await compare_mod_level(ctx.author, entry.mod_level) or not ctx.author.id == entry.mod:
-            raise CommandError(tg.permission_denied)
-
         if entry.minutes == minutes or (entry.minutes == -1 and minutes is None):
             raise CommandError(translation.already_done)
 
@@ -859,7 +826,7 @@ async def handle_edit_timed_duration(
         server_embed = Embed(title=translation.action, description=translation.edited_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
 
-        await model.edit_duration(entry.id, ctx.author.id, await get_mod_level(ctx.author), minutes)
+        await model.edit_duration(entry.id, ctx.author.id, minutes)
 
         await invalidate_entry_cache()
 
@@ -886,7 +853,7 @@ async def handle_edit_timed_duration(
     async def handle_delete_timed(
         self, ctx: Context, entry_id: int, translation: Any, model: Type[TBase], color: int
     ) -> TBase | None:
-        entry = await get_and_compare_entry(model, entry_id, ctx.author)
+        entry = await get_database_entry(model, entry_id)
 
         conf_embed = Embed(
             title=t.confirmation,
@@ -956,9 +923,6 @@ async def handle_undo_timed(
 
         minutes = 0
         async for entry in await db.stream(filter_by(model, active=True, member=user.id)):
-            if not await compare_mod_level(ctx.author, entry.mod_level) or not ctx.author.id == entry.mod:
-                raise CommandError(tg.permission_denied)
-
             await model.deactivate(entry.id, ctx.author.id, reason)
 
             was_done = True
diff --git a/moderation/mod/models.py b/moderation/mod/models.py
index ccb4abbeb..e0a87616c 100644
--- a/moderation/mod/models.py
+++ b/moderation/mod/models.py
@@ -24,31 +24,16 @@ class Punishment(ModBase):
 
     @classmethod
     async def create(
-        cls,
-        member: int,
-        member_name: str,
-        mod: int | None,
-        mod_level: int | None,
-        reason: str | None,
-        evidence: str | None,
+        cls, member: int, member_name: str, mod: int | None, reason: str | None, evidence: str | None
     ) -> Punishment:
-        row = cls(
-            member=member,
-            member_name=member_name,
-            mod=mod,
-            mod_level=mod_level,
-            timestamp=utcnow(),
-            reason=reason,
-            evidence=evidence,
-        )
+        row = cls(member=member, member_name=member_name, mod=mod, timestamp=utcnow(), reason=reason, evidence=evidence)
         await db.add(row)
         return row
 
     @classmethod
-    async def edit(cls, entry_id: int, mod: int, mod_level: int, new_reason: str):
+    async def edit(cls, entry_id: int, mod: int, new_reason: str):
         row = await db.get(cls, id=entry_id)
         row.mod = mod
-        row.mod_level = mod_level
         row.reason = new_reason
 
     @classmethod

From 6bc8b4a2c7ee19cb3310ed1b1c90026fc397174e Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Sat, 25 Jun 2022 07:14:41 +0200
Subject: [PATCH 110/120] Added support for discords timeout feature

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py              | 57 ++++++++++++++++++++++++++++--
 moderation/mod/translations/en.yml |  1 +
 2 files changed, 56 insertions(+), 2 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 325fa44d1..d1699aaf6 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -54,6 +54,7 @@
 tg = t.g
 t = t.mod
 TBase = TypeVar("TBase", bound=DBBase)
+MAX_TIMEOUT = timedelta(days=28)
 
 
 # TODO
@@ -95,12 +96,19 @@ async def convert(self, ctx, argument: str) -> int | None:
 
 
 async def load_entries():
+    """
+    Loads active mute and ban entries from the database and caches them in Redis.
+    Bans and timed mutes are stored in hashes, while infinite mutes are stored in a list
+    """
+
     async def fill(db_model: Type[TBase]):
         async with redis.pipeline() as pipe:
             await pipe.delete(entry_key := f"mod_entries:{db_model.__tablename__}")
 
             async for entry in await db.stream(filter_by(db_model, active=True)):
                 if entry.minutes == -1:
+                    new_key = f"{entry_key}_inf"
+                    await pipe.rpush(new_key, str(entry.id))
                     continue
 
                 expiration_timestamp = entry.timestamp + timedelta(minutes=entry.minutes)
@@ -148,6 +156,9 @@ async def get_mute_role(guild: Guild) -> Role:
 
 
 def extract_evidence(message: Message) -> Tuple[Attachment | None, str | None]:
+    """
+    Extracts possible evidence attachments from a message
+    """
     attachments = message.attachments
     evidence = attachments[0] if attachments else None
     evidence_url = evidence.url if attachments else None
@@ -156,10 +167,16 @@ def extract_evidence(message: Message) -> Tuple[Attachment | None, str | None]:
 
 
 def show_evidence(evidence: str | None) -> str:
+    """
+    Util function to display evidences correctly
+    """
     return t.ulog.evidence(evidence) if evidence else ""
 
 
 async def get_database_entry(entry_format: Type[TBase], entry_id: int) -> TBase:
+    """
+    Loads an entry with a given id from the database
+    """
     entry = await db.get(entry_format, id=entry_id)
     if entry is None:
         raise CommandError(getattr(t.not_found, entry_format.__tablename__))
@@ -168,6 +185,9 @@ async def get_database_entry(entry_format: Type[TBase], entry_id: int) -> TBase:
 
 
 async def confirm_no_evidence(ctx: Context):
+    """
+    Function that lets the user confirm that he does not want to attach an evidence
+    """
     conf_embed = Embed(title=t.confirmation, description=t.no_evidence, color=Colors.ModTools)
 
     return await Confirmation().run(ctx, embed=conf_embed)
@@ -186,6 +206,9 @@ async def send_to_changelog_mod(
     mod: Member | User | None = None,
     original_reason: str | None = None,
 ):
+    """
+    Function that sends logging messages to the moderation log channel
+    """
     embed = Embed(title=title, colour=colour, timestamp=utcnow())
 
     if isinstance(member, tuple):
@@ -331,8 +354,12 @@ async def mod_loop(self):
             if utcnow() >= datetime.fromisoformat(await redis.hget(mute_entries_key, key)):
                 mute = await db.get(Mute, id=int(key))
 
-                if member := guild.get_member(mute.member):
+                member = guild.get_member(mute.member)
+                timeout: datetime | None = member.communication_disabled_until
+
+                if member:
                     await member.remove_roles(mute_role)
+                    await member.remove_timeout()
                 else:
                     member = mute.member, mute.member_name
 
@@ -349,6 +376,23 @@ async def mod_loop(self):
 
                 await redis.hdel(mute_entries_key, key)
 
+        for infinite_mute in await redis.lrange(
+            inf_mute_key := f"mod_entries:{Mute.__tablename__}_inf", 0, await redis.llen(inf_mute_key) - 1
+        ):
+            mute = await db.get(Mute, id=int(infinite_mute))
+
+            member = guild.get_member(mute.member)
+            timeout: datetime | None = member.communication_disabled_until
+
+            if member and infinite_mute.days == -1:
+                await member.timeout_for(MAX_TIMEOUT)
+            elif member and (
+                not timeout
+                or timeout + timedelta(seconds=2) < infinite_mute.timestamp + timedelta(days=infinite_mute.days)
+            ):
+                delta = min(infinite_mute.timestamp + timedelta(days=infinite_mute.days) - utcnow(), MAX_TIMEOUT)
+                await member.timeout_for(delta)
+
     @log_auto_kick.subscribe
     async def handle_log_auto_kick(self, member: Member):
         await Kick.create(member.id, str(member), None, None, None, None)
@@ -1040,7 +1084,11 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
 
         if isinstance(user, Member):
             await user.add_roles(mute_role)
-            await user.move_to(None)
+
+            try:
+                await user.timeout_for(min(timedelta(minutes=time), MAX_TIMEOUT) if time else MAX_TIMEOUT)
+            except Forbidden:
+                raise CommandError(t.mute.cannot)
 
     @commands.group(aliases=["mute_edit"])
     @ModPermission.mute.check
@@ -1095,6 +1143,11 @@ async def unmute_inner(context: Context, muted_user: Member | User) -> bool:
                 if mute_role is not None:
                     await muted_user.remove_roles(mute_role)
 
+                try:
+                    await user.remove_timeout()
+                except Forbidden:
+                    raise CommandError(t.mute.cannot_undo)
+
             return was_muted
 
         await self.handle_undo_timed(ctx, user, reason, t.mute, Mute, Colors.unmute, unmute_inner)
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index 328519bef..a61c07147 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -137,6 +137,7 @@ mute:
   log_deleted: ":loud_sound: Mute deleted"
   role_not_set: User could not be muted because no mute role is configured.
   cannot_assign_role: Cannot manage mute role `@{}` ({})
+  cannot_undo: This member cannot be unmuted.
 
 kick:
   action: ":x: Kick"

From 6aec0ff3cfd6139cf0e12d39e59ee5f68a044eaa Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Mon, 4 Jul 2022 07:43:08 +0200
Subject: [PATCH 111/120] Added support for discords timeout feature

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py              | 123 ++++++++++++++++++++---------
 moderation/mod/translations/en.yml |   1 +
 2 files changed, 88 insertions(+), 36 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index d1699aaf6..c4c187e39 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -60,11 +60,9 @@
 # TODO
 #  Docstring for all methods, functions and classes
 #  make all functions private, if the are not ment to be used by other
-#  use timeout function for mutes (see actual mod tools)
 #  do not require mute role, update whole code accordingly
 #  assign mute role to all muted members, when mute role gets set
 #  remove mute role from all muted members if mute role gets cleared
-#  to be continued......
 
 
 class DurationConverter(Converter):  # TODO: Move to library
@@ -107,13 +105,11 @@ async def fill(db_model: Type[TBase]):
 
             async for entry in await db.stream(filter_by(db_model, active=True)):
                 if entry.minutes == -1:
-                    new_key = f"{entry_key}_inf"
-                    await pipe.rpush(new_key, str(entry.id))
                     continue
 
                 expiration_timestamp = entry.timestamp + timedelta(minutes=entry.minutes)
 
-                await pipe.hset(entry_key, str(entry.id), str(expiration_timestamp))
+                await pipe.hset(entry_key, str(entry.id), f"{str(entry.timestamp)}_{str(expiration_timestamp)}")
 
             await pipe.expire(entry_key, CACHE_TTL)
             await pipe.execute()
@@ -128,7 +124,7 @@ async def fill(db_model: Type[TBase]):
 
 
 async def invalidate_entry_cache():
-    await redis.delete("mod_entries_loaded")
+    await redis.delete("mod_entries_loaded", "last_refreshed_inf_mutes")
 
 
 def time_to_units(minutes: int | float) -> str:
@@ -148,10 +144,20 @@ def get_func(key, value):
     return ", ".join(get_func(key, time) for key in _keys if (time := getattr(rd, key)) != 0)
 
 
-async def get_mute_role(guild: Guild) -> Role:
+async def get_mute_role(guild: Guild) -> Role | None:
+    """
+    Receive the mute role as a Role object
+    """
+
     mute_role: Role | None = guild.get_role(await RoleSettings.get("mute"))
     if not mute_role:
         await send_alert(guild, t.mute.role_not_set)
+
+    try:
+        check_role_assignable(mute_role)
+    except CommandError:
+        await send_alert(guild, t.mute.cannot_assign_role(mute_role, mute_role.id))
+
     return mute_role
 
 
@@ -264,12 +270,37 @@ async def on_ready(self):
 
     async def on_member_join(self, member: Member):
         mute_role: Role | None = member.guild.get_role(await RoleSettings.get("mute"))
-        if mute_role is None:
-            return
 
-        if await db.exists(filter_by(Mute, active=True, member=member.id)):
+        active_mutes: list[TBase] = sorted(
+            await db.all(filter_by(Mute, active=True, member=member.id)),
+            key=lambda active_entry: active_entry.timestamp,
+        )
+
+        if active_mutes:
             await member.add_roles(mute_role)
 
+            for active_mute in active_mutes[1:]:
+                await Mute.delete(active_mute.id)
+
+            mute = active_mutes[0]
+
+            try:
+                await member.timeout_for(
+                    min(mute.timestamp + timedelta(minutes=mute.minutes) - utcnow())
+                    if mute.minutes != -1
+                    else MAX_TIMEOUT
+                )
+            except Forbidden:
+                await send_alert(member.guild, t.mute.cannot_permissions)
+
+        else:
+            if member.timed_out:
+                try:
+                    await member.remove_timeout()
+                except Forbidden:
+                    await send_alert(member.guild, t.mute.cannot_permissions)
+            return
+
     async def on_member_ban(self, guild: Guild, member: Member):
         search_limit = 100
         for i in range(10, 1, -1):
@@ -311,10 +342,13 @@ async def mod_loop(self):
         guild: Guild = self.bot.guilds[0]
         await load_entries()
 
+        # Undo expired bans
         ban_keys = await redis.hkeys(ban_entries_key := f"mod_entries:{Ban.__tablename__}")
 
         for key in ban_keys:
-            if utcnow() >= datetime.fromisoformat(await redis.hget(ban_entries_key, key)):
+            stamps = await redis.hget(ban_entries_key, key)
+
+            if utcnow() >= datetime.fromisoformat(stamps.split("_")[1]):
                 ban = await db.get(Ban, id=int(key))
 
                 try:
@@ -322,7 +356,7 @@ async def mod_loop(self):
                 except NotFound:
                     user = ban.member, ban.member_name
                 except Forbidden:
-                    await send_alert(guild, t.cannot_unban_permissions)
+                    await send_alert(guild, t.ban.cannot_undo_permissions)
                     break
 
                 await Ban.deactivate(ban.id)
@@ -342,24 +376,26 @@ async def mod_loop(self):
         if mute_role is None:
             return
 
-        try:
-            check_role_assignable(mute_role)  # TODO move into get_mute_role
-        except CommandError:
-            await send_alert(guild, t.cannot_assign_mute_role(mute_role, mute_role.id))
-            return
-
+        # Undo expired mutes
         mute_keys = await redis.hkeys(mute_entries_key := f"mod_entries:{Mute.__tablename__}")
 
         for key in mute_keys:
-            if utcnow() >= datetime.fromisoformat(await redis.hget(mute_entries_key, key)):
+            stamps = (await redis.hget(ban_entries_key, key)).split("_")
+
+            if utcnow() >= (expiration_time := datetime.fromisoformat(stamps[1])):
                 mute = await db.get(Mute, id=int(key))
 
                 member = guild.get_member(mute.member)
-                timeout: datetime | None = member.communication_disabled_until
+                timeout: datetime | None = member.communication_disabled_until if member else None
 
                 if member:
                     await member.remove_roles(mute_role)
-                    await member.remove_timeout()
+
+                    try:
+                        await member.remove_timeout()
+                    except Forbidden:
+                        await send_alert(member.guild, t.mute.cannot_permissions)
+
                 else:
                     member = mute.member, mute.member_name
 
@@ -376,22 +412,37 @@ async def mod_loop(self):
 
                 await redis.hdel(mute_entries_key, key)
 
-        for infinite_mute in await redis.lrange(
-            inf_mute_key := f"mod_entries:{Mute.__tablename__}_inf", 0, await redis.llen(inf_mute_key) - 1
-        ):
-            mute = await db.get(Mute, id=int(infinite_mute))
+            elif expiration_time - datetime.fromisoformat(stamps[0]) > MAX_TIMEOUT:
+                mute = await db.get(Mute, id=int(key))
 
-            member = guild.get_member(mute.member)
-            timeout: datetime | None = member.communication_disabled_until
+                member = guild.get_member(mute.member)
+                timeout: datetime | None = member.communication_disabled_until
+
+                if member and (
+                    not timeout or timeout + timedelta(minutes=1) < mute.timestamp + timedelta(minutes=mute.minutes)
+                ):
+                    delta = min(mute.timestamp + timedelta(minutes=mute.minutes) - utcnow(), MAX_TIMEOUT)
+                    try:
+                        await member.timeout_for(delta)
+                    except Forbidden:
+                        await send_alert(member.guild, t.mute.cannot_permissions)
+                        break
+
+        # Refresh timeout time for members that are muted infinitely
+        if not await redis.exists(key_last_checked := "last_refreshed_inf_mutes") or utcnow() - datetime.fromisoformat(
+            await redis.get(key_last_checked)
+        ) > MAX_TIMEOUT - timedelta(minutes=1):
+            async for mute in await db.stream(filter_by(Mute, active=True, minutes=-1)):
+                member = guild.get_member(mute.member)
+
+                if member:
+                    try:
+                        await member.timeout_for(MAX_TIMEOUT)
+                    except Forbidden:
+                        await send_alert(member.guild, t.mute.cannot_permissions)
+                        break
 
-            if member and infinite_mute.days == -1:
-                await member.timeout_for(MAX_TIMEOUT)
-            elif member and (
-                not timeout
-                or timeout + timedelta(seconds=2) < infinite_mute.timestamp + timedelta(days=infinite_mute.days)
-            ):
-                delta = min(infinite_mute.timestamp + timedelta(days=infinite_mute.days) - utcnow(), MAX_TIMEOUT)
-                await member.timeout_for(delta)
+            await redis.setex("last_refreshed_inf_mutes", CACHE_TTL, str(utcnow()))
 
     @log_auto_kick.subscribe
     async def handle_log_auto_kick(self, member: Member):
@@ -1138,7 +1189,7 @@ async def unmute_inner(context: Context, muted_user: Member | User) -> bool:
             mute_role: Role | None = await get_mute_role(context.guild)
 
             was_muted = False
-            if isinstance(muted_user, Member) and mute_role in muted_user.roles:
+            if isinstance(muted_user, Member) and (mute_role in muted_user.roles or user.timed_out):
                 was_muted = True
                 if mute_role is not None:
                     await muted_user.remove_roles(mute_role)
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index a61c07147..54a131a3e 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -138,6 +138,7 @@ mute:
   role_not_set: User could not be muted because no mute role is configured.
   cannot_assign_role: Cannot manage mute role `@{}` ({})
   cannot_undo: This member cannot be unmuted.
+  cannot_permissions: User could not be muted because I don't have the `moderate_members` permission on this server.
 
 kick:
   action: ":x: Kick"

From 987d9ae78d8266392e8ca27b331ccf82e4de15a3 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Mon, 4 Jul 2022 07:51:29 +0200
Subject: [PATCH 112/120] Made the bot do not require a mute role anymore
 necessarily

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index c4c187e39..244aba60a 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -60,7 +60,6 @@
 # TODO
 #  Docstring for all methods, functions and classes
 #  make all functions private, if the are not ment to be used by other
-#  do not require mute role, update whole code accordingly
 #  assign mute role to all muted members, when mute role gets set
 #  remove mute role from all muted members if mute role gets cleared
 
@@ -277,7 +276,8 @@ async def on_member_join(self, member: Member):
         )
 
         if active_mutes:
-            await member.add_roles(mute_role)
+            if mute_role:
+                await member.add_roles(mute_role)
 
             for active_mute in active_mutes[1:]:
                 await Mute.delete(active_mute.id)
@@ -373,8 +373,6 @@ async def mod_loop(self):
                 )
 
         mute_role: Role | None = guild.get_role(await RoleSettings.get("mute"))
-        if mute_role is None:
-            return
 
         # Undo expired mutes
         mute_keys = await redis.hkeys(mute_entries_key := f"mod_entries:{Mute.__tablename__}")
@@ -389,7 +387,8 @@ async def mod_loop(self):
                 timeout: datetime | None = member.communication_disabled_until if member else None
 
                 if member:
-                    await member.remove_roles(mute_role)
+                    if mute_role:
+                        await member.remove_roles(mute_role)
 
                     try:
                         await member.remove_timeout()
@@ -1127,14 +1126,12 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
 
         mute_role: Role | None = await get_mute_role(ctx.guild)
 
-        if mute_role is None:
-            raise CommandError(t.mute.role_not_set)
-
         if not await self.handle_timed(ctx, user, time, reason, t.mute, Mute, Colors.mute, ""):
             return
 
         if isinstance(user, Member):
-            await user.add_roles(mute_role)
+            if mute_role:
+                await user.add_roles(mute_role)
 
             try:
                 await user.timeout_for(min(timedelta(minutes=time), MAX_TIMEOUT) if time else MAX_TIMEOUT)
@@ -1191,7 +1188,7 @@ async def unmute_inner(context: Context, muted_user: Member | User) -> bool:
             was_muted = False
             if isinstance(muted_user, Member) and (mute_role in muted_user.roles or user.timed_out):
                 was_muted = True
-                if mute_role is not None:
+                if mute_role:
                     await muted_user.remove_roles(mute_role)
 
                 try:

From d840d87dcbdb0658cc95bbb06f05795f6f21d102 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Mon, 11 Jul 2022 14:29:40 +0200
Subject: [PATCH 113/120] Added docstrings to functions

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 66 +++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 64 insertions(+), 2 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 244aba60a..230fb523a 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -58,8 +58,7 @@
 
 
 # TODO
-#  Docstring for all methods, functions and classes
-#  make all functions private, if the are not ment to be used by other
+#  make all functions private, if the are not ment to be used by other (mit _ davor )
 #  assign mute role to all muted members, when mute role gets set
 #  remove mute role from all muted members if mute role gets cleared
 
@@ -123,6 +122,9 @@ async def fill(db_model: Type[TBase]):
 
 
 async def invalidate_entry_cache():
+    """
+    Removes some keys from redis so the mod loop knows when it needs to reload the entries from the database
+    """
     await redis.delete("mod_entries_loaded", "last_refreshed_inf_mutes")
 
 
@@ -339,6 +341,9 @@ async def on_member_ban(self, guild: Guild, member: Member):
     @tasks.loop(minutes=1)
     @db_wrapper
     async def mod_loop(self):
+        """
+        function that removes expired punishments and refreshes timeouts
+        """
         guild: Guild = self.bot.guilds[0]
         await load_entries()
 
@@ -449,6 +454,9 @@ async def handle_log_auto_kick(self, member: Member):
 
     @get_user_info_entries.subscribe
     async def handle_get_user_stats_entries(self, user_id: int) -> list[tuple[str, str]]:
+        """
+        function to retrieve mod related user statistics
+        """
         out: list[tuple[str, str]] = []
 
         async def count(cls):
@@ -475,6 +483,9 @@ async def count(cls):
 
     @get_user_status_entries.subscribe
     async def handle_get_user_status_entries(self, user_id: int) -> list[tuple[str, str]]:
+        """
+        function to retrieve some mod related status information about a user
+        """
         status = t.none
         if (ban := await db.get(Ban, member=user_id, active=True)) is not None:
             if ban.minutes != -1:
@@ -496,9 +507,16 @@ async def handle_get_user_status_entries(self, user_id: int) -> list[tuple[str,
     async def handle_get_userlog_entries(
         self, user_id: int, show_ids: bool, author: Member
     ) -> list[tuple[datetime, str]]:
+        """
+        function to retrieve mod related logs for a user
+        """
+
         def wrap_time_entry(
             translation, mod: int, reason: str, evidence: str, minutes: int | None = None, entry_id: int | None = None
         ) -> str:
+            """
+            function to process a duration-based punishment for the user log
+            """
             args = [f"<@{mod}>"]
 
             if minutes:
@@ -520,6 +538,9 @@ def wrap_time_entry(
             return translation(*args)
 
         def wrap_entry(translation, user: int, reason: str, evidence: str | None, entry_id: int | None = None) -> str:
+            """
+            function to process a non duration-based punishment for the user log
+            """
             if entry_id:
                 return translation.id_on(f"<@{user}>", reason, entry_id, show_evidence(evidence))
             else:
@@ -637,6 +658,10 @@ def wrap_entry(translation, user: int, reason: str, evidence: str | None, entry_
     @ModPermission.modtools_write.check
     @docs(t.commands.send_delete_message)
     async def send_delete_message(self, ctx: Context, send: bool | None = None):
+        """
+        command to set whether the user should receive an information
+        about how a punishment concerning him has been deleted
+        """
         embed = Embed(title=t.modtools, color=Colors.ModTools)
 
         if send is None:
@@ -652,6 +677,10 @@ async def send_delete_message(self, ctx: Context, send: bool | None = None):
     async def handle_single(
         self, ctx: Context, user: User | Member, reason: str, translation: Any, model: Type[TBase], color: int
     ) -> bool:
+        """
+        function to handle the execution of non duration-based punishments
+        (wrapper for kicks and warns)
+        """
         user: Member | User
 
         if len(reason) > 900:
@@ -696,6 +725,10 @@ async def handle_single(
     async def handle_edit_single(
         self, ctx: Context, entry_id: int, reason: str, translation: Any, model: Type[TBase], color: int
     ):
+        """
+        function to handle changes to non duration-based punishments
+        (wrapper for kick and warn edits)
+        """
         entry = await get_database_entry(model, entry_id)
 
         if len(reason) > 900:
@@ -732,6 +765,10 @@ async def handle_edit_single(
         )
 
     async def handle_delete_single(self, ctx: Context, entry_id: int, translation, model: Type[TBase], color: int):
+        """
+        function to handle deletions of non duration-based punishments
+        (wrapper for kick and warn deletions)
+        """
         entry = await get_database_entry(model, entry_id)
 
         conf_embed = Embed(
@@ -785,6 +822,11 @@ async def handle_timed(
         color: int,
         embed_addition: str,
     ) -> bool:
+        """
+        function to handle the execution of duration-based punishments
+        (wrapper for mutes and bans)
+        """
+
         time: int | None
         minutes = time
 
@@ -843,6 +885,11 @@ async def handle_timed(
     async def handle_edit_timed_reason(
         self, ctx: Context, entry_id: int, reason: str, translation: Any, model: Type[TBase], color: int
     ):
+        """
+        function to handle changes to teh reasons of duration-based punishments
+        (wrapper for mute and ban edits)
+        """
+
         entry = await get_database_entry(model, entry_id)
 
         if len(reason) > 900:
@@ -885,6 +932,11 @@ async def handle_edit_timed_reason(
     async def handle_edit_timed_duration(
         self, ctx: Context, user: User | Member, time: int | None, translation: Any, model: Type[TBase], color: int
     ):
+        """
+        function to handle changes to the duration of duration-based punishments
+        (wrapper for mute and ban edits)
+        """
+
         user: Member | User
         time: int | None
         minutes = time
@@ -947,6 +999,11 @@ async def handle_edit_timed_duration(
     async def handle_delete_timed(
         self, ctx: Context, entry_id: int, translation: Any, model: Type[TBase], color: int
     ) -> TBase | None:
+        """
+        function to handle deletions of duration-based punishments
+        (wrapper for mute and ban deletions)
+        """
+
         entry = await get_database_entry(model, entry_id)
 
         conf_embed = Embed(
@@ -1008,6 +1065,11 @@ async def handle_undo_timed(
         color: int,
         undo_function: Callable[[Context, Member | User], Awaitable[bool]],
     ):
+        """
+        function to handle revocations of duration-based punishments
+        (wrapper for unmute/unban)
+        """
+
         user: Member | User
 
         if len(reason) > 900:

From 6d515a49646f80fb9ea475da8da3cc7e894608bb Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Mon, 11 Jul 2022 16:47:23 +0200
Subject: [PATCH 114/120] Added pubsub for role updates and made mod cog assign
 mute role automatically when it is set. also fixed some minor bugs
 (misspelled variable)

Signed-off-by: LoC <loc@locrealloc.de>
---
 administration/roles/cog.py        |  3 ++-
 moderation/mod/cog.py              | 25 +++++++++++++++++++------
 moderation/mod/models.py           |  4 +---
 moderation/mod/translations/en.yml |  2 +-
 pubsub.md                          | 20 ++++++++++++++++++++
 pubsub.py                          |  1 +
 6 files changed, 44 insertions(+), 11 deletions(-)

diff --git a/administration/roles/cog.py b/administration/roles/cog.py
index 92f8fc647..f1cbd91f4 100644
--- a/administration/roles/cog.py
+++ b/administration/roles/cog.py
@@ -20,7 +20,7 @@
 from .models import PermaRole, RoleAuth
 from .permissions import RolesPermission
 from ...contributor import Contributor
-from ...pubsub import send_alert, send_to_changelog
+from ...pubsub import role_updated, send_alert, send_to_changelog
 
 
 tg = t.g
@@ -32,6 +32,7 @@ async def configure_role(ctx: Context, role_name: str, role: Role, check_assigna
         check_role_assignable(role)
 
     await RoleSettings.set(role_name, role.id)
+    await role_updated(role=role, role_name=role_name)
     await reply(ctx, t.role_set)
     await send_to_changelog(ctx.guild, t.log_role_set(Config.ROLES[role_name][0], role.name, role.id))
 
diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 230fb523a..5a9be76ac 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -46,6 +46,7 @@
     get_userlog_entries,
     log_auto_kick,
     revoke_verification,
+    role_updated,
     send_alert,
     send_to_changelog,
 )
@@ -59,8 +60,6 @@
 
 # TODO
 #  make all functions private, if the are not ment to be used by other (mit _ davor )
-#  assign mute role to all muted members, when mute role gets set
-#  remove mute role from all muted members if mute role gets cleared
 
 
 class DurationConverter(Converter):  # TODO: Move to library
@@ -75,10 +74,10 @@ async def convert(self, ctx, argument: str) -> int | None:
             raise BadArgument(t.duration_suffixes)
 
         years, months, weeks, days, hours, minutes = [
-            0 if (value := match.group(i)) is None else int(value[:-1]) for i in range(1, 5)
+            0 if (value := match.group(i)) is None else int(value[:-1]) for i in range(1, 7)
         ]
 
-        years += days * 365
+        days += years * 365
         days += months * 30
         days += weeks * 7
         td = timedelta(days=days, hours=hours, minutes=minutes)
@@ -153,11 +152,13 @@ async def get_mute_role(guild: Guild) -> Role | None:
     mute_role: Role | None = guild.get_role(await RoleSettings.get("mute"))
     if not mute_role:
         await send_alert(guild, t.mute.role_not_set)
+        return None
 
     try:
         check_role_assignable(mute_role)
     except CommandError:
         await send_alert(guild, t.mute.cannot_assign_role(mute_role, mute_role.id))
+        return None
 
     return mute_role
 
@@ -377,13 +378,13 @@ async def mod_loop(self):
                     reason=t.ban.log_undo_expired,
                 )
 
-        mute_role: Role | None = guild.get_role(await RoleSettings.get("mute"))
+        mute_role: Role | None = await get_mute_role(guild)
 
         # Undo expired mutes
         mute_keys = await redis.hkeys(mute_entries_key := f"mod_entries:{Mute.__tablename__}")
 
         for key in mute_keys:
-            stamps = (await redis.hget(ban_entries_key, key)).split("_")
+            stamps = (await redis.hget(mute_entries_key, key)).split("_")
 
             if utcnow() >= (expiration_time := datetime.fromisoformat(stamps[1])):
                 mute = await db.get(Mute, id=int(key))
@@ -448,6 +449,18 @@ async def mod_loop(self):
 
             await redis.setex("last_refreshed_inf_mutes", CACHE_TTL, str(utcnow()))
 
+    @role_updated.subscribe
+    async def handle_role_update(self, role: Role, role_name: str):
+        if role_name != "mute":
+            return
+
+        guild: Guild = self.bot.guilds[0]
+        async for mute in await db.stream(filter_by(Mute, active=True)):
+            member = guild.get_member(mute.member)
+            print(member)
+            if member:
+                await member.add_roles(role)
+
     @log_auto_kick.subscribe
     async def handle_log_auto_kick(self, member: Member):
         await Kick.create(member.id, str(member), None, None, None, None)
diff --git a/moderation/mod/models.py b/moderation/mod/models.py
index e0a87616c..00a8a5cb1 100644
--- a/moderation/mod/models.py
+++ b/moderation/mod/models.py
@@ -44,7 +44,6 @@ async def delete(cls, entry_id: int):
 
 class TimedPunishment(ModBase):
     mod: Column | int = Column(BigInteger)
-    mod_level: Column | int = Column(Integer)
     minutes: Column | int = Column(Integer)
     active: Column | bool = Column(Boolean)
     deactivation_timestamp: Column | datetime | None = Column(UTCDateTime, nullable=True)
@@ -53,13 +52,12 @@ class TimedPunishment(ModBase):
 
     @classmethod
     async def create(
-        cls, member: int, member_name: str, mod: int, mod_level: int, minutes: int, reason: str, evidence: str | None
+        cls, member: int, member_name: str, mod: int, minutes: int, reason: str, evidence: str | None
     ) -> TimedPunishment:
         row = cls(
             member=member,
             member_name=member_name,
             mod=mod,
-            mod_level=mod_level,
             timestamp=utcnow(),
             minutes=minutes,
             reason=reason,
diff --git a/moderation/mod/translations/en.yml b/moderation/mod/translations/en.yml
index 54a131a3e..fe685a8dc 100644
--- a/moderation/mod/translations/en.yml
+++ b/moderation/mod/translations/en.yml
@@ -135,7 +135,7 @@ mute:
     not_inf: Your mute for {} with the reason ```\n{}\n``` has been deleted"
   deleted_response: ":white_check_mark: The mute has been deleted"
   log_deleted: ":loud_sound: Mute deleted"
-  role_not_set: User could not be muted because no mute role is configured.
+  role_not_set: No mute role is configured.
   cannot_assign_role: Cannot manage mute role `@{}` ({})
   cannot_undo: This member cannot be unmuted.
   cannot_permissions: User could not be muted because I don't have the `moderate_members` permission on this server.
diff --git a/pubsub.md b/pubsub.md
index 77585dde4..65ce22f39 100644
--- a/pubsub.md
+++ b/pubsub.md
@@ -181,3 +181,23 @@ Returns: `None`
 Subscriptions:
 
 - [Logging](/cogs/moderation/logging)
+
+
+## `role_updated`
+
+Use this PubSub to inform about role changes
+
+```python
+async def role_updated(role: Role, role_name: str) -> []
+```
+
+Arguments:
+
+- `role`: The new role
+- `role_name`: The internal role name
+
+Returns: `None`
+
+Subscriptions:
+
+- [Mod Tools](/cogs/moderation/mod)
diff --git a/pubsub.py b/pubsub.py
index 9c6a9fc7c..3e4485432 100644
--- a/pubsub.py
+++ b/pubsub.py
@@ -11,3 +11,4 @@
 can_respond_on_reaction = PubSubChannel()
 ignore_message_edit = PubSubChannel()
 ignore_message_delete = PubSubChannel()
+role_updated = PubSubChannel()

From bc97b64cd25b2e7e6aeb20786ff75d8f58506496 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Mon, 11 Jul 2022 16:52:12 +0200
Subject: [PATCH 115/120] Made functions private

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 158 +++++++++++++++++++++---------------------
 1 file changed, 79 insertions(+), 79 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 5a9be76ac..4fea6baa4 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -90,7 +90,7 @@ async def convert(self, ctx, argument: str) -> int | None:
         return duration
 
 
-async def load_entries():
+async def _load_entries():
     """
     Loads active mute and ban entries from the database and caches them in Redis.
     Bans and timed mutes are stored in hashes, while infinite mutes are stored in a list
@@ -120,14 +120,14 @@ async def fill(db_model: Type[TBase]):
     await redis.setex("mod_entries_loaded", CACHE_TTL, 1)
 
 
-async def invalidate_entry_cache():
+async def _invalidate_entry_cache():
     """
     Removes some keys from redis so the mod loop knows when it needs to reload the entries from the database
     """
     await redis.delete("mod_entries_loaded", "last_refreshed_inf_mutes")
 
 
-def time_to_units(minutes: int | float) -> str:
+def _time_to_units(minutes: int | float) -> str:
     """
     Util function to split minutes back into different time units
     """
@@ -144,7 +144,7 @@ def get_func(key, value):
     return ", ".join(get_func(key, time) for key in _keys if (time := getattr(rd, key)) != 0)
 
 
-async def get_mute_role(guild: Guild) -> Role | None:
+async def _get_mute_role(guild: Guild) -> Role | None:
     """
     Receive the mute role as a Role object
     """
@@ -163,7 +163,7 @@ async def get_mute_role(guild: Guild) -> Role | None:
     return mute_role
 
 
-def extract_evidence(message: Message) -> Tuple[Attachment | None, str | None]:
+def _extract_evidence(message: Message) -> Tuple[Attachment | None, str | None]:
     """
     Extracts possible evidence attachments from a message
     """
@@ -174,14 +174,14 @@ def extract_evidence(message: Message) -> Tuple[Attachment | None, str | None]:
     return evidence, evidence_url
 
 
-def show_evidence(evidence: str | None) -> str:
+def _show_evidence(evidence: str | None) -> str:
     """
     Util function to display evidences correctly
     """
     return t.ulog.evidence(evidence) if evidence else ""
 
 
-async def get_database_entry(entry_format: Type[TBase], entry_id: int) -> TBase:
+async def _get_database_entry(entry_format: Type[TBase], entry_id: int) -> TBase:
     """
     Loads an entry with a given id from the database
     """
@@ -192,7 +192,7 @@ async def get_database_entry(entry_format: Type[TBase], entry_id: int) -> TBase:
     return entry
 
 
-async def confirm_no_evidence(ctx: Context):
+async def _confirm_no_evidence(ctx: Context):
     """
     Function that lets the user confirm that he does not want to attach an evidence
     """
@@ -201,7 +201,7 @@ async def confirm_no_evidence(ctx: Context):
     return await Confirmation().run(ctx, embed=conf_embed)
 
 
-async def send_to_changelog_mod(
+async def _send_to_changelog_mod(
     guild: Guild,
     message: Message | None,
     colour: int,
@@ -319,7 +319,7 @@ async def on_member_ban(self, guild: Guild, member: Member):
                     if entry.reason:
                         await Ban.create(entry.target.id, str(entry.target), entry.user.id, -1, entry.reason, None)
 
-                        await send_to_changelog_mod(
+                        await _send_to_changelog_mod(
                             guild=guild,
                             message=None,
                             colour=Colors.ban,
@@ -346,7 +346,7 @@ async def mod_loop(self):
         function that removes expired punishments and refreshes timeouts
         """
         guild: Guild = self.bot.guilds[0]
-        await load_entries()
+        await _load_entries()
 
         # Undo expired bans
         ban_keys = await redis.hkeys(ban_entries_key := f"mod_entries:{Ban.__tablename__}")
@@ -369,7 +369,7 @@ async def mod_loop(self):
 
                 await redis.hdel(ban_entries_key, key)
 
-                await send_to_changelog_mod(
+                await _send_to_changelog_mod(
                     guild=guild,
                     message=None,
                     colour=Colors.unban,
@@ -378,7 +378,7 @@ async def mod_loop(self):
                     reason=t.ban.log_undo_expired,
                 )
 
-        mute_role: Role | None = await get_mute_role(guild)
+        mute_role: Role | None = await _get_mute_role(guild)
 
         # Undo expired mutes
         mute_keys = await redis.hkeys(mute_entries_key := f"mod_entries:{Mute.__tablename__}")
@@ -404,7 +404,7 @@ async def mod_loop(self):
                 else:
                     member = mute.member, mute.member_name
 
-                await send_to_changelog_mod(
+                await _send_to_changelog_mod(
                     guild=guild,
                     message=None,
                     colour=Colors.unmute,
@@ -503,15 +503,15 @@ async def handle_get_user_status_entries(self, user_id: int) -> list[tuple[str,
         if (ban := await db.get(Ban, member=user_id, active=True)) is not None:
             if ban.minutes != -1:
                 expiry_date: datetime = ban.timestamp + timedelta(minutes=ban.minutes)
-                time_left = time_to_units((expiry_date - utcnow()).total_seconds() / 60 + 1)
-                status = t.status_banned_time(time_to_units(ban.minutes), time_left)
+                time_left = _time_to_units((expiry_date - utcnow()).total_seconds() / 60 + 1)
+                status = t.status_banned_time(_time_to_units(ban.minutes), time_left)
             else:
                 status = t.status_banned
         elif (mute := await db.get(Mute, member=user_id, active=True)) is not None:
             if mute.minutes != -1:
                 expiry_date: datetime = mute.timestamp + timedelta(minutes=mute.minutes)
-                time_left = time_to_units((expiry_date - utcnow()).total_seconds() / 60 + 1)
-                status = t.status_muted_time(time_to_units(mute.minutes), time_left)
+                time_left = _time_to_units((expiry_date - utcnow()).total_seconds() / 60 + 1)
+                status = t.status_muted_time(_time_to_units(mute.minutes), time_left)
             else:
                 status = t.status_muted
         return [(t.active_sanctions, status)]
@@ -534,7 +534,7 @@ def wrap_time_entry(
 
             if minutes:
                 translation = translation.temp
-                args.append(time_to_units(minutes))
+                args.append(_time_to_units(minutes))
             else:
                 translation = translation.inf
 
@@ -546,7 +546,7 @@ def wrap_time_entry(
             else:
                 translation = translation.id_off
 
-            args.append(show_evidence(evidence))
+            args.append(_show_evidence(evidence))
 
             return translation(*args)
 
@@ -555,9 +555,9 @@ def wrap_entry(translation, user: int, reason: str, evidence: str | None, entry_
             function to process a non duration-based punishment for the user log
             """
             if entry_id:
-                return translation.id_on(f"<@{user}>", reason, entry_id, show_evidence(evidence))
+                return translation.id_on(f"<@{user}>", reason, entry_id, _show_evidence(evidence))
             else:
-                return translation.id_off(f"<@{user}>", reason, show_evidence(evidence))
+                return translation.id_off(f"<@{user}>", reason, _show_evidence(evidence))
 
         out: list[tuple[datetime, str]] = []
 
@@ -687,7 +687,7 @@ async def send_delete_message(self, ctx: Context, send: bool | None = None):
         await reply(ctx, embed=embed)
         await send_to_changelog(ctx.guild, t.configured_send_delete_message[send])
 
-    async def handle_single(
+    async def _handle_single(
         self, ctx: Context, user: User | Member, reason: str, translation: Any, model: Type[TBase], color: int
     ) -> bool:
         """
@@ -702,10 +702,10 @@ async def handle_single(
         if user == self.bot.user:
             raise UserCommandError(user, translation.cannot)
 
-        evidence, evidence_url = extract_evidence(ctx.message)
+        evidence, evidence_url = _extract_evidence(ctx.message)
 
         if not evidence:
-            if not await confirm_no_evidence(ctx):
+            if not await _confirm_no_evidence(ctx):
                 return False
 
         user_embed = Embed(
@@ -723,7 +723,7 @@ async def handle_single(
             server_embed.colour = Colors.error
         await model.create(user.id, str(user), ctx.author.id, reason, evidence_url)
         await reply(ctx, embed=server_embed)
-        await send_to_changelog_mod(
+        await _send_to_changelog_mod(
             guild=ctx.guild,
             message=ctx.message,
             colour=color,
@@ -735,14 +735,14 @@ async def handle_single(
 
         return True
 
-    async def handle_edit_single(
+    async def _handle_edit_single(
         self, ctx: Context, entry_id: int, reason: str, translation: Any, model: Type[TBase], color: int
     ):
         """
         function to handle changes to non duration-based punishments
         (wrapper for kick and warn edits)
         """
-        entry = await get_database_entry(model, entry_id)
+        entry = await _get_database_entry(model, entry_id)
 
         if len(reason) > 900:
             raise CommandError(t.reason_too_long)
@@ -773,16 +773,16 @@ async def handle_edit_single(
             server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
             server_embed.colour = Colors.error
         await reply(ctx, embed=server_embed)
-        await send_to_changelog_mod(
+        await _send_to_changelog_mod(
             guild=ctx.guild, message=ctx.message, colour=color, title=translation.log_edited, member=user, reason=reason
         )
 
-    async def handle_delete_single(self, ctx: Context, entry_id: int, translation, model: Type[TBase], color: int):
+    async def _handle_delete_single(self, ctx: Context, entry_id: int, translation, model: Type[TBase], color: int):
         """
         function to handle deletions of non duration-based punishments
         (wrapper for kick and warn deletions)
         """
-        entry = await get_database_entry(model, entry_id)
+        entry = await _get_database_entry(model, entry_id)
 
         conf_embed = Embed(
             title=t.confirmation,
@@ -815,7 +815,7 @@ async def handle_delete_single(self, ctx: Context, entry_id: int, translation, m
                 server_embed.colour = Colors.error
 
         await reply(ctx, embed=server_embed)
-        await send_to_changelog_mod(
+        await _send_to_changelog_mod(
             guild=ctx.guild,
             message=ctx.message,
             colour=color,
@@ -824,7 +824,7 @@ async def handle_delete_single(self, ctx: Context, entry_id: int, translation, m
             reason=entry.reason,
         )
 
-    async def handle_timed(
+    async def _handle_timed(
         self,
         ctx: Context,
         user: Member | User,
@@ -849,10 +849,10 @@ async def handle_timed(
         if await db.exists(filter_by(model, active=True, member=user.id)):
             raise UserCommandError(user, translation.already_done)
 
-        evidence, evidence_url = extract_evidence(ctx.message)
+        evidence, evidence_url = _extract_evidence(ctx.message)
 
         if not evidence:
-            if not await confirm_no_evidence(ctx):
+            if not await _confirm_no_evidence(ctx):
                 return False
 
         user_embed = Embed(title=translation.action, colour=Colors.ModTools)
@@ -863,22 +863,22 @@ async def handle_timed(
             user.id, str(user), ctx.author.id, minutes if minutes is not None else -1, reason, evidence_url
         )
 
-        await invalidate_entry_cache()
+        await _invalidate_entry_cache()
 
-        await send_to_changelog_mod(
+        await _send_to_changelog_mod(
             guild=ctx.guild,
             message=ctx.message,
             colour=color,
             title=translation.log,
             member=user,
             reason=reason,
-            duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
+            duration=_time_to_units(minutes) if minutes is not None else t.log_field.infinity,
             evidence=evidence,
         )
 
         if minutes is not None:
             user_embed.description = translation.done(
-                ctx.author.mention, ctx.guild.name, time_to_units(minutes), reason
+                ctx.author.mention, ctx.guild.name, _time_to_units(minutes), reason
             )
         else:
             user_embed.description = translation.done_inf(ctx.author.mention, ctx.guild.name, reason)
@@ -895,7 +895,7 @@ async def handle_timed(
 
         return True
 
-    async def handle_edit_timed_reason(
+    async def _handle_edit_timed_reason(
         self, ctx: Context, entry_id: int, reason: str, translation: Any, model: Type[TBase], color: int
     ):
         """
@@ -903,7 +903,7 @@ async def handle_edit_timed_reason(
         (wrapper for mute and ban edits)
         """
 
-        entry = await get_database_entry(model, entry_id)
+        entry = await _get_database_entry(model, entry_id)
 
         if len(reason) > 900:
             raise CommandError(t.reason_too_long)
@@ -938,11 +938,11 @@ async def handle_edit_timed_reason(
             server_embed.description = f"{t.no_dm}\n\n{server_embed.description}"
             server_embed.colour = Colors.error
         await reply(ctx, embed=server_embed)
-        await send_to_changelog_mod(
+        await _send_to_changelog_mod(
             guild=ctx.guild, message=ctx.message, colour=color, title=translation.log_edited, member=user, reason=reason
         )
 
-    async def handle_edit_timed_duration(
+    async def _handle_edit_timed_duration(
         self, ctx: Context, user: User | Member, time: int | None, translation: Any, model: Type[TBase], color: int
     ):
         """
@@ -968,12 +968,12 @@ async def handle_edit_timed_duration(
 
         conf_embed = Embed(title=t.confirmation, color=Colors.ModTools)
 
-        old_time = t.infinity if entry.minutes == -1 else time_to_units(entry.minutes)
+        old_time = t.infinity if entry.minutes == -1 else _time_to_units(entry.minutes)
 
         if minutes is None:
             conf_embed.description = translation.confirm_edit.duration(old_time, t.infinity)
         else:
-            conf_embed.description = translation.confirm_edit.duration(old_time, time_to_units(minutes))
+            conf_embed.description = translation.confirm_edit.duration(old_time, _time_to_units(minutes))
 
         if not await Confirmation().run(ctx, embed=conf_embed):
             return
@@ -987,19 +987,19 @@ async def handle_edit_timed_duration(
 
         await model.edit_duration(entry.id, ctx.author.id, minutes)
 
-        await invalidate_entry_cache()
+        await _invalidate_entry_cache()
 
         user_embed.description = translation.edited.duration(
-            time_to_units(entry.minutes), t.infinity if minutes is None else time_to_units(minutes)
+            _time_to_units(entry.minutes), t.infinity if minutes is None else _time_to_units(minutes)
         )
-        await send_to_changelog_mod(
+        await _send_to_changelog_mod(
             guild=ctx.guild,
             message=ctx.message,
             colour=color,
             title=translation.log_edited,
             member=user,
             reason=entry.reason,
-            duration=t.log_field.infinity if minutes is None else time_to_units(minutes),
+            duration=t.log_field.infinity if minutes is None else _time_to_units(minutes),
         )
 
         try:
@@ -1009,7 +1009,7 @@ async def handle_edit_timed_duration(
             server_embed.colour = Colors.error
         await reply(ctx, embed=server_embed)
 
-    async def handle_delete_timed(
+    async def _handle_delete_timed(
         self, ctx: Context, entry_id: int, translation: Any, model: Type[TBase], color: int
     ) -> TBase | None:
         """
@@ -1017,7 +1017,7 @@ async def handle_delete_timed(
         (wrapper for mute and ban deletions)
         """
 
-        entry = await get_database_entry(model, entry_id)
+        entry = await _get_database_entry(model, entry_id)
 
         conf_embed = Embed(
             title=t.confirmation,
@@ -1035,7 +1035,7 @@ async def handle_delete_timed(
 
         await model.delete(entry_id)
 
-        await invalidate_entry_cache()
+        await _invalidate_entry_cache()
 
         server_embed = Embed(title=translation.action, description=translation.deleted_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
@@ -1046,7 +1046,7 @@ async def handle_delete_timed(
             if entry.minutes == -1:
                 user_embed.description = translation.deleted.inf(entry.reason)
             else:
-                user_embed.description = translation.deleted.not_inf(time_to_units(entry.minutes), entry.reason)
+                user_embed.description = translation.deleted.not_inf(_time_to_units(entry.minutes), entry.reason)
 
             try:
                 await user.send(embed=user_embed)
@@ -1056,19 +1056,19 @@ async def handle_delete_timed(
 
         await reply(ctx, embed=server_embed)
 
-        await send_to_changelog_mod(
+        await _send_to_changelog_mod(
             guild=ctx.guild,
             message=ctx.message,
             colour=color,
             title=translation.log_deleted,
             member=user,
             reason=entry.reason,
-            duration=t.log_field_infinity if entry.minutes == -1 else time_to_units(entry.minutes),
+            duration=t.log_field_infinity if entry.minutes == -1 else _time_to_units(entry.minutes),
         )
 
         return entry
 
-    async def handle_undo_timed(
+    async def _handle_undo_timed(
         self,
         ctx: Context,
         user: User | Member,
@@ -1102,20 +1102,20 @@ async def handle_undo_timed(
         if not was_done:
             raise UserCommandError(user, translation.not_done)
 
-        await invalidate_entry_cache()
+        await _invalidate_entry_cache()
 
         server_embed = Embed(title=translation.undo, description=translation.undo_response, colour=Colors.ModTools)
         server_embed.set_author(name=str(user), icon_url=user.display_avatar.url)
         await reply(ctx, embed=server_embed)
 
-        await send_to_changelog_mod(
+        await _send_to_changelog_mod(
             guild=ctx.guild,
             message=ctx.message,
             colour=color,
             title=translation.log_undo,
             member=user,
             reason=reason,
-            duration=time_to_units(minutes) if minutes is not None else t.log_field.infinity,
+            duration=_time_to_units(minutes) if minutes is not None else t.log_field.infinity,
             mod=ctx.author,
             original_reason=entry.reason,
         )
@@ -1140,7 +1140,7 @@ async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         if not await Confirmation().run(ctx, embed=conf_embed):
             return
 
-        evidence, evidence_url = extract_evidence(ctx.message)
+        evidence, evidence_url = _extract_evidence(ctx.message)
 
         await Report.create(user.id, str(user), ctx.author.id, reason, evidence_url)
         server_embed = Embed(title=t.report, description=t.reported_response, colour=Colors.ModTools)
@@ -1172,21 +1172,21 @@ async def report(self, ctx: Context, user: UserMemberConverter, *, reason: str):
     async def warn(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         user: User | Member
 
-        await self.handle_single(ctx, user, reason, t.warn, Warn, Colors.warn)
+        await self._handle_single(ctx, user, reason, t.warn, Warn, Colors.warn)
 
     @commands.command(aliases=["warn_edit"])
     @ModPermission.warn.check
     @guild_only()
     @docs(t.commands.edit_warn)
     async def edit_warn(self, ctx: Context, warn_id: int, *, reason: str):
-        await self.handle_edit_single(ctx, warn_id, reason, t.warn, Warn, Colors.warn)
+        await self._handle_edit_single(ctx, warn_id, reason, t.warn, Warn, Colors.warn)
 
     @commands.command(aliases=["warn_delete"])
     @ModPermission.warn.check
     @guild_only()
     @docs(t.commands.delete_warn)
     async def delete_warn(self, ctx: Context, warn_id: int):
-        await self.handle_delete_single(ctx, warn_id, t.warn, Warn, Colors.warn)
+        await self._handle_delete_single(ctx, warn_id, t.warn, Warn, Colors.warn)
 
     @commands.command()
     @ModPermission.mute.check
@@ -1199,9 +1199,9 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
         if user == self.bot.user or await is_teamler(user):
             raise UserCommandError(user, t.mute.cannot)
 
-        mute_role: Role | None = await get_mute_role(ctx.guild)
+        mute_role: Role | None = await _get_mute_role(ctx.guild)
 
-        if not await self.handle_timed(ctx, user, time, reason, t.mute, Mute, Colors.mute, ""):
+        if not await self._handle_timed(ctx, user, time, reason, t.mute, Mute, Colors.mute, ""):
             return
 
         if isinstance(user, Member):
@@ -1224,7 +1224,7 @@ async def edit_mute(self, ctx):
     @edit_mute.command(name="reason", aliases=["r"])
     @docs(t.commands.edit_mute_reason)
     async def edit_mute_reason(self, ctx: Context, mute_id: int, *, reason: str):
-        await self.handle_edit_timed_reason(ctx, mute_id, reason, t.mute, Mute, Colors.mute)
+        await self._handle_edit_timed_reason(ctx, mute_id, reason, t.mute, Mute, Colors.mute)
 
     @edit_mute.command(name="duration", aliases=["d"])
     @docs(t.commands.edit_mute_duration)
@@ -1232,14 +1232,14 @@ async def edit_mute_duration(self, ctx: Context, user: UserMemberConverter, time
         user: User | Member
         time: int | None
 
-        await self.handle_edit_timed_duration(ctx, user, time, t.mute, Mute, Colors.mute)
+        await self._handle_edit_timed_duration(ctx, user, time, t.mute, Mute, Colors.mute)
 
     @commands.command(aliases=["mute_delete"])
     @ModPermission.mute.check
     @guild_only()
     @docs(t.commands.delete_mute)
     async def delete_mute(self, ctx: Context, mute_id: int):
-        if not (mute := await self.handle_delete_timed(ctx, mute_id, t.mute, Mute, Colors.mute)):
+        if not (mute := await self._handle_delete_timed(ctx, mute_id, t.mute, Mute, Colors.mute)):
             return
 
         active_mutes: list[Mute] = await db.all(filter_by(Mute, active=True, member=mute.member))
@@ -1247,7 +1247,7 @@ async def delete_mute(self, ctx: Context, mute_id: int):
         if len(active_mutes) == 1 and mute in active_mutes:
             user = ctx.guild.get_member(mute.member)
             if user is not None:
-                if (mute_role := await get_mute_role(ctx.guild)) in user.roles:
+                if (mute_role := await _get_mute_role(ctx.guild)) in user.roles:
                     await user.remove_roles(mute_role)
 
     @commands.command()
@@ -1258,7 +1258,7 @@ async def unmute(self, ctx: Context, user: UserMemberConverter, *, reason: str):
         user: User | Member
 
         async def unmute_inner(context: Context, muted_user: Member | User) -> bool:
-            mute_role: Role | None = await get_mute_role(context.guild)
+            mute_role: Role | None = await _get_mute_role(context.guild)
 
             was_muted = False
             if isinstance(muted_user, Member) and (mute_role in muted_user.roles or user.timed_out):
@@ -1273,7 +1273,7 @@ async def unmute_inner(context: Context, muted_user: Member | User) -> bool:
 
             return was_muted
 
-        await self.handle_undo_timed(ctx, user, reason, t.mute, Mute, Colors.unmute, unmute_inner)
+        await self._handle_undo_timed(ctx, user, reason, t.mute, Mute, Colors.unmute, unmute_inner)
 
     @commands.command()
     @ModPermission.kick.check
@@ -1289,7 +1289,7 @@ async def kick(self, ctx: Context, member: Member, *, reason: str):
         if member.top_role >= ctx.guild.me.top_role or member.id == ctx.guild.owner_id:
             raise UserCommandError(member, t.cannot_kick)
 
-        if not self.handle_single(ctx, member, reason, t.kick, Kick, Colors.kick):
+        if not self._handle_single(ctx, member, reason, t.kick, Kick, Colors.kick):
             return
 
         await member.kick(reason=reason)
@@ -1300,14 +1300,14 @@ async def kick(self, ctx: Context, member: Member, *, reason: str):
     @guild_only()
     @docs(t.commands.edit_kick)
     async def edit_kick(self, ctx: Context, kick_id: int, *, reason: str):
-        await self.handle_edit_single(ctx, kick_id, reason, t.kick, Kick, Colors.kick)
+        await self._handle_edit_single(ctx, kick_id, reason, t.kick, Kick, Colors.kick)
 
     @commands.command(aliases=["kick_delete"])
     @ModPermission.kick.check
     @guild_only()
     @docs(t.commands.delete_kick)
     async def delete_kick(self, ctx: Context, kick_id: int):
-        await self.handle_delete_single(ctx, kick_id, t.kick, Kick, Colors.kick)
+        await self._handle_delete_single(ctx, kick_id, t.kick, Kick, Colors.kick)
 
     @commands.command()
     @ModPermission.ban.check
@@ -1330,7 +1330,7 @@ async def ban(
 
         active_mutes: list[Mute] = await db.all(filter_by(Mute, active=True, member=user.id))
 
-        if not await self.handle_timed(
+        if not await self._handle_timed(
             ctx, user, time, reason, t.ban, Ban, Colors.ban, f"\n\n{t.ban.previously_muted}" if active_mutes else ""
         ):
             return
@@ -1352,7 +1352,7 @@ async def edit_ban(self, ctx):
     @edit_ban.command(name="reason", aliases=["r"])
     @docs(t.commands.edit_ban_reason)
     async def edit_ban_reason(self, ctx: Context, ban_id: int, *, reason: str):
-        await self.handle_edit_timed_reason(ctx, ban_id, reason, t.ban, Ban, Colors.ban)
+        await self._handle_edit_timed_reason(ctx, ban_id, reason, t.ban, Ban, Colors.ban)
 
     @edit_ban.command(name="duration", aliases=["d"])
     @docs(t.commands.edit_ban_duration)
@@ -1360,14 +1360,14 @@ async def edit_ban_duration(self, ctx: Context, user: UserMemberConverter, time:
         user: User | Member
         time: int | None
 
-        await self.handle_edit_timed_duration(ctx, user, time, t.ban, Ban, Colors.ban)
+        await self._handle_edit_timed_duration(ctx, user, time, t.ban, Ban, Colors.ban)
 
     @commands.command(aliases=["ban_delete"])
     @ModPermission.ban.check
     @guild_only()
     @docs(t.commands.delete_ban)
     async def delete_ban(self, ctx: Context, ban_id: int):
-        if not (ban := await self.handle_delete_timed(ctx, ban_id, t.ban, Ban, Colors.ban)):
+        if not (ban := await self._handle_delete_timed(ctx, ban_id, t.ban, Ban, Colors.ban)):
             return
 
         active_bans: list[Ban] = await db.all(filter_by(Ban, active=True, member=ban.member))
@@ -1399,4 +1399,4 @@ async def unban_inner(context: Context, banned_user: Member | User) -> bool:
 
             return was_banned
 
-        await self.handle_undo_timed(ctx, user, reason, t.ban, Ban, Colors.unban, unban_inner)
+        await self._handle_undo_timed(ctx, user, reason, t.ban, Ban, Colors.unban, unban_inner)

From d9dae404c0e7cbf66077bc7adcf92c2b5f165aca Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Mon, 11 Jul 2022 16:55:15 +0200
Subject: [PATCH 116/120] Removed ugly TODO-comments

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 4fea6baa4..3c6053e10 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -58,10 +58,6 @@
 MAX_TIMEOUT = timedelta(days=28)
 
 
-# TODO
-#  make all functions private, if the are not ment to be used by other (mit _ davor )
-
-
 class DurationConverter(Converter):  # TODO: Move to library
     """
     Converter for retrieving simple time spans from a string containing different time units

From a1f5dd76894bc7907788f8e37902959e7d036af5 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Sat, 24 Sep 2022 08:30:57 +0200
Subject: [PATCH 117/120] Made content filter userlog query accept  parameters
 that are only necessary for the mod ulog query

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/content_filter/cog.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/moderation/content_filter/cog.py b/moderation/content_filter/cog.py
index 805e98383..c16804c76 100644
--- a/moderation/content_filter/cog.py
+++ b/moderation/content_filter/cog.py
@@ -126,7 +126,7 @@ class ContentFilterCog(Cog, name="Content Filter"):
     CONTRIBUTORS = [Contributor.Infinity, Contributor.Defelo]
 
     @get_userlog_entries.subscribe
-    async def handle_get_ulog_entries(self, user_id: int, _):
+    async def handle_get_ulog_entries(self, user_id: int, *_):
         out = []
 
         log: BadWordPost

From 8f28426c3cf962cc6b0aed4a0c07a13773606a8c Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Mon, 26 Sep 2022 20:28:03 +0200
Subject: [PATCH 118/120] Removed duplicated changelog entry

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 3c6053e10..060405cd2 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -1112,7 +1112,6 @@ async def _handle_undo_timed(
             member=user,
             reason=reason,
             duration=_time_to_units(minutes) if minutes is not None else t.log_field.infinity,
-            mod=ctx.author,
             original_reason=entry.reason,
         )
 

From 58d76cc09c88cfd79a52abf2ded126a1556ccb80 Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Mon, 26 Sep 2022 20:33:16 +0200
Subject: [PATCH 119/120] Fixed wrong translation

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 060405cd2..10378e3c0 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -606,7 +606,7 @@ def wrap_entry(translation, user: int, reason: str, evidence: str | None, entry_
                         (
                             mute.deactivation_timestamp,
                             wrap_entry(
-                                translation=t.unmuted,
+                                translation=t.ulog.unmuted,
                                 user=mute.deactivate_mod,
                                 reason=mute.deactivate_reason,
                                 evidence=None,

From 48a83ce874c4aac1fed923d1b80e8b490fa53f4b Mon Sep 17 00:00:00 2001
From: LoC <loc@locrealloc.de>
Date: Tue, 27 Sep 2022 09:07:28 +0200
Subject: [PATCH 120/120] Added check for the moderate_members permission on
 mute command

Signed-off-by: LoC <loc@locrealloc.de>
---
 moderation/mod/cog.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/moderation/mod/cog.py b/moderation/mod/cog.py
index 10378e3c0..0d224fc06 100644
--- a/moderation/mod/cog.py
+++ b/moderation/mod/cog.py
@@ -1194,6 +1194,9 @@ async def mute(self, ctx: Context, user: UserMemberConverter, time: DurationConv
         if user == self.bot.user or await is_teamler(user):
             raise UserCommandError(user, t.mute.cannot)
 
+        if not ctx.guild.me.guild_permissions.moderate_members:
+            raise CommandError(t.mute.cannot_permissions)
+
         mute_role: Role | None = await _get_mute_role(ctx.guild)
 
         if not await self._handle_timed(ctx, user, time, reason, t.mute, Mute, Colors.mute, ""):
@@ -1315,7 +1318,7 @@ async def ban(
         time: int | None
 
         if not ctx.guild.me.guild_permissions.ban_members:
-            raise CommandError(t.cannot_ban_permissions)
+            raise CommandError(t.ban.cannot_permissions)
 
         if not 0 <= delete_days <= 7:
             raise CommandError(tg.invalid_duration)