chore: fix gradle and code warnings

commands.md

@@ -11,6 +11,12 @@
 | configuration | (GuildConfig) | Update configuration parameters for this guild (conversation). |
 | setup         |               | Configure a guild to use Judgebot.                             |
 
+## Information
+| Commands   | Arguments                    | Description                                         |
+| ---------- | ---------------------------- | --------------------------------------------------- |
+| info       | LowerMemberArg, Info Content | Send an information message to a guild member       |
+| removeInfo | LowerMemberArg, Integer      | Remove an information message from a member record. |
+
 ## Infraction
 | Commands         | Arguments                       | Description                                                                                                                           |
 | ---------------- | ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
@@ -50,8 +56,6 @@
 | ban          | LowerMemberArg, (Delete message days), Text | Ban a member from this guild.                              |
 | getBanReason | User                                        | Get a ban reason for a banned user                         |
 | history, h   | User                                        | Use this to view a user's record.                          |
-| info         | LowerMemberArg, Info Content                | Send an information message to a guild member              |
-| removeInfo   | LowerMemberArg, Integer                     | Remove an information message from a member record.        |
 | selfHistory  |                                             | View your infraction history (contents will be DM'd)       |
 | setBanReason | User, Text                                  | Set a ban reason for a banned user                         |
 | status, st   | User                                        | Use this to view a user's status card.                     |

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

@@ -0,0 +1,45 @@
+package me.ddivad.judgebot.commands
+
+import me.ddivad.judgebot.arguments.LowerMemberArg
+import me.ddivad.judgebot.dataclasses.Info
+import me.ddivad.judgebot.embeds.createInformationEmbed
+import me.ddivad.judgebot.services.DatabaseService
+import me.ddivad.judgebot.services.PermissionLevel
+import me.ddivad.judgebot.services.requiredPermissionLevel
+import me.jakejmattson.discordkt.api.arguments.EveryArg
+import me.jakejmattson.discordkt.api.arguments.IntegerArg
+import me.jakejmattson.discordkt.api.dsl.commands
+import me.jakejmattson.discordkt.api.extensions.sendPrivateMessage
+
+@Suppress("unused")
+fun createInformationCommands(databaseService: DatabaseService) = commands("Information") {
+    guildCommand("info") {
+        description = "Send an information message to a guild member"
+        requiredPermissionLevel = PermissionLevel.Moderator
+        execute(LowerMemberArg, EveryArg("Info Content")) {
+            val (target, content) = args
+            val user = databaseService.users.getOrCreateUser(target, guild)
+            val information = Info(content, author.id.value)
+            databaseService.users.addInfo(guild, user, information)
+            target.sendPrivateMessage {
+                createInformationEmbed(guild, target, information)
+            }
+            respond("Info added and sent to user.")
+        }
+    }
+
+    guildCommand("removeInfo") {
+        description = "Remove an information message from a member record."
+        requiredPermissionLevel = PermissionLevel.Staff
+        execute(LowerMemberArg, IntegerArg) {
+            val (target, id) = args
+            val user = databaseService.users.getOrCreateUser(target, guild)
+            if (user.getGuildInfo(guild.id.value).info.isEmpty()) {
+                respond("User has no information records.")
+                return@execute
+            }
+            databaseService.users.removeInfo(guild, user, id)
+            respond("Information record removed.")
+        }
+    }
+}

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

@@ -84,7 +84,7 @@ fun createInfractionCommands(databaseService: DatabaseService,
             }
 
             val badPfp = Infraction(author.id.value, "BadPfp", InfractionType.BadPfp)
-            badPfpService.applyBadPfp(targetMember, guild, badPfp, timeLimit)
+            badPfpService.applyBadPfp(targetMember, guild, timeLimit)
             respond("${targetMember.mention} has been muted and a badpfp has been triggered with a time limit of $minutesUntilBan minutes.")
         }
     }

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

@@ -42,7 +42,7 @@ fun noteCommands(databaseService: DatabaseService) = commands("Notes") {
         requiredPermissionLevel = PermissionLevel.Administrator
         execute(LowerMemberArg) {
             val user = databaseService.users.getOrCreateUser(args.first, guild)
-            if (user.getGuildInfo(guild.id.value)!!.notes.isEmpty()) {
+            if (user.getGuildInfo(guild.id.value).notes.isEmpty()) {
                 respond("User has no notes.")
                 return@execute
             }

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

@@ -21,7 +21,7 @@ fun ruleCommands(configuration: Configuration,
         description = "Add a rule to this guild."
         requiredPermissionLevel = PermissionLevel.Administrator
         execute {
-            AddRuleConversation(configuration, databaseService)
+            AddRuleConversation(databaseService)
                     .createAddRuleConversation(guild)
                     .startPublicly(discord, author, channel)
         }
@@ -31,7 +31,7 @@ fun ruleCommands(configuration: Configuration,
         description = "Edit a rule in this guild."
         requiredPermissionLevel = PermissionLevel.Administrator
         execute {
-            EditRuleConversation(configuration, databaseService)
+            EditRuleConversation(databaseService)
                     .createAddRuleConversation(guild)
                     .startPublicly(discord, author, channel)
         }
@@ -41,7 +41,7 @@ fun ruleCommands(configuration: Configuration,
         description = "Archive a rule in this guild."
         requiredPermissionLevel = PermissionLevel.Administrator
         execute {
-            ArchiveRuleConversation(configuration, databaseService)
+            ArchiveRuleConversation(databaseService)
                     .createArchiveRuleConversation(guild)
                     .startPublicly(discord, author, channel)
         }

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

@@ -3,7 +3,6 @@ package me.ddivad.judgebot.commands
 import me.ddivad.judgebot.arguments.LowerMemberArg
 import me.ddivad.judgebot.dataclasses.*
 import me.ddivad.judgebot.embeds.createHistoryEmbed
-import me.ddivad.judgebot.embeds.createInformationEmbed
 import me.ddivad.judgebot.embeds.createSelfHistoryEmbed
 import me.ddivad.judgebot.embeds.createStatusEmbed
 import me.ddivad.judgebot.services.DatabaseService
@@ -95,7 +94,7 @@ fun createUserCommands(databaseService: DatabaseService,
             val ban = Ban(user.id.value, author.id.value, reason)
             if (guild.getBanOrNull(user.id) != null) {
                 if (!databaseService.guilds.checkBanExists(guild, user.id.value)) {
-                    databaseService.guilds.addBan(guild, user.id.value, ban)
+                    databaseService.guilds.addBan(guild, ban)
                 } else {
                     databaseService.guilds.editBanReason(guild, user.id.value, reason)
                 }
@@ -132,34 +131,4 @@ fun createUserCommands(databaseService: DatabaseService,
             }
         }
     }
-
-    guildCommand("info") {
-        description = "Send an information message to a guild member"
-        requiredPermissionLevel = PermissionLevel.Moderator
-        execute(LowerMemberArg, EveryArg("Info Content")) {
-            val (target, content) = args
-            val user = databaseService.users.getOrCreateUser(target, guild)
-            val information = Info(content, author.id.value)
-            databaseService.users.addInfo(guild, user, information)
-            target.sendPrivateMessage {
-                createInformationEmbed(guild, target, information)
-            }
-            respond("Info added and sent to user.")
-        }
-    }
-
-    guildCommand("removeInfo") {
-        description = "Remove an information message from a member record."
-        requiredPermissionLevel = PermissionLevel.Staff
-        execute(LowerMemberArg, IntegerArg) {
-            val (target, id) = args
-            val user = databaseService.users.getOrCreateUser(target, guild)
-            if (user.getGuildInfo(guild.id.value).info.isEmpty()) {
-                respond("User has no information records.")
-                return@execute
-            }
-            databaseService.users.removeInfo(guild, user, id)
-            respond("Information record removed.")
-        }
-    }
 }

src/main/kotlin/me/ddivad/judgebot/conversations/rules/AddRuleConversation.kt

@@ -10,8 +10,7 @@ import me.jakejmattson.discordkt.api.arguments.EveryArg
 import me.jakejmattson.discordkt.api.arguments.UrlArg
 import me.jakejmattson.discordkt.api.dsl.conversation
 
-class AddRuleConversation(private val configuration: Configuration,
-                          private val databaseService: DatabaseService) {
+class AddRuleConversation(private val databaseService: DatabaseService) {
     fun createAddRuleConversation(guild: Guild) = conversation("cancel") {
         val rules = databaseService.guilds.getRules(guild)
         val nextId = rules.size.plus(1)

src/main/kotlin/me/ddivad/judgebot/conversations/rules/ArchiveRuleConversation.kt

@@ -1,13 +1,11 @@
 package me.ddivad.judgebot.conversations.rules
 
 import com.gitlab.kordlib.core.entity.Guild
-import me.ddivad.judgebot.dataclasses.Configuration
 import me.ddivad.judgebot.services.DatabaseService
 import me.jakejmattson.discordkt.api.arguments.IntegerArg
 import me.jakejmattson.discordkt.api.dsl.conversation
 
-class ArchiveRuleConversation(private val configuration: Configuration,
-                          private val databaseService: DatabaseService) {
+class ArchiveRuleConversation(private val databaseService: DatabaseService) {
     fun createArchiveRuleConversation(guild: Guild) = conversation("cancel") {
         val ruleToArchive = promptMessage(IntegerArg, "Please enter rule number to archive:")
 

src/main/kotlin/me/ddivad/judgebot/conversations/rules/EditRuleConversation.kt

@@ -1,7 +1,6 @@
 package me.ddivad.judgebot.conversations.rules
 
 import com.gitlab.kordlib.core.entity.Guild
-import me.ddivad.judgebot.dataclasses.Configuration
 import me.ddivad.judgebot.dataclasses.Rule
 import me.ddivad.judgebot.embeds.createRuleEmbed
 import me.ddivad.judgebot.services.DatabaseService
@@ -11,8 +10,7 @@ import me.jakejmattson.discordkt.api.arguments.IntegerArg
 import me.jakejmattson.discordkt.api.arguments.UrlArg
 import me.jakejmattson.discordkt.api.dsl.conversation
 
-class EditRuleConversation(private val configuration: Configuration,
-                           private val databaseService: DatabaseService) {
+class EditRuleConversation(private val databaseService: DatabaseService) {
     fun createAddRuleConversation(guild: Guild) = conversation("cancel") {
         val rules = databaseService.guilds.getRules(guild)
         val ruleNumberToUpdate = promptMessage(IntegerArg, "Which rule would you like to update?")

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

@@ -8,26 +8,25 @@ import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import me.ddivad.judgebot.services.DatabaseService
-import me.ddivad.judgebot.services.LoggingService
 import me.jakejmattson.discordkt.api.dsl.listeners
 import org.joda.time.DateTime
 
 @Suppress("unused")
-fun onGuildMemberLeave(loggingService: LoggingService, databaseService: DatabaseService) = listeners {
+fun onGuildMemberLeave(databaseService: DatabaseService) = listeners {
     on<GuildCreateEvent> {
         gateway.send(RequestGuildMembers(guildId = listOf(guild.id.value)))
     }
 
     on<MemberLeaveEvent> {
-        databaseService.users.getUserOrNull(this.user.asUser(), this.guild.asGuild())?.let {
+        databaseService.users.getUserOrNull(this.user.asUser())?.let {
             databaseService.users.addGuildLeave(it, guild.asGuild(), DateTime.now().millis)
         }
     }
 
     on<MemberJoinEvent> {
         val user = this.member.asUser()
         val guild = this.getGuild()
-        databaseService.users.getUserOrNull(user, guild)?.let {
+        databaseService.users.getUserOrNull(user)?.let {
             databaseService.users.addGuildJoin(guild, it, this.member.joinedAt.toEpochMilli())
             return@on
         }

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

@@ -1,7 +1,6 @@
 package me.ddivad.judgebot.listeners
 
 import com.gitlab.kordlib.core.event.guild.MemberJoinEvent
-import me.ddivad.judgebot.dataclasses.InfractionType
 import me.ddivad.judgebot.services.LoggingService
 import me.ddivad.judgebot.services.infractions.MuteService
 import me.ddivad.judgebot.services.infractions.RoleState

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

@@ -5,7 +5,6 @@ import com.gitlab.kordlib.core.event.message.ReactionAddEvent
 import me.ddivad.judgebot.dataclasses.Configuration
 import me.ddivad.judgebot.embeds.createMessageDeleteEmbed
 import me.ddivad.judgebot.embeds.createSelfHistoryEmbed
-import me.ddivad.judgebot.extensions.testDmStatus
 import me.ddivad.judgebot.services.DatabaseService
 import me.ddivad.judgebot.services.PermissionLevel
 import me.ddivad.judgebot.services.PermissionsService

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

@@ -1,12 +1,10 @@
 package me.ddivad.judgebot.services
 
-import me.ddivad.judgebot.dataclasses.Configuration
 import me.ddivad.judgebot.services.database.GuildOperations
 import me.ddivad.judgebot.services.database.UserOperations
 import me.jakejmattson.discordkt.api.annotations.Service
 
 @Service
-open class DatabaseService(val config: Configuration,
-                           val users: UserOperations,
+open class DatabaseService(val users: UserOperations,
                            val guilds: GuildOperations) {
 }

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

@@ -7,7 +7,6 @@ import com.gitlab.kordlib.core.entity.Member
 import com.gitlab.kordlib.core.entity.Role
 import com.gitlab.kordlib.core.entity.User
 import com.gitlab.kordlib.core.entity.channel.TextChannel
-import me.ddivad.judgebot.dataclasses.Ban
 import me.ddivad.judgebot.dataclasses.Configuration
 import me.ddivad.judgebot.dataclasses.Infraction
 import me.ddivad.judgebot.dataclasses.Punishment
@@ -71,6 +70,6 @@ class LoggingService(private val configuration: Configuration) {
     private suspend fun getLoggingChannel(guild: Guild): TextChannel? {
         val channelId = configuration[guild.id.longValue]?.loggingConfiguration?.loggingChannel.takeIf { it!!.isNotEmpty() }
                 ?: return null
-        return guild.getChannelOf<TextChannel>(Snowflake(channelId))
+        return guild.getChannelOf(Snowflake(channelId))
     }
 }

src/main/kotlin/me/ddivad/judgebot/services/database/ConnectionService.kt

@@ -8,7 +8,7 @@ import org.litote.kmongo.coroutine.coroutine
 import org.litote.kmongo.reactivestreams.KMongo
 
 @Service
-class ConnectionService(val config: Configuration) {
+class ConnectionService(config: Configuration) {
     private val client: CoroutineClient = KMongo.createClient(config.dbConfiguration.address).coroutine
     val db: CoroutineDatabase = client.getDatabase(config.dbConfiguration.databaseName)
 }

src/main/kotlin/me/ddivad/judgebot/services/database/GuildOperations.kt

@@ -63,7 +63,7 @@ class GuildOperations(connection: ConnectionService) {
         this.getGuild(guild).removePunishment(userId, type).let { updateGuild(it) }
     }
 
-    suspend fun addBan(guild: Guild, userId: String, ban: Ban): Ban {
+    suspend fun addBan(guild: Guild, ban: Ban): Ban {
         this.getGuild(guild).addBan(ban).let { updateGuild(it) }
         return ban
     }

src/main/kotlin/me/ddivad/judgebot/services/database/UserOperations.kt

@@ -29,7 +29,7 @@ class UserOperations(connection: ConnectionService, private val configuration: C
         }
     }
 
-    suspend fun getUserOrNull(target: User, guild: Guild): GuildMember? {
+    suspend fun getUserOrNull(target: User): GuildMember? {
         return userCollection.findOne(GuildMember::userId eq target.id.value)
     }
 

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

@@ -7,7 +7,6 @@ import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
-import me.ddivad.judgebot.dataclasses.Infraction
 import me.ddivad.judgebot.embeds.createBadPfpEmbed
 import me.ddivad.judgebot.services.LoggingService
 import me.jakejmattson.discordkt.api.Discord
@@ -21,7 +20,7 @@ class BadPfpService(private val muteService: MuteService,
     private val badPfpTracker = hashMapOf<Pair<GuildID, UserId>, Job>()
     private suspend fun toKey(member: Member): Pair<GuildID, UserId> = member.guild.id.value to member.asUser().id.value
 
-    suspend fun applyBadPfp(target: Member, guild: Guild, badPfp: Infraction, timeLimit: Long) {
+    suspend fun applyBadPfp(target: Member, guild: Guild, timeLimit: Long) {
         target.sendPrivateMessage {
             createBadPfpEmbed(guild, target)
         }

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

@@ -26,7 +26,7 @@ class BanService(private val databaseService: DatabaseService,
             deleteMessagesDays = deleteDays
             reason = punishment.reason
         }
-        databaseService.guilds.addBan(guild, target.id.value, Ban(target.id.value, punishment.moderator, punishment.reason))
+        databaseService.guilds.addBan(guild, Ban(target.id.value, punishment.moderator, punishment.reason))
         if (punishment.clearTime != null) {
             databaseService.guilds.addPunishment(guild.asGuild(), punishment)
             banTracker[punishment.id] = GlobalScope.launch {

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

@@ -26,11 +26,11 @@ class InfractionService(private val configuration: Configuration,
                 createInfractionEmbed(guild, configuration[guild.id.longValue]!!, target, userRecord, it, rule)
             }
             loggingService.infractionApplied(guild, target.asUser(), it)
-            applyPunishment(guild, target, userRecord, it)
+            applyPunishment(guild, target, it)
         }
     }
 
-    private suspend fun applyPunishment(guild: Guild, target: Member, guildMember: GuildMember, infraction: Infraction) {
+    private suspend fun applyPunishment(guild: Guild, target: Member, infraction: Infraction) {
         when (infraction.punishment?.punishment) {
             PunishmentType.NONE -> return
             PunishmentType.MUTE -> muteService.applyMute(target, infraction.punishment?.duration!!, infraction.reason)

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

@@ -11,7 +11,6 @@ import kotlinx.coroutines.Job
 import kotlinx.coroutines.flow.toList
 import kotlinx.coroutines.runBlocking
 import me.ddivad.judgebot.dataclasses.Configuration
-import me.ddivad.judgebot.dataclasses.GuildMember
 import me.ddivad.judgebot.dataclasses.InfractionType
 import me.ddivad.judgebot.dataclasses.Punishment
 import me.ddivad.judgebot.embeds.createMuteEmbed