Merge pull request #35 from the-programmers-hangout/fix/muted-user-leaving

fix: user leaving guild with active mute didn't remove punishment

Author: ddivad195

src/main/kotlin/me/ddivad/judgebot/commands/MuteCommands.kt

@@ -40,7 +40,7 @@ fun createMuteCommands(muteService: MuteService) = commands("Mute") {
                 return@execute
             }
 
-            muteService.removeMute(targetMember)
+            muteService.removeMute(guild, targetMember.asUser())
             respond("User ${args.first.username} has been unmuted")
         }
     }

src/main/kotlin/me/ddivad/judgebot/embeds/InfractionEmbeds.kt

@@ -113,7 +113,7 @@ fun EmbedBuilder.createMuteEmbed(guild: Guild, user: User, reason: String, lengt
     }
 }
 
-fun EmbedBuilder.createUnmuteEmbed(guild: Guild, user: Member) {
+fun EmbedBuilder.createUnmuteEmbed(guild: Guild, user: User) {
     color = Color.GREEN
     title = "Mute Removed"
     description = "${user.mention} you have been unmuted from **${guild.name}**."

src/main/kotlin/me/ddivad/judgebot/services/infractions/BadPfpService.kt

@@ -54,7 +54,7 @@ class BadPfpService(private val muteService: MuteService,
             badPfpTracker[key]?.cancel()
             badPfpTracker.remove(key)
             loggingService.badPfpCancelled(guild, target)
-            muteService.removeMute(target)
+            muteService.removeMute(guild, target.asUser())
         }
     }
 }

src/main/kotlin/me/ddivad/judgebot/services/infractions/MuteService.kt

@@ -6,6 +6,7 @@ import com.gitlab.kordlib.common.entity.Permissions
 import com.gitlab.kordlib.core.entity.Guild
 import com.gitlab.kordlib.core.entity.Member
 import com.gitlab.kordlib.core.entity.PermissionOverwrite
+import com.gitlab.kordlib.core.entity.User
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.flow.toList
 import kotlinx.coroutines.runBlocking
@@ -38,10 +39,9 @@ class MuteService(val configuration: Configuration,
                   private val discord: Discord,
                   private val databaseService: DatabaseService,
                   private val loggingService: LoggingService) {
-    private val punishmentTimerMap = hashMapOf<Pair<GuildID, UserId>, Job>()
-    private suspend fun toKey(member: Member) = member.guild.id.value to member.asUser().id.value
+    private val muteTimerMap = hashMapOf<Pair<UserId, GuildID>, Job>()
     private suspend fun getMutedRole(guild: Guild) = guild.getRole(configuration[guild.id.longValue]?.mutedRole?.toSnowflake()!!)
-
+    private fun toKey(user: User, guild: Guild) = user.id.value to guild.id.value
     suspend fun initGuilds() {
         configuration.guildConfigurations.forEach { config ->
             val guild = config.value.id.toSnowflake().let { discord.api.getGuild(it) } ?: return@forEach
@@ -52,21 +52,20 @@ class MuteService(val configuration: Configuration,
 
     suspend fun applyMute(member: Member, time: Long, reason: String) {
         val guild = member.guild.asGuild()
-        val userId = member.asUser().id.value
-        val key = toKey(member)
+        val user = member.asUser()
         val clearTime = DateTime.now().plus(time).millis
+        val punishment = Punishment(user.id.value, InfractionType.Mute, reason, "", clearTime)
         val muteRole = getMutedRole(guild)
-
-        if (key in punishmentTimerMap) {
-            punishmentTimerMap[key]?.cancel()
-            punishmentTimerMap.remove(key)
+        val key = toKey(user, guild)
+        if (key in muteTimerMap) {
+            muteTimerMap[key]?.cancel()
+            muteTimerMap.remove(key)
             databaseService.guilds.removePunishment(guild, member.asUser().id.value, InfractionType.Mute)
             loggingService.muteOverwritten(guild, member)
         }
-        val punishment = Punishment(userId, InfractionType.Mute, reason, "", clearTime)
         databaseService.guilds.addPunishment(guild.asGuild(), punishment)
-        punishmentTimerMap[key] = applyRoleWithTimer(member, muteRole, time) {
-            removeMute(member)
+        muteTimerMap[key] = applyRoleWithTimer(member, muteRole, time) {
+            removeMute(guild, user)
         }.also {
             loggingService.roleApplied(guild, member.asUser(), muteRole)
             member.sendPrivateMessage {
@@ -79,19 +78,22 @@ class MuteService(val configuration: Configuration,
         this.applyMute(target, 1000L * 60 * 5, "You've been muted temporarily so that a mod can handle something.")
     }
 
-    fun removeMute(member: Member) {
+    fun removeMute(guild: Guild, user: User) {
         runBlocking {
-            val guild = member.guild.asGuild()
-            val key = toKey(member)
             val muteRole = getMutedRole(guild)
-            member.removeRole(muteRole.id)
-            databaseService.guilds.removePunishment(guild, member.asUser().id.value, InfractionType.Mute)
-            punishmentTimerMap[key]?.cancel()
-            punishmentTimerMap.remove(toKey(member))
-            member.sendPrivateMessage {
-                createUnmuteEmbed(guild, member)
+            databaseService.guilds.removePunishment(guild, user.id.value, InfractionType.Mute)
+            val key = toKey(user, guild)
+            muteTimerMap[key]?.cancel()
+            muteTimerMap.remove(key)
+
+            guild.getMemberOrNull(user.id)?.let {
+                it.removeRole(muteRole.id)
+                it.sendPrivateMessage {
+                    createUnmuteEmbed(guild, user)
+                }
             }
-            loggingService.roleRemoved(guild, member.asUser(), muteRole)
+
+            loggingService.roleRemoved(guild, user, muteRole)
         }
     }
 
@@ -100,9 +102,10 @@ class MuteService(val configuration: Configuration,
             if (it.clearTime != null) {
                 val difference = it.clearTime - DateTime.now().millis
                 val member = guild.getMemberOrNull(it.userId.toSnowflake()) ?: return
-                val key = toKey(member)
-                punishmentTimerMap[key] = applyRoleWithTimer(member, getMutedRole(guild), difference) {
-                    removeMute(member)
+                val user = member.asUser()
+                val key = toKey(user, guild)
+                muteTimerMap[key] = applyRoleWithTimer(member, getMutedRole(guild), difference) {
+                    removeMute(guild, user)
                 }
             }
         }
@@ -112,9 +115,10 @@ class MuteService(val configuration: Configuration,
         val mute = databaseService.guilds.checkPunishmentExists(guild, member, InfractionType.Mute).first()
         if (mute.clearTime != null) {
             val difference = mute.clearTime - DateTime.now().millis
-            val key = toKey(member)
-            punishmentTimerMap[key] = applyRoleWithTimer(member, getMutedRole(guild), difference) {
-                removeMute(member)
+            val user = member.asUser()
+            val key = toKey(user, guild)
+            muteTimerMap[key] = applyRoleWithTimer(member, getMutedRole(guild), difference) {
+                removeMute(guild, user)
             }
         }
     }
@@ -140,7 +144,7 @@ class MuteService(val configuration: Configuration,
                 } catch (ex: RequestException) {
                     println("No permssions to add overwrite to ${it.id.value}")
                 }
-                
+
             }
         }
     }