Logging the /tag-manage command

application/src/main/java/org/togetherjava/tjbot/commands/Features.java

@@ -19,6 +19,7 @@
 import org.togetherjava.tjbot.commands.tophelper.TopHelpersPurgeMessagesRoutine;
 import org.togetherjava.tjbot.config.Config;
 import org.togetherjava.tjbot.db.Database;
+import org.togetherjava.tjbot.moderation.ModAuditLogWriter;
 import org.togetherjava.tjbot.routines.ModAuditLogRoutine;
 
 import java.util.ArrayList;
@@ -50,14 +51,15 @@ public enum Features {
             @NotNull Database database, @NotNull Config config) {
         TagSystem tagSystem = new TagSystem(database);
         ModerationActionsStore actionsStore = new ModerationActionsStore(database);
+        ModAuditLogWriter modAuditLogWriter = new ModAuditLogWriter(config);
 
         // NOTE The system can add special system relevant commands also by itself,
         // hence this list may not necessarily represent the full list of all commands actually
         // available.
         Collection<Feature> features = new ArrayList<>();
 
         // Routines
-        features.add(new ModAuditLogRoutine(database, config));
+        features.add(new ModAuditLogRoutine(database, config, modAuditLogWriter));
         features.add(new TemporaryModerationRoutine(jda, actionsStore, config));
         features.add(new TopHelpersPurgeMessagesRoutine(database));
         features.add(new RemindRoutine(database));
@@ -73,7 +75,7 @@ public enum Features {
         features.add(new PingCommand());
         features.add(new TeXCommand());
         features.add(new TagCommand(tagSystem));
-        features.add(new TagManageCommand(tagSystem, config));
+        features.add(new TagManageCommand(tagSystem, config, modAuditLogWriter));
         features.add(new TagsCommand(tagSystem));
         features.add(new VcActivityCommand());
         features.add(new WarnCommand(actionsStore, config));

application/src/main/java/org/togetherjava/tjbot/commands/tags/TagManageCommand.java

@@ -1,8 +1,10 @@
 package org.togetherjava.tjbot.commands.tags;
 
 import net.dv8tion.jda.api.EmbedBuilder;
+import net.dv8tion.jda.api.entities.Guild;
 import net.dv8tion.jda.api.entities.Member;
 import net.dv8tion.jda.api.entities.Role;
+import net.dv8tion.jda.api.entities.User;
 import net.dv8tion.jda.api.events.interaction.SlashCommandEvent;
 import net.dv8tion.jda.api.exceptions.ErrorResponseException;
 import net.dv8tion.jda.api.interactions.Interaction;
@@ -11,12 +13,17 @@
 import net.dv8tion.jda.api.interactions.commands.build.SubcommandData;
 import net.dv8tion.jda.api.requests.ErrorResponse;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.togetherjava.tjbot.commands.SlashCommandAdapter;
 import org.togetherjava.tjbot.commands.SlashCommandVisibility;
 import org.togetherjava.tjbot.config.Config;
+import org.togetherjava.tjbot.moderation.ModAuditLogWriter;
 
+import java.time.temporal.TemporalAccessor;
+import java.util.*;
+import java.util.NoSuchElementException;
 import java.nio.charset.StandardCharsets;
 import java.time.Instant;
 import java.util.Objects;
@@ -49,21 +56,37 @@ public final class TagManageCommand extends SlashCommandAdapter {
     private static final String CONTENT_DESCRIPTION = "the content of the tag";
     static final String MESSAGE_ID_OPTION = "message-id";
     private static final String MESSAGE_ID_DESCRIPTION = "the id of the message to refer to";
+
+    // "Edited tag **ask**"
+    private static final String LOG_EMBED_DESCRIPTION = "%s tag **%s**";
+
+    private static final String CONTENT_FILE_NAME = "content.md";
+    private static final String NEW_CONTENT_FILE_NAME = "new_content.md";
+    private static final String PREVIOUS_CONTENT_FILE_NAME = "previous_content.md";
+
+    private static final String UNABLE_TO_GET_CONTENT_MESSAGE = "Was unable to retrieve content";
+
     private final TagSystem tagSystem;
     private final Predicate<String> hasRequiredRole;
 
+    private final ModAuditLogWriter modAuditLogWriter;
+
     /**
      * Creates a new instance, using the given tag system as base.
      *
      * @param tagSystem the system providing the actual tag data
      * @param config the config to use for this
+     * @param modAuditLogWriter to log tag changes for audition
      */
-    public TagManageCommand(TagSystem tagSystem, @NotNull Config config) {
+    public TagManageCommand(@NotNull TagSystem tagSystem, @NotNull Config config,
+            @NotNull ModAuditLogWriter modAuditLogWriter) {
         super("tag-manage", "Provides commands to manage all tags", SlashCommandVisibility.GUILD);
 
         this.tagSystem = tagSystem;
         hasRequiredRole = Pattern.compile(config.getTagManageRolePattern()).asMatchPredicate();
 
+        this.modAuditLogWriter = modAuditLogWriter;
+
         // TODO Think about adding a "Are you sure"-dialog to 'edit', 'edit-with-message' and
         // 'delete'
         getData().addSubcommands(new SubcommandData(Subcommand.RAW.name,
@@ -155,31 +178,37 @@ private void rawTag(@NotNull SlashCommandEvent event) {
         }
 
         String content = tagSystem.getTag(id).orElseThrow();
-        event.reply("").addFile(content.getBytes(StandardCharsets.UTF_8), "content.md").queue();
+        event.reply("")
+            .addFile(content.getBytes(StandardCharsets.UTF_8), CONTENT_FILE_NAME)
+            .queue();
     }
 
     private void createTag(@NotNull CommandInteraction event) {
         String content = Objects.requireNonNull(event.getOption(CONTENT_OPTION)).getAsString();
 
-        handleAction(TagStatus.NOT_EXISTS, id -> tagSystem.putTag(id, content), "created", event);
+        handleAction(TagStatus.NOT_EXISTS, id -> tagSystem.putTag(id, content), event,
+                Subcommand.CREATE, content);
     }
 
     private void createTagWithMessage(@NotNull CommandInteraction event) {
-        handleActionWithMessage(TagStatus.NOT_EXISTS, tagSystem::putTag, "created", event);
+        handleActionWithMessage(TagStatus.NOT_EXISTS, tagSystem::putTag, event,
+                Subcommand.CREATE_WITH_MESSAGE);
     }
 
     private void editTag(@NotNull CommandInteraction event) {
         String content = Objects.requireNonNull(event.getOption(CONTENT_OPTION)).getAsString();
 
-        handleAction(TagStatus.EXISTS, id -> tagSystem.putTag(id, content), "edited", event);
+        handleAction(TagStatus.EXISTS, id -> tagSystem.putTag(id, content), event, Subcommand.EDIT,
+                content);
     }
 
     private void editTagWithMessage(@NotNull CommandInteraction event) {
-        handleActionWithMessage(TagStatus.EXISTS, tagSystem::putTag, "edited", event);
+        handleActionWithMessage(TagStatus.EXISTS, tagSystem::putTag, event,
+                Subcommand.EDIT_WITH_MESSAGE);
     }
 
     private void deleteTag(@NotNull CommandInteraction event) {
-        handleAction(TagStatus.EXISTS, tagSystem::deleteTag, "deleted", event);
+        handleAction(TagStatus.EXISTS, tagSystem::deleteTag, event, Subcommand.DELETE, null);
     }
 
     /**
@@ -190,20 +219,28 @@ private void deleteTag(@NotNull CommandInteraction event) {
      *
      * @param requiredTagStatus the required status of the tag
      * @param idAction the action to perform on the id
-     * @param actionVerb the verb describing the executed action, i.e. <i>edited</i> or
-     *        <i>created</i>, will be displayed in the message send to the user
      * @param event the event to send messages with, it must have an {@code id} option set
+     * @param subcommand the subcommand to be executed
+     * @param newContent the new content of the tag, or null if content is unchanged
      */
     private void handleAction(@NotNull TagStatus requiredTagStatus,
-            @NotNull Consumer<? super String> idAction, @NotNull String actionVerb,
-            @NotNull CommandInteraction event) {
+            @NotNull Consumer<? super String> idAction, @NotNull CommandInteraction event,
+            @NotNull Subcommand subcommand, @Nullable String newContent) {
+
         String id = Objects.requireNonNull(event.getOption(ID_OPTION)).getAsString();
         if (isWrongTagStatusAndHandle(requiredTagStatus, id, event)) {
             return;
         }
 
+        String previousContent =
+                getTagContent(subcommand, id).orElse(UNABLE_TO_GET_CONTENT_MESSAGE);
+
         idAction.accept(id);
-        sendSuccessMessage(event, id, actionVerb);
+        sendSuccessMessage(event, id, subcommand.getActionVerb());
+
+        Guild guild = Objects.requireNonNull(event.getGuild());
+        logAction(subcommand, guild, event.getUser(), event.getTimeCreated(), id, newContent,
+                previousContent);
     }
 
     /**
@@ -217,14 +254,14 @@ private void handleAction(@NotNull TagStatus requiredTagStatus,
      *
      * @param requiredTagStatus the required status of the tag
      * @param idAndContentAction the action to perform on the id and content
-     * @param actionVerb the verb describing the executed action, i.e. <i>edited</i> or
-     *        <i>created</i>, will be displayed in the message send to the user
      * @param event the event to send messages with, it must have an {@code id} and
      *        {@code message-id} option set
+     * @param subcommand the subcommand to be executed
      */
     private void handleActionWithMessage(@NotNull TagStatus requiredTagStatus,
             @NotNull BiConsumer<? super String, ? super String> idAndContentAction,
-            @NotNull String actionVerb, @NotNull CommandInteraction event) {
+            @NotNull CommandInteraction event, @NotNull Subcommand subcommand) {
+
         String tagId = Objects.requireNonNull(event.getOption(ID_OPTION)).getAsString();
         OptionalLong messageIdOpt = parseMessageIdAndHandle(
                 Objects.requireNonNull(event.getOption(MESSAGE_ID_OPTION)).getAsString(), event);
@@ -237,8 +274,16 @@ private void handleActionWithMessage(@NotNull TagStatus requiredTagStatus,
         }
 
         event.getMessageChannel().retrieveMessageById(messageId).queue(message -> {
+            String previousContent =
+                    getTagContent(subcommand, tagId).orElse(UNABLE_TO_GET_CONTENT_MESSAGE);
+
             idAndContentAction.accept(tagId, message.getContentRaw());
-            sendSuccessMessage(event, tagId, actionVerb);
+            sendSuccessMessage(event, tagId, subcommand.getActionVerb());
+
+            Guild guild = Objects.requireNonNull(event.getGuild());
+            logAction(subcommand, guild, event.getUser(), event.getTimeCreated(), tagId,
+                    message.getContentRaw(), previousContent);
+
         }, failure -> {
             if (failure instanceof ErrorResponseException ex
                     && ex.getErrorResponse() == ErrorResponse.UNKNOWN_MESSAGE) {
@@ -258,6 +303,30 @@ private void handleActionWithMessage(@NotNull TagStatus requiredTagStatus,
         });
     }
 
+    /**
+     * Gets the content of a tag.
+     *
+     * @param subcommand the subcommand to be executed
+     * @param id the id of the tag to get its content
+     * @return the content of the tag, if present
+     */
+    private @NotNull Optional<String> getTagContent(@NotNull Subcommand subcommand,
+            @NotNull String id) {
+        if (Subcommand.SUBCOMMANDS_WITH_PREVIOUS_CONTENT.contains(subcommand)) {
+            try {
+                return tagSystem.getTag(id);
+            } catch (NoSuchElementException e) {
+                // NOTE Rare race condition, for example if another thread deleted the tag in the
+                // meantime
+                logger.warn(String.format(
+                        "tried to retrieve content of tag '%s', but the content doesn't exist.",
+                        id));
+            }
+        }
+
+        return Optional.empty();
+    }
+
     /**
      * Returns whether the status of the given tag is <b>not equal</b> to the required status.
      * <p>
@@ -285,6 +354,51 @@ private boolean isWrongTagStatusAndHandle(@NotNull TagStatus requiredTagStatus,
         return false;
     }
 
+    private void logAction(@NotNull Subcommand subcommand, @NotNull Guild guild,
+            @NotNull User author, @NotNull TemporalAccessor triggeredAt, @NotNull String id,
+            @Nullable String newContent, @Nullable String previousContent) {
+
+        List<ModAuditLogWriter.Attachment> attachments = new ArrayList<>();
+
+        if (Subcommand.SUBCOMMANDS_WITH_NEW_CONTENT.contains(subcommand)) {
+            if (newContent == null) {
+                throw new IllegalArgumentException(
+                        "newContent is null even though the subcommand should supply a value.");
+            }
+
+            String fileName = (subcommand == Subcommand.CREATE
+                    || subcommand == Subcommand.CREATE_WITH_MESSAGE) ? CONTENT_FILE_NAME
+                            : NEW_CONTENT_FILE_NAME;
+
+            attachments.add(new ModAuditLogWriter.Attachment(fileName, newContent));
+
+        }
+
+        if (Subcommand.SUBCOMMANDS_WITH_PREVIOUS_CONTENT.contains(subcommand)) {
+            if (previousContent == null) {
+                throw new IllegalArgumentException(
+                        "previousContent is null even though the subcommand should supply a value.");
+            }
+
+            attachments
+                .add(new ModAuditLogWriter.Attachment(PREVIOUS_CONTENT_FILE_NAME, previousContent));
+        }
+
+        String title = switch (subcommand) {
+            case CREATE -> "Tag-Manage Create";
+            case CREATE_WITH_MESSAGE -> "Tag-Manage Create with message";
+            case EDIT -> "Tag-Manage Edit";
+            case EDIT_WITH_MESSAGE -> "Tag-Manage Edit with message";
+            case DELETE -> "Tag-Manage Delete";
+            default -> throw new IllegalArgumentException(
+                    "The subcommand '%s' is not intended to be logged to the mod audit channel.");
+        };
+
+        modAuditLogWriter.write(title,
+                LOG_EMBED_DESCRIPTION.formatted(subcommand.getActionVerb(), id), author,
+                triggeredAt, guild, attachments.toArray(ModAuditLogWriter.Attachment[]::new));
+    }
+
     private boolean hasTagManageRole(@NotNull Member member) {
         return member.getRoles().stream().map(Role::getName).anyMatch(hasRequiredRole);
     }
@@ -296,17 +410,25 @@ private enum TagStatus {
 
 
     enum Subcommand {
-        RAW("raw"),
-        CREATE("create"),
-        CREATE_WITH_MESSAGE("create-with-message"),
-        EDIT("edit"),
-        EDIT_WITH_MESSAGE("edit-with-message"),
-        DELETE("delete");
+        RAW("raw", ""),
+        CREATE("create", "created"),
+        CREATE_WITH_MESSAGE("create-with-message", "created"),
+        EDIT("edit", "edited"),
+        EDIT_WITH_MESSAGE("edit-with-message", "edited"),
+        DELETE("delete", "deleted");
+
+        private static final Set<Subcommand> SUBCOMMANDS_WITH_NEW_CONTENT =
+                EnumSet.of(CREATE, CREATE_WITH_MESSAGE, EDIT, EDIT_WITH_MESSAGE);
+        private static final Set<Subcommand> SUBCOMMANDS_WITH_PREVIOUS_CONTENT =
+                EnumSet.of(EDIT, EDIT_WITH_MESSAGE, DELETE);
+
 
         private final String name;
+        private final String actionVerb;
 
-        Subcommand(@NotNull String name) {
+        Subcommand(@NotNull String name, @NotNull String actionVerb) {
             this.name = name;
+            this.actionVerb = actionVerb;
         }
 
         @NotNull
@@ -323,5 +445,10 @@ static Subcommand fromName(@NotNull String name) {
             throw new IllegalArgumentException(
                     "Subcommand with name '%s' is unknown".formatted(name));
         }
+
+        @NotNull
+        String getActionVerb() {
+            return actionVerb;
+        }
     }
 }