feat: miscellaneous updates

- Update logging for gags.
- Add edit note command.
- Update text in rule embeds for infractions.
- Cleanup of staff reaction listeners.

Author: ddivad195

commands.md

@@ -34,11 +34,12 @@
 | unmute   | LowerMemberArg               | Unmute a user.                                          |
 
 ## Notes
-| Commands     | Arguments               | Description                                       |
-| ------------ | ----------------------- | ------------------------------------------------- |
-| cleansenotes | LowerMemberArg          | Use this to delete (permanently) as user's notes. |
-| deleteNote   | LowerMemberArg, Note ID | Use this to add a delete a note from a user.      |
-| note         | User, Note Content      | Use this to add a note to a user.                 |
+| Commands     | Arguments                        | Description                                       |
+| ------------ | -------------------------------- | ------------------------------------------------- |
+| cleansenotes | LowerMemberArg                   | Use this to delete (permanently) as user's notes. |
+| deleteNote   | LowerMemberArg, Note ID          | Use this to add a delete a note from a user.      |
+| editNote     | User, Note to edit, Note Content | Use this to edit a note.                          |
+| note         | User, Note Content               | Use this to add a note to a user.                 |
 
 ## Rules
 | Commands    | Arguments | Description                                                                                       |

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

@@ -58,7 +58,7 @@ fun createMuteCommands(muteService: MuteService) = commands("Mute") {
                 return@execute
             }
             val time = 1000L * 60 * 5
-            muteService.gag(targetMember)
+            muteService.gag(guild, targetMember, author)
 
             respond("${targetMember.mention} has been muted for ${timeToString(time)}")
         }

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

@@ -22,6 +22,21 @@ fun noteCommands(databaseService: DatabaseService) = commands("Notes") {
         }
     }
 
+    guildCommand("editNote") {
+        description = "Use this to edit a note."
+        requiredPermissionLevel = PermissionLevel.Moderator
+        execute(UserArg, IntegerArg("Note to edit"), EveryArg("Note Content")) {
+            val (target, noteId, note) = args
+            val user = databaseService.users.getOrCreateUser(target, guild)
+            if (user.getGuildInfo(guild.id.value).notes.none{ it.id == noteId }) {
+                respond("User has no note with ID $noteId.")
+                return@execute
+            }
+            databaseService.users.editNote(guild, user, noteId, note, author.id.value)
+            respond("Note edited.")
+        }
+    }
+
     guildCommand("deleteNote") {
         description = "Use this to add a delete a note from a user."
         requiredPermissionLevel = PermissionLevel.Staff

src/main/kotlin/me/ddivad/judgebot/dataclasses/GuildMember.kt

@@ -30,6 +30,13 @@ data class GuildMember(
         this.notes.add(Note(note, moderator, DateTime().millis, nextId))
     }
 
+    fun editNote(guild: Guild, noteId: Int, newNote: String, moderator: String) = with(this.getGuildInfo(guild.id.value)) {
+        this.notes.find { it.id == noteId }?.let{
+            it.note = newNote
+            it.moderator = moderator
+        }
+    }
+
     fun deleteNote(noteId: Int, guild: Guild) = with(this.getGuildInfo(guild.id.value)) {
         this.notes.removeIf { it.id == noteId }
     }

src/main/kotlin/me/ddivad/judgebot/dataclasses/Note.kt

@@ -2,10 +2,11 @@ package me.ddivad.judgebot.dataclasses
 
 import org.joda.time.DateTime
 
-data class Note(val note: String,
-                val moderator: String,
-                val dateTime: Long,
-                val id: Int)
+data class Note(
+    var note: String,
+    var moderator: String,
+    val dateTime: Long,
+    val id: Int)
 
 data class Info(val message: String,
                 val moderator: String,

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

@@ -54,7 +54,7 @@ fun EmbedBuilder.createInfractionRuleEmbed(guild: Guild, rules: List<Rule>) {
         text = guild.name
     }
     addField("","")
-    addField("Rule Choice:", "Reply with **rule id**, or **0** for no rule.")
+    addField("Rule Choice:", "Reply with **rule id**, or **0** for no rule.\nYou can also type **cancel** to stop this process.")
 }
 
 fun EmbedBuilder.createRulesEmbedDetailed(guild: Guild, rules: List<Rule>) {

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

@@ -26,26 +26,25 @@ fun onStaffReactionAdd(muteService: MuteService,
         val guild = guild?.asGuildOrNull() ?: return@on
         val guildConfiguration = configuration[guild.asGuild().id.longValue]
         if (!guildConfiguration?.reactions!!.enabled) return@on
-        val member = user.asMemberOrNull(guild.id) ?: return@on
+        val staffMember = user.asMemberOrNull(guild.id) ?: return@on
         val messageAuthor = message.asMessage().author?.asMemberOrNull(guild.id) ?: return@on
         val msg = message.asMessage()
 
-        if (permissionsService.hasPermission(member, PermissionLevel.Moderator) && !member.isHigherRankedThan(permissionsService, messageAuthor)) {
+        if (permissionsService.hasPermission(staffMember, PermissionLevel.Moderator) && !staffMember.isHigherRankedThan(permissionsService, messageAuthor)) {
             when (this.emoji.name) {
                 guildConfiguration.reactions.gagReaction -> {
-                    val target = messageAuthor.asMember(guild.id)
                     msg.deleteReaction(this.emoji)
-                    if (muteService.checkRoleState(guild, target) == RoleState.Tracked) {
-                        member.sendPrivateMessage("${messageAuthor.mention} is already muted.")
+                    if (muteService.checkRoleState(guild, messageAuthor) == RoleState.Tracked) {
+                        staffMember.sendPrivateMessage("${messageAuthor.mention} is already muted.")
                         return@on
                     }
-                    muteService.gag(target)
-                    member.sendPrivateMessage("${messageAuthor.mention} gagged.")
+                    muteService.gag(guild, messageAuthor, staffMember)
+                    staffMember.sendPrivateMessage("${messageAuthor.mention} gagged.")
                 }
                 guildConfiguration.reactions.historyReaction -> {
                     msg.deleteReaction(this.emoji)
                     val target = databaseService.users.getOrCreateUser(messageAuthor, guild.asGuild())
-                    member.sendPrivateMessage { createSelfHistoryEmbed(messageAuthor, target, guild.asGuild(), configuration) }
+                    staffMember.sendPrivateMessage { createSelfHistoryEmbed(messageAuthor, target, guild.asGuild(), configuration) }
                 }
                 guildConfiguration.reactions.deleteMessageReaction -> {
                     msg.deleteReaction(this.emoji)
@@ -55,7 +54,7 @@ fun onStaffReactionAdd(muteService: MuteService,
                             createMessageDeleteEmbed(guild, msg)
                         }
                     } catch (ex: RequestException) {
-                        this.user.sendPrivateMessage("User ${messageAuthor.mention} has DM's disabled." +
+                        staffMember.sendPrivateMessage("User ${messageAuthor.mention} has DM's disabled." +
                                 " Message deleted without notification.")
                     }
 

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

@@ -74,6 +74,9 @@ class LoggingService(private val configuration: Configuration) {
     suspend fun dmDisabled(guild: Guild, target: User) =
         log(guild, "**Info ::** Attempted to send direct message to ${target.mention} :: ${target.id.value} but they have DMs disabled")
 
+    suspend fun gagApplied(guild: Guild, target: Member, moderator: User) =
+        log(guild, "**Info ::** User ${target.mention} has been gagged by **${moderator.username} :: ${moderator.tag}**")
+
     private suspend fun log(guild: Guild, message: String) {
         getLoggingChannel(guild)?.createMessage(message)
         println("${SimpleDateFormat("dd/M/yyyy HH:mm:ss").format(Date())} > ${guild.name} > $message")

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

@@ -38,6 +38,11 @@ class UserOperations(connection: ConnectionService, private val configuration: C
         return this.updateUser(user)
     }
 
+    suspend fun editNote(guild: Guild, user: GuildMember, noteId: Int, newContent: String, moderator: String): GuildMember {
+        user.editNote(guild, noteId, newContent, moderator)
+        return this.updateUser(user)
+    }
+
     suspend fun deleteNote(guild: Guild, user: GuildMember, noteId: Int): GuildMember {
         user.deleteNote(noteId, guild)
         return this.updateUser(user)

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

@@ -79,8 +79,9 @@ class MuteService(val configuration: Configuration,
         }
     }
 
-    suspend fun gag(target: Member) {
-        this.applyMute(target, 1000L * 60 * 5, "You've been muted temporarily so that a mod can handle something.")
+    suspend fun gag(guild: Guild, target: Member, moderator: User) {
+        loggingService.gagApplied(guild, target, moderator)
+        this.applyMute(target, 1000L * 60 * 5, "You've been muted temporarily by staff.")
     }
 
     fun removeMute(guild: Guild, user: User) {