GH-870 Add /msgtoggle command (#896)

* Innit commit

* In progress: add messages, setup methods and commands

* Add msgToggle repo, service, API and commands

* Fix logic

* Fix logic, rename messages

* Remove comments

* Delete duplicated message.

* Update eternalcore-api/src/main/java/com/eternalcode/core/feature/msgtoggle/MsgToggle.java

Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>

* Delete duplicated message.

* Fix coderabbit issue

* Fix naming and logic.

* Resolve @imDMK review

* Add comments to api

* Resolve Rollcz's review

* Resolve coderabbit review

* Update README.md

* Fix logic: enable -> enable priv messages.

* Resolve @coderabbitai nitpick comment, simplify command and api

* Refactor names of variables following vLuckyyy comment

* Change name from toggleState to State

* Simplify logic (i hope @Rollczi will like it) refactor to PrivateChatState instead of toggle

* Resolve master changes

* Resolve @coderabbitai 's review

* Cleanup method and parameters names. Remove unused classes.

* Simplify commands

* Fix command messages

---------

Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>
Co-authored-by: Rollczi <[email protected]>

Author: 3 people

README.md

@@ -40,7 +40,7 @@ Get the latest development builds from our [GitHub Actions](https://github.com/E
   - Chat On/Off Switch
   - Chat Slow Mode
   - /ignore and /unignore (with -all option)
-  - /msg, /socialspy, and /reply commands
+  - /msg, /msgtoggle, /socialspy, and /reply commands
   - /helpop command
   - Advanced Notification System allowing you to customize every message to your liking (Title, Subtitle, Actionbar, Chat, etc.) 
 - :hammer: Open Utility Blocks with simple commands like `/workbench`

eternalcore-api/src/main/java/com/eternalcode/core/feature/privatechat/toggle/PrivateChatState.java

@@ -0,0 +1,22 @@
+package com.eternalcode.core.feature.privatechat.toggle;
+
+/**
+ * Enum representing state of blocking incoming private messages by the player.
+ */
+public enum PrivateChatState {
+
+    /**
+     * Player can receive private messages.
+     */
+    ENABLE,
+
+    /**
+     * Player cannot receive private messages.
+     */
+    DISABLE;
+
+    PrivateChatState invert() {
+        return this == ENABLE ? DISABLE : ENABLE;
+    }
+
+}

eternalcore-api/src/main/java/com/eternalcode/core/feature/privatechat/toggle/PrivateChatStateService.java

@@ -0,0 +1,36 @@
+package com.eternalcode.core.feature.privatechat.toggle;
+
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+
+/**
+ * This Service manages player's receiving of private messages
+ */
+public interface PrivateChatStateService {
+
+    /**
+     * Checks status of player's private chat messages blocking.
+     *
+     * @param playerUniqueId player's UUID.
+     * @return state of player's private chat messages blocking.
+     */
+    CompletableFuture<PrivateChatState> getChatState(UUID playerUniqueId);
+
+    /**
+     * Sets blocking of incoming private messages.
+     *
+     * @param playerUniqueId player's UUID.
+     * @param state desired state of player's private chat messages blocking.
+     */
+    CompletableFuture<Void> setChatState(UUID playerUniqueId, PrivateChatState state);
+
+
+    /**
+     * Toggle blocking of incoming private messages.
+     *
+     * @param playerUniqueId player's UUID.
+     * @return new state of player's private chat messages blocking.
+     */
+    CompletableFuture<PrivateChatState> toggleChatState(UUID playerUniqueId);
+
+}

eternalcore-core/src/main/java/com/eternalcode/core/feature/privatechat/PrivateChatServiceImpl.java

@@ -2,6 +2,8 @@
 
 import com.eternalcode.core.event.EventCaller;
 import com.eternalcode.core.feature.ignore.IgnoreService;
+import com.eternalcode.core.feature.privatechat.toggle.PrivateChatStateService;
+import com.eternalcode.core.feature.privatechat.toggle.PrivateChatState;
 import com.eternalcode.core.injector.annotations.Inject;
 import com.eternalcode.core.injector.annotations.component.Service;
 import com.eternalcode.core.notice.NoticeService;
@@ -24,6 +26,7 @@ class PrivateChatServiceImpl implements PrivateChatService {
     private final UserManager userManager;
     private final PrivateChatPresenter presenter;
     private final EventCaller eventCaller;
+    private final PrivateChatStateService privateChatStateService;
 
     private final Cache<UUID, UUID> replies = CacheBuilder.newBuilder()
         .expireAfterWrite(Duration.ofHours(1))
@@ -36,12 +39,14 @@ class PrivateChatServiceImpl implements PrivateChatService {
         NoticeService noticeService,
         IgnoreService ignoreService,
         UserManager userManager,
-        EventCaller eventCaller
+        EventCaller eventCaller,
+        PrivateChatStateService privateChatStateService
     ) {
         this.noticeService = noticeService;
         this.ignoreService = ignoreService;
         this.userManager = userManager;
         this.eventCaller = eventCaller;
+        this.privateChatStateService = privateChatStateService;
 
         this.presenter = new PrivateChatPresenter(noticeService);
     }
@@ -53,15 +58,25 @@ void privateMessage(User sender, User target, String message) {
             return;
         }
 
-        this.ignoreService.isIgnored(target.getUniqueId(), sender.getUniqueId()).thenAccept(isIgnored -> {
-            if (!isIgnored) {
-                this.replies.put(target.getUniqueId(), sender.getUniqueId());
-                this.replies.put(sender.getUniqueId(), target.getUniqueId());
+        UUID uniqueId = target.getUniqueId();
+
+        this.privateChatStateService.getChatState(uniqueId).thenAccept(privateChatState -> {
+            if (privateChatState == PrivateChatState.DISABLE) {
+                this.noticeService.player(sender.getUniqueId(), translation -> translation.privateChat().receiverDisabledMessages());
+
+                return;
             }
 
-            PrivateChatEvent event = new PrivateChatEvent(sender.getUniqueId(), target.getUniqueId(), message);
-            this.eventCaller.callEvent(event);
-            this.presenter.onPrivate(new PrivateMessage(sender, target, event.getContent(), this.socialSpy, isIgnored));
+            this.ignoreService.isIgnored(uniqueId, sender.getUniqueId()).thenAccept(isIgnored -> {
+                if (!isIgnored) {
+                    this.replies.put(uniqueId, sender.getUniqueId());
+                    this.replies.put(sender.getUniqueId(), uniqueId);
+                }
+
+                PrivateChatEvent event = new PrivateChatEvent(sender.getUniqueId(), uniqueId, message);
+                this.eventCaller.callEvent(event);
+                this.presenter.onPrivate(new PrivateMessage(sender, target, event.getContent(), this.socialSpy, isIgnored));
+            });
         });
     }
 

eternalcore-core/src/main/java/com/eternalcode/core/feature/privatechat/messages/ENPrivateMessages.java

@@ -24,6 +24,15 @@ public class ENPrivateMessages implements PrivateChatMessages {
     public Notice socialSpyMessage = Notice.chat(
         "<dark_gray>[<red>ss<dark_gray>] <dark_gray>[<gray>{SENDER} -> <white>{TARGET}<dark_gray>]<gray>: <white>{MESSAGE}");
 
+    public Notice receiverDisabledMessages = Notice.chat("<red>► <dark_red>This player has disabled private messages!");
+
+    public Notice selfMessagesDisabled = Notice.chat("<green>► <white>Private messages have been <red>disabled<white>!");
+    public Notice selfMessagesEnabled = Notice.chat("<green>► <white>Private messages have been <green>enabled<white>!");
+
+    @Description("# {PLAYER} - Player")
+    public Notice otherMessagesDisabled = Notice.chat("<green>► <white>Private messages have been <red>disabled <white>for <green>{PLAYER}<white>!");
+    public Notice otherMessagesEnabled = Notice.chat("<green>► <white>Private messages have been <green>enabled <white>for <green>{PLAYER}<white>!");
+
     @Description(" ")
     public Notice socialSpyEnable = Notice.chat("<green>► <white>SocialSpy has been {STATE}<white>!");
     public Notice socialSpyDisable = Notice.chat("<red>► <white>SocialSpy has been {STATE}<white>!");
@@ -39,10 +48,10 @@ public class ENPrivateMessages implements PrivateChatMessages {
     public Notice alreadyIgnorePlayer = Notice.chat("<red>► <dark_red>You already ignore this player!");
 
     @Description("# {PLAYER} - Unignored player")
-    public Notice unIgnorePlayer = Notice.chat("<red>► <dark_red>{PLAYER} <red>player has been uningored!");
+    public Notice unIgnorePlayer = Notice.chat("<red>► <dark_red>{PLAYER} <red>player has been unignored!");
 
     @Description(" ")
-    public Notice unIgnoreAll = Notice.chat("<red>► <dark_red>All players have been uningored!");
+    public Notice unIgnoreAll = Notice.chat("<red>► <dark_red>All players have been unignored!");
     public Notice cantUnIgnoreYourself = Notice.chat("<red>► <dark_red>You can't unignore yourself!");
 
     @Description({" ", "# {PLAYER} - Ignored player"})

eternalcore-core/src/main/java/com/eternalcode/core/feature/privatechat/messages/PLPrivateChatMessages.java

@@ -29,6 +29,15 @@ public class PLPrivateChatMessages implements PrivateChatMessages {
     public Notice socialSpyEnable = Notice.chat("<green>► <white>SocialSpy został {STATE}<white>!");
     public Notice socialSpyDisable = Notice.chat("<red>► <white>SocialSpy został {STATE}<white>!");
 
+    public Notice receiverDisabledMessages = Notice.chat("<red>► <dark_red>Wiadomości prywatne zostały wyłączone!");
+
+    public Notice selfMessagesDisabled = Notice.chat("<green>► <white>Wiadomości prywatne zostały <red>wyłączone!");
+    public Notice selfMessagesEnabled = Notice.chat("<green>► <white>Wiadomości prywatne zostały <green>włączone!");
+
+    @Description({" ", "# {PLAYER} - Gracz któremu wyłączono wiadomości prywatne"})
+    public Notice otherMessagesDisabled = Notice.chat("<green>► <white>Wiadomości prywatne zostały <red>wyłączone <white>dla gracza <green>{PLAYER}<white>!");
+    public Notice otherMessagesEnabled = Notice.chat("<green>► <white>Wiadomości prywatne zostały <green>włączone <white>dla gracza <green>{PLAYER}<white>!");
+
     @Description({" ", "# {PLAYER} - Gracz który jest zignorowany"})
     public Notice ignorePlayer = Notice.chat("<green>► <white>Zignorowano gracza <red>{PLAYER}<white>!");
 

eternalcore-core/src/main/java/com/eternalcode/core/feature/privatechat/messages/PrivateChatMessages.java

@@ -11,6 +11,12 @@ public interface PrivateChatMessages {
     Notice socialSpyEnable();
     Notice socialSpyDisable();
 
+    Notice receiverDisabledMessages();
+    Notice selfMessagesDisabled();
+    Notice selfMessagesEnabled();
+    Notice otherMessagesDisabled();
+    Notice otherMessagesEnabled();
+
     Notice ignorePlayer();
     Notice ignoreAll();
     Notice unIgnorePlayer();

eternalcore-core/src/main/java/com/eternalcode/core/feature/privatechat/toggle/PrivateChatStateCommand.java

@@ -0,0 +1,88 @@
+package com.eternalcode.core.feature.privatechat.toggle;
+
+import com.eternalcode.annotations.scan.command.DescriptionDocs;
+import com.eternalcode.core.injector.annotations.Inject;
+import com.eternalcode.core.notice.NoticeService;
+import dev.rollczi.litecommands.annotations.argument.Arg;
+import dev.rollczi.litecommands.annotations.command.Command;
+import dev.rollczi.litecommands.annotations.context.Context;
+import dev.rollczi.litecommands.annotations.execute.Execute;
+import dev.rollczi.litecommands.annotations.permission.Permission;
+import java.util.UUID;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+@Command(name = "msgtoggle")
+@Permission("eternalcore.msgtoggle")
+class PrivateChatStateCommand {
+
+    private final PrivateChatStateService privateChatStateService;
+    private final NoticeService noticeService;
+
+    @Inject
+    PrivateChatStateCommand(PrivateChatStateService privateChatStateService, NoticeService noticeService) {
+        this.privateChatStateService = privateChatStateService;
+        this.noticeService = noticeService;
+    }
+
+    @Execute
+    @DescriptionDocs(description = "Toggle receiving private messages")
+    void execute(@Context Player sender) {
+        UUID player = sender.getUniqueId();
+        this.privateChatStateService.toggleChatState(player)
+            .thenAccept(toggledState -> noticePlayer(toggledState, player));
+    }
+
+    @Execute
+    @DescriptionDocs(description = "Switch receiving private messages", arguments = "<state>")
+    void execute(@Context Player sender, @Arg PrivateChatState state) {
+        UUID player = sender.getUniqueId();
+        this.privateChatStateService.setChatState(player, state)
+            .thenAccept(ignored -> noticePlayer(state, player));
+    }
+
+    @Execute
+    @Permission("eternalcore.msgtoggle.other")
+    @DescriptionDocs(description = "Switch receiving private messages for other player", arguments = "<player>")
+    void other(@Context CommandSender sender, @Arg Player target) {
+        UUID player = target.getUniqueId();
+        this.privateChatStateService.toggleChatState(player)
+            .thenAccept(toggledState -> noticeOtherPlayer(sender, toggledState, target));
+    }
+
+    @Execute
+    @Permission("eternalcore.msgtoggle.other")
+    @DescriptionDocs(description = "Switch receiving private messages for other player", arguments = "<player>  <toggle>")
+    void other(@Context CommandSender sender, @Arg Player target, @Arg PrivateChatState state) {
+        UUID player = target.getUniqueId();
+        this.privateChatStateService.setChatState(player, state)
+            .thenAccept(ignored -> noticeOtherPlayer(sender, state, target));
+    }
+
+    private void noticeOtherPlayer(CommandSender sender, PrivateChatState state, Player target) {
+        this.noticePlayer(state, target.getUniqueId());
+        if (sender.equals(target)) {
+            return;
+        }
+
+        this.noticeService.create()
+            .sender(sender)
+            .notice(translation -> state == PrivateChatState.DISABLE
+                ? translation.privateChat().otherMessagesDisabled()
+                : translation.privateChat().otherMessagesEnabled()
+            )
+            .placeholder("{PLAYER}", target.getName())
+            .send();
+    }
+
+    private void noticePlayer(PrivateChatState state, UUID player) {
+        this.noticeService.create()
+            .player(player)
+            .notice(translation -> state == PrivateChatState.ENABLE
+                ? translation.privateChat().selfMessagesEnabled()
+                : translation.privateChat().selfMessagesDisabled()
+            )
+            .send();
+    }
+
+}

eternalcore-core/src/main/java/com/eternalcode/core/feature/privatechat/toggle/PrivateChatStateRepository.java

@@ -0,0 +1,13 @@
+package com.eternalcode.core.feature.privatechat.toggle;
+
+
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+
+interface PrivateChatStateRepository {
+
+    CompletableFuture<PrivateChatState> getPrivateChatState(UUID uuid);
+
+    CompletableFuture<Void> setPrivateChatState(UUID uuid, PrivateChatState toggledOff);
+
+}

eternalcore-core/src/main/java/com/eternalcode/core/feature/privatechat/toggle/PrivateChatStateRepositoryOrmLite.java

@@ -0,0 +1,35 @@
+package com.eternalcode.core.feature.privatechat.toggle;
+
+import com.eternalcode.commons.scheduler.Scheduler;
+import com.eternalcode.core.database.DatabaseManager;
+import com.eternalcode.core.database.wrapper.AbstractRepositoryOrmLite;
+import com.eternalcode.core.injector.annotations.Inject;
+import com.eternalcode.core.injector.annotations.component.Repository;
+import com.j256.ormlite.table.TableUtils;
+import java.sql.SQLException;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+
+@Repository
+class PrivateChatStateRepositoryOrmLite extends AbstractRepositoryOrmLite implements PrivateChatStateRepository {
+
+    @Inject
+    private PrivateChatStateRepositoryOrmLite(DatabaseManager databaseManager, Scheduler scheduler) throws SQLException {
+        super(databaseManager, scheduler);
+        TableUtils.createTableIfNotExists(databaseManager.connectionSource(), PrivateChatStateWrapper.class);
+    }
+
+    @Override
+    public CompletableFuture<PrivateChatState> getPrivateChatState(UUID uuid) {
+        return this.selectSafe(PrivateChatStateWrapper.class, uuid)
+            .thenApply(
+                optional -> optional.map(PrivateChatStateWrapper::isEnabled).orElse(PrivateChatState.ENABLE)
+            ).exceptionally(throwable -> PrivateChatState.ENABLE);
+    }
+
+    @Override
+    public CompletableFuture<Void> setPrivateChatState(UUID uuid, PrivateChatState state) {
+        return this.save(PrivateChatStateWrapper.class, new PrivateChatStateWrapper(uuid, state))
+            .thenApply(status -> null);
+    }
+}

eternalcore-core/src/main/java/com/eternalcode/core/feature/privatechat/toggle/PrivateChatStateServiceImpl.java

@@ -0,0 +1,52 @@
+package com.eternalcode.core.feature.privatechat.toggle;
+
+import com.eternalcode.core.injector.annotations.Inject;
+import com.eternalcode.core.injector.annotations.component.Service;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentSkipListMap;
+
+@Service
+class PrivateChatStateServiceImpl implements PrivateChatStateService {
+
+    private final PrivateChatStateRepository msgToggleRepository;
+    private final ConcurrentHashMap<UUID, PrivateChatState> cachedToggleStates;
+
+    @Inject
+    PrivateChatStateServiceImpl(PrivateChatStateRepository msgToggleRepository) {
+        this.cachedToggleStates = new ConcurrentHashMap<>();
+        this.msgToggleRepository = msgToggleRepository;
+
+    }
+
+
+    @Override
+    public CompletableFuture<PrivateChatState> getChatState(UUID playerUniqueId) {
+        if (this.cachedToggleStates.containsKey(playerUniqueId)) {
+            return CompletableFuture.completedFuture(this.cachedToggleStates.get(playerUniqueId));
+        }
+
+        return this.msgToggleRepository.getPrivateChatState(playerUniqueId);
+    }
+
+    @Override
+    public CompletableFuture<Void> setChatState(UUID playerUniqueId, PrivateChatState state) {
+        this.cachedToggleStates.put(playerUniqueId, state);
+
+        return this.msgToggleRepository.setPrivateChatState(playerUniqueId, state)
+            .exceptionally(throwable -> {
+                this.cachedToggleStates.remove(playerUniqueId);
+                return null;
+            });
+    }
+
+    @Override
+    public CompletableFuture<PrivateChatState> toggleChatState(UUID playerUniqueId) {
+        return this.getChatState(playerUniqueId).thenCompose(state -> {
+            PrivateChatState newState = state.invert();
+            return this.setChatState(playerUniqueId, newState)
+                .thenApply(aVoid -> newState);
+        });
+    }
+}