Merge pull request #39 from the-programmers-hangout/develop

release: merge develop for 1.2.2 release

Author: ddivad195

src/main/kotlin/me/ddivad/judgebot/Main.kt

@@ -56,7 +56,7 @@ suspend fun main(args: Array<String>) {
             field {
                 name = "Build Info"
                 value = "```" +
-                        "Version:   1.2.1\n" +
+                        "Version:   1.2.2\n" +
                         "DiscordKt: ${versions.library}\n" +
                         "Kotlin:    $kotlinVersion" +
                         "```"

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

@@ -35,13 +35,13 @@ fun createMuteCommands(muteService: MuteService) = commands("Mute") {
         requiredPermissionLevel = PermissionLevel.Moderator
         execute(LowerMemberArg) {
             val targetMember = args.first
-            if (muteService.checkRoleState(guild, targetMember, InfractionType.Mute) == RoleState.None) {
+            if (muteService.checkRoleState(guild, targetMember) == RoleState.None) {
                 respond("User ${targetMember.mention} isn't muted")
                 return@execute
             }
 
             muteService.removeMute(guild, targetMember.asUser())
-            respond("User ${args.first.username} has been unmuted")
+            respond("User ${args.first.mention} has been unmuted")
         }
     }
 
@@ -56,7 +56,7 @@ fun createMuteCommands(muteService: MuteService) = commands("Mute") {
                 respond("Unable to contact the target user. Infraction cancelled.")
                 return@execute
             }
-            if (muteService.checkRoleState(guild, targetMember, InfractionType.Mute) == RoleState.Tracked) {
+            if (muteService.checkRoleState(guild, targetMember) == RoleState.Tracked) {
                 respond("User ${targetMember.mention} is already muted")
                 return@execute
             }

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

@@ -6,6 +6,8 @@ import com.gitlab.kordlib.core.entity.User
 import me.ddivad.judgebot.arguments.LowerMemberArg
 import me.ddivad.judgebot.dataclasses.Ban
 import me.ddivad.judgebot.dataclasses.Configuration
+import me.ddivad.judgebot.dataclasses.InfractionType
+import me.ddivad.judgebot.dataclasses.Punishment
 import me.ddivad.judgebot.embeds.createHistoryEmbed
 import me.ddivad.judgebot.embeds.createSelfHistoryEmbed
 import me.ddivad.judgebot.embeds.createStatusEmbed
@@ -68,14 +70,10 @@ fun createUserCommands(databaseService: DatabaseService,
         requiredPermissionLevel = PermissionLevel.Staff
         execute(LowerMemberArg, IntegerArg("Delete message days").makeOptional(1), EveryArg) {
             val (target, deleteDays, reason) = args
-            guild.ban(target.id) {
-                this.reason = reason
-                this.deleteMessagesDays = deleteDays
-                val ban = Ban(target.id.value, reason, author.id.value)
-                databaseService.guilds.addBan(guild, target.id.value, ban).also {
-                    loggingService.userBanned(guild, target.asUser(), it)
-                    respond("User ${target.mention} banned")
-                }
+            val ban = Punishment(target.id.value, InfractionType.Ban , reason, author.id.value)
+            banService.banUser(target, guild, ban, deleteDays).also {
+                loggingService.userBanned(guild, target.asUser(), ban)
+                respond("User ${target.mention} banned")
             }
         }
     }

src/main/kotlin/me/ddivad/judgebot/listeners/RejoinMuteListener.kt

@@ -11,7 +11,7 @@ fun onMemberRejoinWithMute(muteService: MuteService, loggingService: LoggingServ
     on<MemberJoinEvent> {
         val member = this.member
         val guild = this.getGuild()
-        if (muteService.checkRoleState(guild, member, InfractionType.Mute) == RoleState.Tracked) {
+        if (muteService.checkRoleState(guild, member) == RoleState.Tracked) {
             muteService.handleRejoinMute(guild, member)
             loggingService.rejoinMute(guild, member.asUser(), RoleState.Tracked)
         }

src/main/kotlin/me/ddivad/judgebot/services/LoggingService.kt

@@ -34,7 +34,7 @@ class LoggingService(private val configuration: Configuration) {
     suspend fun channelOverrideAdded(guild: Guild, channel: TextChannel) =
             log(guild, "**Info ::** Channel overrides for muted role added to ${channel.name}")
 
-    suspend fun userBanned(guild: Guild, user: User, ban: Ban) {
+    suspend fun userBanned(guild: Guild, user: User, ban: Punishment) {
         val moderator = guild.kord.getUser(Snowflake(ban.moderator))
         log(guild, "**Info ::** User ${user.mention} :: ${user.tag} banned by ${moderator?.username} for reason: ${ban.reason}")
     }

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

@@ -21,9 +21,9 @@ class BanService(private val databaseService: DatabaseService,
     private val banTracker = hashMapOf<Int, Job>()
     private suspend fun toKey(member: Member): Pair<GuildID, UserId> = member.guild.id.value to member.asUser().id.value
 
-    suspend fun banUser(target: Member, guild: Guild, moderator: String, punishment: Punishment) {
+    suspend fun banUser(target: Member, guild: Guild, punishment: Punishment, deleteDays: Int = 1) {
         guild.ban(target.id) {
-            deleteMessagesDays = 1
+            deleteMessagesDays = deleteDays
             reason = punishment.reason
         }
         databaseService.guilds.addBan(guild, target.id.value, Ban(target.id.value, punishment.moderator, punishment.reason))

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

@@ -37,7 +37,7 @@ class InfractionService(private val configuration: Configuration,
             PunishmentType.BAN -> {
                 val clearTime = infraction.punishment!!.duration?.let { DateTime().millis.plus(it) }
                 val punishment = Punishment(target.id.value, InfractionType.Ban, infraction.reason, infraction.moderator, clearTime)
-                banService.banUser(target, guild, infraction.moderator, punishment)
+                banService.banUser(target, guild, punishment)
             }
         }
     }

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

@@ -81,19 +81,18 @@ class MuteService(val configuration: Configuration,
     fun removeMute(guild: Guild, user: User) {
         runBlocking {
             val muteRole = getMutedRole(guild)
-            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, user, muteRole)
+                if (checkRoleState(guild, it) == RoleState.Untracked) return@runBlocking
             }
-
-            loggingService.roleRemoved(guild, user, muteRole)
+            databaseService.guilds.removePunishment(guild, user.id.value, InfractionType.Mute)
+            muteTimerMap[key]?.cancel()
+            muteTimerMap.remove(key)
         }
     }
 
@@ -123,8 +122,8 @@ class MuteService(val configuration: Configuration,
         }
     }
 
-    suspend fun checkRoleState(guild: Guild, member: Member, type: InfractionType) = when {
-        databaseService.guilds.checkPunishmentExists(guild, member, type).isNotEmpty() -> RoleState.Tracked
+    suspend fun checkRoleState(guild: Guild, member: Member) = when {
+        databaseService.guilds.checkPunishmentExists(guild, member, InfractionType.Mute).isNotEmpty() -> RoleState.Tracked
         member.roles.toList().contains(getMutedRole(member.getGuild())) -> RoleState.Untracked
         else -> RoleState.None
     }