feat: update dkt snapshot version

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

@@ -6,6 +6,7 @@ import dev.kord.gateway.Intent
 import dev.kord.gateway.Intents
 import dev.kord.gateway.PrivilegedIntent
 import me.ddivad.judgebot.dataclasses.Configuration
+import me.ddivad.judgebot.dataclasses.Permissions
 import me.ddivad.judgebot.services.*
 import me.ddivad.judgebot.services.infractions.BanService
 import me.ddivad.judgebot.services.infractions.MuteService
@@ -31,6 +32,14 @@ suspend fun main(args: Array<String>) {
             commandReaction = null
             theme = Color.MAGENTA
             entitySupplyStrategy = EntitySupplyStrategy.cacheWithCachingRestFallback
+            permissions(Permissions.NONE)
+            intents = Intents(
+                Intent.GuildMembers,
+                Intent.DirectMessages,
+                Intent.GuildBans,
+                Intent.Guilds,
+                Intent.GuildMessageReactions
+            )
         }
 
         mentionEmbed {
@@ -73,15 +82,6 @@ suspend fun main(args: Array<String>) {
             }
         }
 
-        permissions {
-            val permissionsService = discord.getInjectionObjects(PermissionsService::class)
-            val permission = command.requiredPermissionLevel
-            if (guild != null)
-                permissionsService.hasClearance(guild!!, user, permission)
-            else
-                return@permissions command.requiredPermissionLevel == PermissionLevel.Everyone
-        }
-
         onStart {
             val (muteService, banService, cacheService) = this.getInjectionObjects(
                 MuteService::class,

src/main/kotlin/me/ddivad/judgebot/arguments/LowerMemberArg.kt

@@ -1,7 +1,6 @@
 package me.ddivad.judgebot.arguments
 
 import dev.kord.core.entity.Member
-import me.ddivad.judgebot.services.PermissionsService
 import me.jakejmattson.discordkt.api.arguments.*
 import me.jakejmattson.discordkt.api.dsl.CommandEvent
 import me.jakejmattson.discordkt.api.extensions.toSnowflakeOrNull
@@ -14,20 +13,17 @@ open class LowerMemberArg(override val name: String = "LowerMemberArg") : Argume
     override suspend fun generateExamples(event: CommandEvent<*>) = mutableListOf("@User", "197780697866305536", "302134543639511050")
 
     override suspend fun convert(arg: String, args: List<String>, event: CommandEvent<*>): ArgumentResult<Member> {
-        val permissionsService = event.discord.getInjectionObjects(PermissionsService::class)
         val guild = event.guild ?: return Error("No guild found")
 
         val member = arg.toSnowflakeOrNull()?.let { guild.getMemberOrNull(it) } ?: return Error("Not found")
+        val author = event.author.asMember(event.guild!!.id)
 
         return when {
-            event.author.asMember(event.guild!!.id).isHigherRankedThan(permissionsService, member) ->
+            event.discord.permissions.isHigherLevel(event.discord, member, author) ->
                 Error("You don't have the permission to use this command on the target user.")
             else -> Success(member)
         }
     }
 
     override fun formatData(data: Member) = "@${data.tag}"
-}
-
-suspend fun Member.isHigherRankedThan(permissions: PermissionsService, targetMember: Member) =
-    permissions.getPermissionRank(this) < permissions.getPermissionRank(targetMember)
+}

src/main/kotlin/me/ddivad/judgebot/arguments/LowerUserArg.kt

@@ -1,7 +1,6 @@
 package me.ddivad.judgebot.arguments
 
 import dev.kord.core.entity.User
-import me.ddivad.judgebot.services.PermissionsService
 import me.jakejmattson.discordkt.api.arguments.*
 import me.jakejmattson.discordkt.api.dsl.CommandEvent
 import me.jakejmattson.discordkt.api.extensions.toSnowflakeOrNull
@@ -14,15 +13,15 @@ open class LowerUserArg(override val name: String = "LowerUserArg") : ArgumentTy
     override suspend fun generateExamples(event: CommandEvent<*>) = mutableListOf("@User", "197780697866305536", "302134543639511050")
 
     override suspend fun convert(arg: String, args: List<String>, event: CommandEvent<*>): ArgumentResult<User> {
-        val permissionsService = event.discord.getInjectionObjects(PermissionsService::class)
         val guild = event.guild ?: return Error("No guild found")
 
         val user = arg.toSnowflakeOrNull()?.let { guild.kord.getUser(it) } ?: return Error("User Not Found")
         val member = guild.getMemberOrNull(user.id) ?: return Success(user)
+        val author = event.author.asMember(event.guild!!.id)
 
         return when {
-            event.author.asMember(event.guild!!.id).isHigherRankedThan(permissionsService, member) ->
-                Error("You don't have the permission to use this command on the target user")
+            event.discord.permissions.isHigherLevel(event.discord, member, author) ->
+                Error("You don't have the permission to use this command on the target user.")
             else -> Success(member.asUser())
         }
     }

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

@@ -4,19 +4,18 @@ import me.ddivad.judgebot.arguments.GuildConfigArg
 import me.ddivad.judgebot.conversations.guild.GuildSetupConversation
 import me.ddivad.judgebot.conversations.guild.EditConfigConversation
 import me.ddivad.judgebot.dataclasses.Configuration
+import me.ddivad.judgebot.dataclasses.Permissions
 import me.ddivad.judgebot.embeds.createActivePunishmentsEmbed
 import me.ddivad.judgebot.services.DatabaseService
 import me.ddivad.judgebot.services.infractions.MuteService
-import me.ddivad.judgebot.services.PermissionLevel
-import me.ddivad.judgebot.services.requiredPermissionLevel
 import me.jakejmattson.discordkt.api.dsl.commands
 
 fun guildConfigCommands(configuration: Configuration,
                         databaseService: DatabaseService,
                         muteService: MuteService) = commands("Guild") {
     guildCommand("setup") {
         description = "Configure a guild to use Judgebot."
-        requiredPermissionLevel = PermissionLevel.Administrator
+        requiredPermission = Permissions.ADMINISTRATOR
         execute {
             if (configuration.hasGuildConfig(guild.id.value)) {
                 respond("Guild configuration exists. To modify it use the commands to set values.")
@@ -32,7 +31,7 @@ fun guildConfigCommands(configuration: Configuration,
 
     guildCommand("configuration") {
         description = "Update configuration parameters for this guild (conversation)."
-        requiredPermissionLevel = PermissionLevel.Staff
+        requiredPermission = Permissions.STAFF
         execute(GuildConfigArg.optional("options")) {
             if (!configuration.hasGuildConfig(guild.id.value)) {
                 respond("Please run the **setup** command to set this initially.")
@@ -46,7 +45,7 @@ fun guildConfigCommands(configuration: Configuration,
 
     guildCommand("activePunishments") {
         description = "View active punishments for a guild."
-        requiredPermissionLevel = PermissionLevel.Staff
+        requiredPermission = Permissions.STAFF
         execute {
             val punishments = databaseService.guilds.getActivePunishments(guild)
             if (punishments.isEmpty()) {

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

@@ -5,24 +5,20 @@ import dev.kord.x.emoji.Emojis
 import dev.kord.x.emoji.addReaction
 import me.ddivad.judgebot.arguments.LowerMemberArg
 import me.ddivad.judgebot.dataclasses.Info
+import me.ddivad.judgebot.dataclasses.Permissions
 import me.ddivad.judgebot.embeds.createInformationEmbed
 import me.ddivad.judgebot.extensions.testDmStatus
 import me.ddivad.judgebot.services.DatabaseService
-import me.ddivad.judgebot.services.HelpService
-import me.ddivad.judgebot.services.PermissionLevel
-import me.ddivad.judgebot.services.requiredPermissionLevel
-import me.jakejmattson.discordkt.api.arguments.CommandArg
 import me.jakejmattson.discordkt.api.arguments.EveryArg
 import me.jakejmattson.discordkt.api.arguments.IntegerArg
-import me.jakejmattson.discordkt.api.arguments.UnicodeEmojiArg
 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
+        requiredPermission = Permissions.MODERATOR
         execute(LowerMemberArg, EveryArg("Info Content")) {
             val (target, content) = args
             try {
@@ -45,7 +41,7 @@ fun createInformationCommands(databaseService: DatabaseService) = commands("Info
 
     guildCommand("removeInfo") {
         description = "Remove an information message from a member record."
-        requiredPermissionLevel = PermissionLevel.Staff
+        requiredPermission = Permissions.STAFF
         execute(LowerMemberArg, IntegerArg("Info ID")) {
             val (target, id) = args
             val user = databaseService.users.getOrCreateUser(target, guild)

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

@@ -1,25 +1,25 @@
 package me.ddivad.judgebot.commands
 
-import dev.kord.common.entity.Permission
 import me.ddivad.judgebot.arguments.LowerUserArg
 import dev.kord.common.exception.RequestException
+import dev.kord.core.behavior.reply
 import dev.kord.x.emoji.Emojis
 import dev.kord.x.emoji.addReaction
 import me.ddivad.judgebot.arguments.LowerMemberArg
 import me.ddivad.judgebot.conversations.InfractionConversation
 import me.ddivad.judgebot.dataclasses.Configuration
 import me.ddivad.judgebot.dataclasses.Infraction
 import me.ddivad.judgebot.dataclasses.InfractionType
+import me.ddivad.judgebot.dataclasses.Permissions
 import me.ddivad.judgebot.extensions.testDmStatus
 import me.ddivad.judgebot.services.*
-import me.ddivad.judgebot.extensions.*
 import me.ddivad.judgebot.services.infractions.BadPfpService
 import me.ddivad.judgebot.services.infractions.BadnameService
 import me.ddivad.judgebot.services.infractions.InfractionService
 import me.jakejmattson.discordkt.api.arguments.BooleanArg
 import me.jakejmattson.discordkt.api.arguments.EveryArg
 import me.jakejmattson.discordkt.api.arguments.IntegerArg
-import me.jakejmattson.discordkt.api.arguments.UserArg
+import me.jakejmattson.discordkt.api.conversations.ConversationResult
 import me.jakejmattson.discordkt.api.dsl.commands
 
 @Suppress("unused")
@@ -30,7 +30,7 @@ fun createInfractionCommands(databaseService: DatabaseService,
                              badnameService: BadnameService) = commands("Infraction") {
     guildCommand("strike", "s", "S") {
         description = "Strike a user."
-        requiredPermissionLevel = PermissionLevel.Staff
+        requiredPermission = Permissions.STAFF
         execute(LowerMemberArg, IntegerArg("Weight").optional(1), EveryArg("Reason")) {
             val (targetMember, weight, reason) = args
             val guildConfiguration = config[guild.id.value] ?: return@execute
@@ -46,15 +46,20 @@ fun createInfractionCommands(databaseService: DatabaseService,
                 this.message.addReaction(Emojis.x)
                 respond("${targetMember.mention} has DMs disabled. No messages will be sent.")
             }
-            InfractionConversation(databaseService, config, infractionService)
+            val conversationResult = InfractionConversation(databaseService, config, infractionService)
                     .createInfractionConversation(guild, targetMember, weight, reason, InfractionType.Strike)
                     .startPublicly(discord, author, channel)
+            if (conversationResult == ConversationResult.HAS_CONVERSATION) {
+                message.reply { content = "You already have an active Strike conversation. Make sure you selected a rule." }
+            } else if (conversationResult == ConversationResult.EXITED) {
+                message.reply { content = "Infraction cancelled." }
+            }
         }
     }
 
     guildCommand("warn", "w", "W") {
         description = "Warn a user."
-        requiredPermissionLevel = PermissionLevel.Moderator
+        requiredPermission = Permissions.MODERATOR
         execute(LowerMemberArg, EveryArg("Reason")) {
             val (targetMember, reason) = args
             try {
@@ -72,7 +77,7 @@ fun createInfractionCommands(databaseService: DatabaseService,
 
     guildCommand("badpfp") {
         description = "Notifies the user that they should change their profile pic and applies a 30 minute mute. Bans the user if they don't change picture."
-        requiredPermissionLevel = PermissionLevel.Staff
+        requiredPermission = Permissions.STAFF
         execute(BooleanArg("cancel", "apply", "cancel").optional(true), LowerMemberArg) {
             val (cancel, targetMember) = args
             try {
@@ -103,7 +108,7 @@ fun createInfractionCommands(databaseService: DatabaseService,
 
     guildCommand("badname") {
         description = "Rename a guild member that has a bad name."
-        requiredPermissionLevel = PermissionLevel.Moderator
+        requiredPermission = Permissions.MODERATOR
         execute(LowerMemberArg) {
             badnameService.chooseRandomNickname(args.first)
             respond("User renamed to ${args.first.mention}")
@@ -112,7 +117,7 @@ fun createInfractionCommands(databaseService: DatabaseService,
 
     guildCommand("cleanseInfractions") {
         description = "Use this to delete (permanently) as user's infractions."
-        requiredPermissionLevel = PermissionLevel.Administrator
+        requiredPermission = Permissions.ADMINISTRATOR
         execute(LowerUserArg) {
             val user = databaseService.users.getOrCreateUser(args.first, guild)
             if (user.getGuildInfo(guild.id.asString).infractions.isEmpty()) {
@@ -126,7 +131,7 @@ fun createInfractionCommands(databaseService: DatabaseService,
 
     guildCommand("removeInfraction") {
         description = "Use this to delete (permanently) an infraction from a user."
-        requiredPermissionLevel = PermissionLevel.Administrator
+        requiredPermission = Permissions.ADMINISTRATOR
         execute(LowerUserArg, IntegerArg("Infraction ID")) {
             val user = databaseService.users.getOrCreateUser(args.first, guild)
             if (user.getGuildInfo(guild.id.asString).infractions.isEmpty()) {

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

@@ -4,8 +4,8 @@ import dev.kord.common.exception.RequestException
 import dev.kord.x.emoji.Emojis
 import dev.kord.x.emoji.addReaction
 import me.ddivad.judgebot.arguments.LowerMemberArg
+import me.ddivad.judgebot.dataclasses.Permissions
 import me.ddivad.judgebot.extensions.testDmStatus
-import me.ddivad.judgebot.services.*
 import me.ddivad.judgebot.services.infractions.MuteService
 import me.ddivad.judgebot.services.infractions.RoleState
 import me.ddivad.judgebot.util.timeToString
@@ -18,7 +18,7 @@ import kotlin.math.roundToLong
 fun createMuteCommands(muteService: MuteService) = commands("Mute") {
     guildCommand("mute") {
         description = "Mute a user for a specified time."
-        requiredPermissionLevel = PermissionLevel.Moderator
+        requiredPermission = Permissions.MODERATOR
         execute(LowerMemberArg, TimeArg("Time"), EveryArg("Reason")) {
             val (targetMember, length, reason) = args
             try {
@@ -35,7 +35,7 @@ fun createMuteCommands(muteService: MuteService) = commands("Mute") {
 
     guildCommand("unmute") {
         description = "Unmute a user."
-        requiredPermissionLevel = PermissionLevel.Moderator
+        requiredPermission = Permissions.MODERATOR
         execute(LowerMemberArg) {
             val targetMember = args.first
             if (muteService.checkRoleState(guild, targetMember) == RoleState.None) {
@@ -50,7 +50,7 @@ fun createMuteCommands(muteService: MuteService) = commands("Mute") {
 
     guildCommand("gag") {
         description = "Mute a user for 5 minutes while you deal with something"
-        requiredPermissionLevel = PermissionLevel.Moderator
+        requiredPermission = Permissions.MODERATOR
         execute(LowerMemberArg) {
             val targetMember = args.first
             if (muteService.checkRoleState(guild, targetMember) == RoleState.Tracked) {

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

@@ -1,9 +1,8 @@
 package me.ddivad.judgebot.commands
 
 import me.ddivad.judgebot.arguments.LowerMemberArg
+import me.ddivad.judgebot.dataclasses.Permissions
 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.arguments.UserArg
@@ -13,7 +12,7 @@ import me.jakejmattson.discordkt.api.dsl.commands
 fun noteCommands(databaseService: DatabaseService) = commands("Note") {
     guildCommand("note") {
         description = "Use this to add a note to a user."
-        requiredPermissionLevel = PermissionLevel.Moderator
+        requiredPermission = Permissions.MODERATOR
         execute(UserArg, EveryArg("Note Content")) {
             val (target, note) = args
             val user = databaseService.users.getOrCreateUser(target, guild)
@@ -24,7 +23,7 @@ fun noteCommands(databaseService: DatabaseService) = commands("Note") {
 
     guildCommand("editNote") {
         description = "Use this to edit a note."
-        requiredPermissionLevel = PermissionLevel.Moderator
+        requiredPermission = Permissions.MODERATOR
         execute(UserArg, IntegerArg("Note to edit"), EveryArg("Note Content")) {
             val (target, noteId, note) = args
             val user = databaseService.users.getOrCreateUser(target, guild)
@@ -39,7 +38,7 @@ fun noteCommands(databaseService: DatabaseService) = commands("Note") {
 
     guildCommand("deleteNote") {
         description = "Use this to add a delete a note from a user."
-        requiredPermissionLevel = PermissionLevel.Staff
+        requiredPermission = Permissions.STAFF
         execute(LowerMemberArg, IntegerArg("Note ID")) {
             val (target, noteId) = args
             val user = databaseService.users.getOrCreateUser(target, guild)
@@ -54,7 +53,7 @@ fun noteCommands(databaseService: DatabaseService) = commands("Note") {
 
     guildCommand("cleanseNotes") {
         description = "Use this to delete (permanently) as user's notes."
-        requiredPermissionLevel = PermissionLevel.Administrator
+        requiredPermission = Permissions.ADMINISTRATOR
         execute(LowerMemberArg) {
             val target = args.first
             val user = databaseService.users.getOrCreateUser(target, guild)