GH-870 Add /msgtoggle command

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,17 @@
+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
+}

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

@@ -0,0 +1,25 @@
+package com.eternalcode.core.feature.privatechat.toggle;
+
+import java.util.UUID;
+
+/**
+ * Represents a player's private chat toggle state.
+ */
+public class PrivateChatToggle {
+
+    UUID uuid;
+    PrivateChatState state;
+
+    public PrivateChatToggle(UUID uuid, PrivateChatState toggle) {
+        this.uuid = uuid;
+        this.state = toggle;
+    }
+
+    public UUID getUuid() {
+        return uuid;
+    }
+
+    public PrivateChatState getState() {
+        return state;
+    }
+}

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

@@ -0,0 +1,27 @@
+package com.eternalcode.core.feature.privatechat.toggle;
+
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+
+/**
+ * This Service manages the state of player's private chat messages blocking
+ */
+public interface PrivateChatToggleService {
+
+    /**
+     * Checks status of player's private chat messages blocking.
+     *
+     * @param uuid player's UUID.
+     * @return state of player's private chat messages blocking.
+     */
+    CompletableFuture<PrivateChatState> getPrivateChatToggleState(UUID uuid);
+
+    /**
+     * Sets blocking of incoming private messages.
+     *
+     * @param uuid player's UUID.
+     * @param toggle desired state of player's private chat messages blocking.
+     */
+    void togglePrivateChat(UUID uuid, PrivateChatState toggle);
+
+}

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.PrivateChatToggleService;
+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 PrivateChatToggleService privateChatToggleService;
 
     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,
+        PrivateChatToggleService privateChatToggleService
     ) {
         this.noticeService = noticeService;
         this.ignoreService = ignoreService;
         this.userManager = userManager;
         this.eventCaller = eventCaller;
+        this.privateChatToggleService = privateChatToggleService;
 
         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.privateChatToggleService.getPrivateChatToggleState(uniqueId).thenAccept(privateChatToggleState -> {
+            if (privateChatToggleState == 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/toggle/PrivateChatToggleCommand.java

@@ -0,0 +1,134 @@
+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.optional.OptionalArg;
+import dev.rollczi.litecommands.annotations.permission.Permission;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+@Command(name = "msgtoggle")
+@Permission("eternalcore.msgtoggle")
+public class PrivateChatToggleCommand {
+
+    private final PrivateChatToggleService privateChatToggleService;
+    private final NoticeService noticeService;
+
+    @Inject
+    public PrivateChatToggleCommand(PrivateChatToggleService privateChatToggleService, NoticeService noticeService) {
+        this.privateChatToggleService = privateChatToggleService;
+        this.noticeService = noticeService;
+    }
+
+    @Execute
+    @DescriptionDocs(description = "Switch receiving private messages", arguments = "<toggle>")
+    public void execute(@Context Player sender, @OptionalArg PrivateChatState state) {
+        UUID uniqueId = sender.getUniqueId();
+
+        if (state == null) {
+            CompletableFuture<PrivateChatState> completablePresentState = this.privateChatToggleService.getPrivateChatToggleState(sender.getUniqueId());
+
+            completablePresentState.thenAccept(presentState -> {
+                if (presentState == PrivateChatState.DISABLE) {
+                    this.enable(uniqueId);
+                }
+                else {
+                    this.disable(uniqueId);
+                }
+            });
+
+            return;
+        }
+
+        if (state == PrivateChatState.DISABLE) {
+            this.disable(uniqueId);
+        }
+        else {
+            this.enable(uniqueId);
+        }
+    }
+
+    @Execute
+    @Permission("eternalcore.msgtoggle.other")
+    @DescriptionDocs(description = "Switch receiving private messages for other player", arguments = "<player>  <toggle>")
+    public void other(@Context CommandSender sender, @Arg("player") Player target, @OptionalArg PrivateChatState state) {
+
+        UUID uniqueId = target.getUniqueId();
+
+        if (state == null) {
+            CompletableFuture<PrivateChatState> completablePresentState = this.privateChatToggleService.getPrivateChatToggleState(uniqueId);
+            completablePresentState.thenAccept(presentState -> {
+                if (presentState == PrivateChatState.DISABLE) {
+                    handleToggle(sender, target, PrivateChatState.ENABLE);
+                }
+                else {
+                    handleToggle(sender, target, PrivateChatState.DISABLE);
+                }
+            });
+
+            return;
+        }
+
+        handleToggle(sender, target, state);
+    }
+
+    private void handleToggle(CommandSender sender, Player target, @NotNull PrivateChatState desiredState) {
+        UUID uniqueId = target.getUniqueId();
+
+        if (desiredState == PrivateChatState.DISABLE) {
+            this.disable(uniqueId);
+
+            if (!this.isCommandSenderSameAsTarget(sender, target)) {
+                this.noticeService.create()
+                    .notice(translation -> translation.privateChat().otherMessagesDisabled())
+                    .sender(sender)
+                    .placeholder("{PLAYER}", target.getName())
+                    .send();
+            }
+        }
+        else {
+            this.enable(uniqueId);
+
+            if (!this.isCommandSenderSameAsTarget(sender, target)) {
+                this.noticeService.create()
+                    .notice(translation -> translation.privateChat().otherMessagesEnabled())
+                    .sender(sender)
+                    .placeholder("{PLAYER}", target.getName())
+                    .send();
+            }
+        }
+    }
+
+    private void enable(UUID uniqueId) {
+        this.privateChatToggleService.togglePrivateChat(uniqueId, PrivateChatState.ENABLE);
+
+        this.noticeService.create()
+            .notice(translation -> translation.privateChat().selfMessagesEnabled())
+            .player(uniqueId)
+            .send();
+    }
+
+    private void disable(UUID uniqueId) {
+        this.privateChatToggleService.togglePrivateChat(uniqueId, PrivateChatState.DISABLE);
+
+        this.noticeService.create()
+            .notice(translation -> translation.privateChat().selfMessagesDisabled())
+            .player(uniqueId)
+            .send();
+    }
+
+    private boolean isCommandSenderSameAsTarget(CommandSender context, Player player) {
+        if (context instanceof Player commandSender) {
+            return commandSender.getUniqueId().equals(player.getUniqueId());
+        }
+        return false;
+    }
+}

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

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

eternalcore-core/src/main/java/com/eternalcode/core/feature/privatechat/toggle/PrivateChatToggleRepositoryOrmLite.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 PrivateChatToggleRepositoryOrmLite extends AbstractRepositoryOrmLite implements PrivateChatToggleRepository {
+
+    @Inject
+    private PrivateChatToggleRepositoryOrmLite(DatabaseManager databaseManager, Scheduler scheduler) throws SQLException {
+        super(databaseManager, scheduler);
+        TableUtils.createTableIfNotExists(databaseManager.connectionSource(), PrivateChatToggleWrapper.class);
+    }
+
+    @Override
+    public CompletableFuture<PrivateChatState> getPrivateChatToggleState(UUID uuid) {
+        return this.selectSafe(PrivateChatToggleWrapper.class, uuid)
+            .thenApply(
+                optional -> optional.map(PrivateChatToggleWrapper::isEnabled).orElse(PrivateChatState.ENABLE)
+            );
+    }
+
+    @Override
+    public CompletableFuture<Void> setPrivateChatToggle(UUID uuid, PrivateChatState toggledOff) {
+        return this.save(PrivateChatToggleWrapper.class, new PrivateChatToggleWrapper(uuid, toggledOff))
+            .thenApply(status -> null);
+    }
+}

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

@@ -0,0 +1,36 @@
+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;
+
+@Service
+public class PrivateChatToggleServiceImpl implements PrivateChatToggleService {
+
+    private final PrivateChatToggleRepository msgToggleRepository;
+    private final ConcurrentHashMap<UUID, PrivateChatState> cachedToggleStates;
+
+    @Inject
+    public PrivateChatToggleServiceImpl(PrivateChatToggleRepository msgToggleRepository) {
+        this.cachedToggleStates = new ConcurrentHashMap<>();
+        this.msgToggleRepository = msgToggleRepository;
+    }
+
+
+    @Override
+    public CompletableFuture<PrivateChatState> getPrivateChatToggleState(UUID uuid) {
+        if (this.cachedToggleStates.containsKey(uuid)) {
+            return CompletableFuture.completedFuture(this.cachedToggleStates.get(uuid));
+        }
+
+        return this.msgToggleRepository.getPrivateChatToggleState(uuid);
+    }
+
+    @Override
+    public void togglePrivateChat(UUID uuid, PrivateChatState toggle) {
+        this.cachedToggleStates.put(uuid, toggle);
+        this.msgToggleRepository.setPrivateChatToggle(uuid, toggle);
+    }
+}