GH-766 Add multiple notifications at once. (#873)

* Bump LiteCommands version to 3.8.0. Use experimental "Literal" feature.

* Separated alert command
Updated methods removeBroadcastWithType and removeLatestBroadcastWithType
Removed unnecessary import

* Fast fix NullPointerException

* Fix FNF
Fix Duration Override
Added optional command duration argument

* Update eternalcore-core/src/main/java/com/eternalcode/core/feature/essentials/alert/AlertQueueCommand.java

Co-authored-by: Norbert Dejlich <[email protected]>

* Rename EternalCoreBroadcastImpl -> EternalCoreBroadcast

---------

Co-authored-by: Rollczi <[email protected]>

Author: mydelkonivea

buildSrc/src/main/kotlin/Versions.kt

@@ -23,7 +23,7 @@ object Versions {
     const val ORMLITE = "6.1"
     const val HIKARI_CP = "6.0.0"
 
-    const val LITE_COMMANDS = "3.7.1"
+    const val LITE_COMMANDS = "3.8.0"
     const val LITE_SKULL_API = "1.3.0"
 
     const val GUAVA = "33.3.1-jre"

eternalcore-core/src/main/java/com/eternalcode/core/bridge/litecommand/argument/DurationArgument.java

@@ -1,14 +1,14 @@
-package com.eternalcode.core.feature.essentials;
+package com.eternalcode.core.feature.essentials.alert;
 
 import com.eternalcode.annotations.scan.command.DescriptionDocs;
 import com.eternalcode.core.injector.annotations.Inject;
 import com.eternalcode.core.notice.NoticeService;
 import com.eternalcode.core.notice.NoticeTextType;
 import dev.rollczi.litecommands.annotations.argument.Arg;
-import dev.rollczi.litecommands.annotations.join.Join;
+import dev.rollczi.litecommands.annotations.command.Command;
 import dev.rollczi.litecommands.annotations.execute.Execute;
+import dev.rollczi.litecommands.annotations.join.Join;
 import dev.rollczi.litecommands.annotations.permission.Permission;
-import dev.rollczi.litecommands.annotations.command.Command;
 
 @Command(name = "alert", aliases = { "broadcast", "bc" })
 @Permission("eternalcore.alert")

…ore/feature/essentials/AlertCommand.java …ature/essentials/alert/AlertCommand.javaeternalcore-core/src/main/java/com/eternalcode/core/feature/essentials/AlertCommand.java renamed to eternalcore-core/src/main/java/com/eternalcode/core/feature/essentials/alert/AlertCommand.java eternalcore-core/src/main/java/com/eternalcode/core/feature/essentials/AlertCommand.java renamed to eternalcore-core/src/main/java/com/eternalcode/core/feature/essentials/alert/AlertCommand.java

@@ -0,0 +1,85 @@
+package com.eternalcode.core.feature.essentials.alert;
+
+import com.eternalcode.commons.scheduler.Scheduler;
+import com.eternalcode.core.injector.annotations.Inject;
+import com.eternalcode.core.injector.annotations.component.Service;
+import com.eternalcode.core.notice.EternalCoreBroadcast;
+import com.eternalcode.core.notice.NoticeTextType;
+import com.eternalcode.core.translation.Translation;
+import com.eternalcode.core.viewer.Viewer;
+
+import com.eternalcode.multification.notice.NoticeBroadcast;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+
+@Service
+class AlertManager {
+
+    private final static Set<NoticeTextType> DELAYED_TYPES = Set.of(NoticeTextType.TITLE, NoticeTextType.SUBTITLE, NoticeTextType.ACTIONBAR);
+
+    private final Map<AlertKey, List<NoticeBroadcast<Viewer, Translation, ?>>> broadcasts = new HashMap<>();
+    private final Scheduler scheduler;
+
+    @Inject
+    AlertManager(Scheduler scheduler) {
+        this.scheduler = scheduler;
+    }
+
+    void addBroadcast(UUID uuid, NoticeTextType type, NoticeBroadcast<Viewer, Translation, ?> broadcast) {
+        this.broadcasts.computeIfAbsent(new AlertKey(uuid, type), k -> new ArrayList<>()).add(broadcast);
+    }
+
+    boolean removeBroadcastWithType(UUID uuid, NoticeTextType type) {
+        return this.broadcasts.remove(new AlertKey(uuid, type)) != null;
+    }
+
+    boolean removeLatestBroadcastWithType(UUID uuid, NoticeTextType type) {
+        AlertKey key = new AlertKey(uuid, type);
+        List<NoticeBroadcast<Viewer, Translation, ?>> broadcasts = this.broadcasts.get(key);
+
+        if (broadcasts != null && !broadcasts.isEmpty()) {
+            broadcasts.remove(broadcasts.size() - 1);
+            if (broadcasts.isEmpty()) {
+                this.removeBroadcastWithType(uuid, type);
+            }
+            return true;
+        }
+
+        return false;
+    }
+
+    void clearBroadcasts(UUID uuid) {
+        this.broadcasts.entrySet().removeIf(entry -> entry.getKey().uuid().equals(uuid));
+    }
+
+    void send(UUID uuid, Duration delay) {
+        this.broadcasts.forEach((alertKey, broadcasts) -> {
+            if (!alertKey.uuid().equals(uuid)) {
+                return;
+            }
+
+            NoticeTextType type = alertKey.type();
+            if (DELAYED_TYPES.contains(type)) {
+                for (int i = 0; i < broadcasts.size(); i++) {
+                    NoticeBroadcast<Viewer, Translation, ?> broadcast = broadcasts.get(i);
+                    scheduler.runLater(broadcast::send, delay.multipliedBy(i));
+                }
+
+                return;
+            }
+
+            for (NoticeBroadcast<Viewer, Translation, ?> broadcast : broadcasts) {
+                broadcast.send();
+            }
+        });
+
+        clearBroadcasts(uuid);
+    }
+
+    private record AlertKey(UUID uuid, NoticeTextType type) {}
+}

eternalcore-core/src/main/java/com/eternalcode/core/feature/essentials/alert/AlertManager.java

@@ -0,0 +1,91 @@
+package com.eternalcode.core.feature.essentials.alert;
+
+import com.eternalcode.annotations.scan.command.DescriptionDocs;
+import com.eternalcode.core.injector.annotations.Inject;
+import com.eternalcode.core.notice.NoticeService;
+import com.eternalcode.core.notice.NoticeTextType;
+import dev.rollczi.litecommands.annotations.argument.Arg;
+import dev.rollczi.litecommands.annotations.context.Sender;
+import dev.rollczi.litecommands.annotations.join.Join;
+import dev.rollczi.litecommands.annotations.execute.Execute;
+import dev.rollczi.litecommands.annotations.literal.Literal;
+import dev.rollczi.litecommands.annotations.permission.Permission;
+import dev.rollczi.litecommands.annotations.command.Command;
+import org.bukkit.entity.Player;
+
+import java.time.Duration;
+import java.util.Optional;
+
+@Command(name = "alert-queue", aliases = { "alert-q" })
+@Permission("eternalcore.alert.queue")
+class AlertQueueCommand {
+
+    private final NoticeService noticeService;
+    private final AlertManager alertService;
+
+    @Inject
+    AlertQueueCommand(
+        NoticeService noticeService,
+        AlertManager alertService
+    ) {
+        this.noticeService = noticeService;
+        this.alertService = alertService;
+    }
+
+    @Execute(name = "add")
+    @DescriptionDocs(description = "Adds alert to the queue with specified notice type and messages", arguments = "<type> <message>")
+    void executeAdd(@Sender Player sender, @Arg NoticeTextType type, @Join String text) {
+
+        this.alertService.addBroadcast(sender.getUniqueId(), type, this.noticeService.create()
+            .notice(type, translation -> translation.chat().alertMessageFormat())
+            .placeholder("{BROADCAST}", text)
+            .onlinePlayers());
+
+        this.noticeService.create()
+            .player(sender.getUniqueId())
+            .notice(translation -> translation.chat().alertQueueAdded())
+            .send();
+    }
+
+    @Execute(name = "remove")
+    @DescriptionDocs(description = "Removes all alerts of the given type from the queue", arguments = "<type> all")
+    void executeRemoveAll(@Sender Player sender, @Arg NoticeTextType type, @Literal("all") String all) {
+        boolean success = this.alertService.removeBroadcastWithType(sender.getUniqueId(), type);
+
+        this.noticeService.create()
+            .player(sender.getUniqueId())
+            .notice(translation -> success ? translation.chat().alertQueueRemoved() : translation.chat().alertQueueEmpty())
+            .send();
+    }
+
+    @Execute(name = "remove")
+    @DescriptionDocs(description = "Removes a latest alert of the given type from the queue", arguments = "<type> latest")
+    void executeRemove(@Sender Player sender, @Arg NoticeTextType type, @Literal("latest") String latest) {
+        boolean success = this.alertService.removeLatestBroadcastWithType(sender.getUniqueId(), type);
+
+        this.noticeService.create()
+            .player(sender.getUniqueId())
+            .notice(translation -> success ? translation.chat().alertQueueRemoved() : translation.chat().alertQueueEmpty())
+            .send();
+    }
+
+    @Execute(name = "clear")
+    @DescriptionDocs(description = "Clears all alerts from the queue")
+    void executeClear(@Sender Player sender) {
+        this.alertService.clearBroadcasts(sender.getUniqueId());
+        this.noticeService.create()
+            .player(sender.getUniqueId())
+            .notice(translation -> translation.chat().alertQueueCleared())
+            .send();
+    }
+
+    @Execute(name = "send")
+    @DescriptionDocs(description = "Sends all alerts from the queue")
+    void executeSend(@Sender Player sender, @Arg Optional<Duration> duration) {
+        this.alertService.send(sender.getUniqueId(), duration.orElse(Duration.ofSeconds(2)));
+        this.noticeService.create()
+            .player(sender.getUniqueId())
+            .notice(translation -> translation.chat().alertQueueSent())
+            .send();
+    }
+}

eternalcore-core/src/main/java/com/eternalcode/core/feature/essentials/alert/AlertQueueCommand.java

@@ -24,10 +24,10 @@
 /**
  * This class is an extension of {@link NoticeBroadcastImpl} that provides more methods for creating notices.
  */
-public class EternalCoreBroadcastImpl<Viewer, Translation, B extends EternalCoreBroadcastImpl<Viewer, Translation, B>>
+public class EternalCoreBroadcast<Viewer, Translation, B extends EternalCoreBroadcast<Viewer, Translation, B>>
     extends NoticeBroadcastImpl<Viewer, Translation, B> {
 
-    public EternalCoreBroadcastImpl(
+    public EternalCoreBroadcast(
         AsyncExecutor asyncExecutor,
         TranslationProvider<Translation> translationProvider,
         ViewerProvider<Viewer> viewerProvider,

…ore/notice/EternalCoreBroadcastImpl.java …de/core/notice/EternalCoreBroadcast.javaeternalcore-core/src/main/java/com/eternalcode/core/notice/EternalCoreBroadcastImpl.java renamed to eternalcore-core/src/main/java/com/eternalcode/core/notice/EternalCoreBroadcast.java eternalcore-core/src/main/java/com/eternalcode/core/notice/EternalCoreBroadcastImpl.java renamed to eternalcore-core/src/main/java/com/eternalcode/core/notice/EternalCoreBroadcast.java

@@ -112,8 +112,8 @@ public PlatformBroadcaster platformBroadcaster() {
     }
 
     @Override
-    public EternalCoreBroadcastImpl<Viewer, Translation, ?> create() {
-        return new EternalCoreBroadcastImpl<>(
+    public EternalCoreBroadcast<Viewer, Translation, ?> create() {
+        return new EternalCoreBroadcast<>(
             this.asyncExecutor(),
             this.translationProvider(),
             this.viewerProvider(),

eternalcore-core/src/main/java/com/eternalcode/core/notice/NoticeService.java

@@ -6,6 +6,7 @@
 import com.eternalcode.multification.notice.Notice;
 import org.bukkit.Material;
 import org.bukkit.event.entity.EntityDamageEvent;
+
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
@@ -132,6 +133,11 @@ interface ChatSection {
         Notice tellrawNoSaved();
         Notice tellrawMultipleSent();
         Notice tellrawCleared();
+        Notice alertQueueAdded();
+        Notice alertQueueRemoved();
+        Notice alertQueueCleared();
+        Notice alertQueueEmpty();
+        Notice alertQueueSent();
     }
 
     // Warp Section

eternalcore-core/src/main/java/com/eternalcode/core/translation/Translation.java

@@ -296,6 +296,12 @@ public static class ENChatSection implements ChatSection {
         public Notice tellrawNoSaved = Notice.chat("<red>✘ <dark_red>No messages saved in queue!");
         public Notice tellrawMultipleSent = Notice.chat("<green>► <white>Messages sent! Message que has been cleared!");
         public Notice tellrawCleared = Notice.chat("<green>► <white>Message queue cleared!");
+        public Notice alertQueueAdded = Notice.chat("<green>► <white>Message added to the queue!");
+        public Notice alertQueueRemoved = Notice.chat("<green>► <white>Message removed from the queue!");
+        public Notice alertQueueCleared = Notice.chat("<green>► <white>Message queue cleared!");
+        public Notice alertQueueEmpty = Notice.chat("<red>✘ <dark_red>Error: <red>The message queue is empty!");
+        public Notice alertQueueSent = Notice.chat("<green>► <white>All messages sent from the queue!");
+
     }
 
     @Description({

eternalcore-core/src/main/java/com/eternalcode/core/translation/implementation/ENTranslation.java

@@ -299,6 +299,11 @@ public static class PLChatSection implements ChatSection {
         public Notice tellrawNoSaved = Notice.chat("<red>✘ <dark_red>Nie ma zapisanych wiadomości!");
         public Notice tellrawMultipleSent = Notice.chat("<green>► <white>Wysłano wszystkie zapisane wiadomości!");
         public Notice tellrawCleared = Notice.chat("<green>► <white>Wyczyszczono zapisane wiadomości!");
+        public Notice alertQueueAdded = Notice.chat("<green>► <white>Dodano wiadomość do kolejki!");
+        public Notice alertQueueRemoved = Notice.chat("<green>► <white>Usunięto wiadomość z kolejki!");
+        public Notice alertQueueCleared = Notice.chat("<green>► <white>Wyczyszczono kolejkę wiadomości!");
+        public Notice alertQueueEmpty = Notice.chat("<red>✘ <dark_red>Błąd: <red>Kolejka wiadomości jest pusta!");
+        public Notice alertQueueSent = Notice.chat("<green>► <white>Wysłano wszystkie wiadomości z kolejki!");
     }
 
     @Description({