diff --git a/eternalcore-api-example/src/main/java/com/eternalcode/example/EternalCoreApiExamplePlugin.java b/eternalcore-api-example/src/main/java/com/eternalcode/example/EternalCoreApiExamplePlugin.java index 5e8d080b2..f42690bab 100644 --- a/eternalcore-api-example/src/main/java/com/eternalcode/example/EternalCoreApiExamplePlugin.java +++ b/eternalcore-api-example/src/main/java/com/eternalcode/example/EternalCoreApiExamplePlugin.java @@ -7,6 +7,8 @@ import com.eternalcode.example.feature.catboy.CatBoyListener; import com.eternalcode.example.feature.home.ApiHomeCommand; import com.eternalcode.example.feature.home.ApiHomeListener; +import com.eternalcode.example.feature.ignore.ApiIgnoreCommand; +import com.eternalcode.example.feature.ignore.ApiIgnoreListener; import com.eternalcode.example.feature.jail.ApiJailCommand; import com.eternalcode.example.feature.jail.ApiJailListener; import com.eternalcode.example.feature.privatechat.ApiPrivateChatListener; @@ -41,11 +43,12 @@ public void onEnable() { .message(LiteMessages.MISSING_PERMISSIONS, input -> "You don't have permission to execute this command!") .commands( - new ApiSpawnCommand(provide.getSpawnService()), new ApiAfkCommand(provide.getAfkService()), - new ApiRandomTeleportCommand(provide.getRandomTeleportService()), + new ApiIgnoreCommand(provide.getIgnoreService()), new ApiJailCommand(provide.getJailService()), new ApiRandomTeleportCommand(provide.getRandomTeleportService()), + new ApiSpawnCommand(provide.getSpawnService()), + new ApiRandomTeleportCommand(provide.getRandomTeleportService()), new ApiHomeCommand(provide.getHomeService()) ) @@ -57,8 +60,9 @@ public void onEnable() { new ApiRandomTeleportListener(provide.getRandomTeleportService()), new ApiPrivateChatListener(server), new ApiRandomTeleportListener(provide.getRandomTeleportService()), + new ApiHomeListener(server), new ApiJailListener(server), - new ApiHomeListener(server) + new ApiIgnoreListener() ).forEach(listener -> server.getPluginManager().registerEvents(listener, this)); } diff --git a/eternalcore-api-example/src/main/java/com/eternalcode/example/feature/ignore/ApiIgnoreCommand.java b/eternalcore-api-example/src/main/java/com/eternalcode/example/feature/ignore/ApiIgnoreCommand.java new file mode 100644 index 000000000..f56a5a001 --- /dev/null +++ b/eternalcore-api-example/src/main/java/com/eternalcode/example/feature/ignore/ApiIgnoreCommand.java @@ -0,0 +1,44 @@ +package com.eternalcode.example.feature.ignore; + +import com.eternalcode.core.feature.ignore.IgnoreService; +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 org.bukkit.entity.Player; + +@Command(name = "api ignore") +public class ApiIgnoreCommand { + + private final IgnoreService ignoreService; + + public ApiIgnoreCommand(IgnoreService ignoreService) { + this.ignoreService = ignoreService; + } + + @Execute(name = "ignore") + void executeIgnore(@Context Player player, @Arg Player target) { + this.ignoreService.ignore(player.getUniqueId(), target.getUniqueId()); + String message = "You have ignored %s via eternalcore api bridge!"; + player.sendMessage(String.format(message, target.getName())); + } + + @Execute(name = "unignore") + void executeUnignore(@Context Player player, @Arg Player target) { + this.ignoreService.unIgnore(player.getUniqueId(), target.getUniqueId()); + String message = "You have unignored %s via eternalcore api bridge!"; + player.sendMessage(String.format(message, target.getName())); + } + + @Execute(name = "ignoreall") + void executeIgnoreAll(@Context Player player) { + this.ignoreService.ignoreAll(player.getUniqueId()); + player.sendMessage("You have ignored all players via eternalcore api bridge!"); + } + + @Execute(name = "unignoreall") + void executeUnignoreAll(@Context Player player) { + this.ignoreService.unIgnoreAll(player.getUniqueId()); + player.sendMessage("You have unignored all players via eternalcore api bridge!"); + } +} diff --git a/eternalcore-api-example/src/main/java/com/eternalcode/example/feature/ignore/ApiIgnoreListener.java b/eternalcore-api-example/src/main/java/com/eternalcode/example/feature/ignore/ApiIgnoreListener.java new file mode 100644 index 000000000..082a65ad4 --- /dev/null +++ b/eternalcore-api-example/src/main/java/com/eternalcode/example/feature/ignore/ApiIgnoreListener.java @@ -0,0 +1,84 @@ +package com.eternalcode.example.feature.ignore; + +import com.eternalcode.core.feature.ignore.event.IgnoreAllEvent; +import com.eternalcode.core.feature.ignore.event.IgnoreEvent; +import com.eternalcode.core.feature.ignore.event.UnIgnoreAllEvent; +import com.eternalcode.core.feature.ignore.event.UnIgnoreEvent; +import java.util.UUID; +import org.bukkit.Bukkit; +import org.bukkit.Sound; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; + +public class ApiIgnoreListener implements Listener { + + /** + * This method is called when a player is ignored. + **/ + @EventHandler + public void onIgnore(IgnoreEvent event) { + UUID requesterId = event.getRequester(); + UUID targetId = event.getTarget(); + Player requester = Bukkit.getPlayer(requesterId); + Player target = Bukkit.getPlayer(targetId); + + if (requester == null || target == null) { + return; + } + + requester.playSound(requester.getLocation(), Sound.BLOCK_PORTAL_TRAVEL, 1.0F, 1.0F); + target.getWorld().createExplosion(target.getLocation(), 2.0F); + } + + /** + * This method is called when a player ignores all players + **/ + @EventHandler + public void onIgnoreAll(IgnoreAllEvent event) { + UUID requesterId = event.getRequester(); + Player requester = Bukkit.getPlayer(requesterId); + + if (requester == null) { + return; + } + + requester.playSound(requester.getLocation(), Sound.ENTITY_VILLAGER_NO, 1.0F, 1.0F); + requester.getWorld().strikeLightning(requester.getLocation()); + } + + /** + * This method is called when a player is unignored. + **/ + @EventHandler + public void onUnIgnore(UnIgnoreEvent event) { + UUID requesterId = event.getRequester(); + UUID targetId = event.getTarget(); + Player requester = Bukkit.getPlayer(requesterId); + Player target = Bukkit.getPlayer(targetId); + + if (requester == null || target == null) { + return; + } + + requester.playSound(requester.getLocation(), Sound.ENTITY_VILLAGER_YES, 1.0F, 1.0F); + target.getWorld().strikeLightning(target.getLocation()); + } + + /** + * This method is called when a player unignores all players + **/ + @EventHandler + public void onUnIgnoreAll(UnIgnoreAllEvent event) { + UUID requesterId = event.getRequester(); + Player requester = Bukkit.getPlayer(requesterId); + + if (requester == null) { + return; + } + + requester.playSound(requester.getLocation(), Sound.BLOCK_PORTAL_TRIGGER, 1.0F, 1.0F); + requester.getWorld().createExplosion(requester.getLocation(), 2.0F); + } + +} diff --git a/eternalcore-api/src/main/java/com/eternalcode/core/EternalCoreApi.java b/eternalcore-api/src/main/java/com/eternalcode/core/EternalCoreApi.java index f94a5e985..08eaa6e17 100644 --- a/eternalcore-api/src/main/java/com/eternalcode/core/EternalCoreApi.java +++ b/eternalcore-api/src/main/java/com/eternalcode/core/EternalCoreApi.java @@ -6,6 +6,7 @@ import com.eternalcode.core.feature.jail.JailService; import com.eternalcode.core.feature.language.LanguageService; import com.eternalcode.core.feature.privatechat.PrivateChatService; +import com.eternalcode.core.feature.ignore.IgnoreService; import com.eternalcode.core.feature.randomteleport.RandomTeleportService; import com.eternalcode.core.feature.spawn.SpawnService; import com.eternalcode.core.feature.teleport.TeleportService; @@ -15,21 +16,23 @@ public interface EternalCoreApi { AfkService getAfkService(); - SpawnService getSpawnService(); - CatboyService getCatboyService(); - TeleportService getTeleportService(); + IgnoreService getIgnoreService(); - RandomTeleportService getRandomTeleportService(); + HomeService getHomeService(); + + JailService getJailService(); + + LanguageService getLanguageService(); PrivateChatService getPrivateChatService(); - WarpService getWarpService(); + RandomTeleportService getRandomTeleportService(); - HomeService getHomeService(); + SpawnService getSpawnService(); - JailService getJailService(); + TeleportService getTeleportService(); - LanguageService getLanguageService(); + WarpService getWarpService(); } diff --git a/eternalcore-api/src/main/java/com/eternalcode/core/feature/ignore/IgnoreService.java b/eternalcore-api/src/main/java/com/eternalcode/core/feature/ignore/IgnoreService.java new file mode 100644 index 000000000..ac642d35c --- /dev/null +++ b/eternalcore-api/src/main/java/com/eternalcode/core/feature/ignore/IgnoreService.java @@ -0,0 +1,18 @@ +package com.eternalcode.core.feature.ignore; + +import java.util.UUID; +import java.util.concurrent.CompletableFuture; + +public interface IgnoreService { + + CompletableFuture isIgnored(UUID requester, UUID target); + + CompletableFuture ignore(UUID requester, UUID target); + + CompletableFuture ignoreAll(UUID requester); + + CompletableFuture unIgnore(UUID requester, UUID target); + + CompletableFuture unIgnoreAll(UUID requester); + +} diff --git a/eternalcore-api/src/main/java/com/eternalcode/core/feature/ignore/event/IgnoreAllEvent.java b/eternalcore-api/src/main/java/com/eternalcode/core/feature/ignore/event/IgnoreAllEvent.java new file mode 100644 index 000000000..886d36a09 --- /dev/null +++ b/eternalcore-api/src/main/java/com/eternalcode/core/feature/ignore/event/IgnoreAllEvent.java @@ -0,0 +1,50 @@ +package com.eternalcode.core.feature.ignore.event; + +import java.util.UUID; +import org.bukkit.event.Cancellable; +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; +import org.jetbrains.annotations.NotNull; + +/** + * This event is called when a player wants to ignore all players. + */ +public class IgnoreAllEvent extends Event implements Cancellable { + + private static final HandlerList HANDLER_LIST = new HandlerList(); + + private final UUID requester; + private boolean cancelled; + + public IgnoreAllEvent(UUID requester) { + super(false); + this.requester = requester; + } + + /** + * @return the player executing the ignore all action. + */ + public UUID getRequester() { + return this.requester; + } + + @Override + public boolean isCancelled() { + return this.cancelled; + } + + @Override + public void setCancelled(boolean cancel) { + this.cancelled = cancel; + } + + @NotNull + @Override + public HandlerList getHandlers() { + return HANDLER_LIST; + } + + public static HandlerList getHandlerList() { + return HANDLER_LIST; + } +} diff --git a/eternalcore-api/src/main/java/com/eternalcode/core/feature/ignore/event/IgnoreEvent.java b/eternalcore-api/src/main/java/com/eternalcode/core/feature/ignore/event/IgnoreEvent.java new file mode 100644 index 000000000..30e90b6b8 --- /dev/null +++ b/eternalcore-api/src/main/java/com/eternalcode/core/feature/ignore/event/IgnoreEvent.java @@ -0,0 +1,59 @@ +package com.eternalcode.core.feature.ignore.event; + +import java.util.UUID; +import org.bukkit.event.Cancellable; +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; +import org.jetbrains.annotations.NotNull; + +/** + * This event is called when a player wants to ignore another player. + */ +public class IgnoreEvent extends Event implements Cancellable { + + private static final HandlerList HANDLER_LIST = new HandlerList(); + + private final UUID requester; + private final UUID target; + private boolean cancelled; + + public IgnoreEvent(UUID requester, UUID target) { + super(false); + this.requester = requester; + this.target = target; + } + + /** + * @return the player who requested the ignore action. + */ + public UUID getRequester() { + return this.requester; + } + + /** + * @return the player who is being ignored. + */ + public UUID getTarget() { + return this.target; + } + + @Override + public boolean isCancelled() { + return this.cancelled; + } + + @Override + public void setCancelled(boolean cancel) { + this.cancelled = cancel; + } + + @Override + public @NotNull HandlerList getHandlers() { + return HANDLER_LIST; + } + + public static HandlerList getHandlerList() { + return HANDLER_LIST; + } + +} diff --git a/eternalcore-api/src/main/java/com/eternalcode/core/feature/ignore/event/UnIgnoreAllEvent.java b/eternalcore-api/src/main/java/com/eternalcode/core/feature/ignore/event/UnIgnoreAllEvent.java new file mode 100644 index 000000000..760d78ee0 --- /dev/null +++ b/eternalcore-api/src/main/java/com/eternalcode/core/feature/ignore/event/UnIgnoreAllEvent.java @@ -0,0 +1,50 @@ +package com.eternalcode.core.feature.ignore.event; + +import java.util.UUID; +import org.bukkit.event.Cancellable; +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; +import org.jetbrains.annotations.NotNull; + +/** + * This event is called when a player ignores all other players. + */ +public class UnIgnoreAllEvent extends Event implements Cancellable { + + private static final HandlerList HANDLER_LIST = new HandlerList(); + + private final UUID requester; + private boolean cancelled; + + public UnIgnoreAllEvent(UUID requester) { + super(false); + this.requester = requester; + } + + /** + * @return the player executing the unignore all action. + */ + public UUID getRequester() { + return this.requester; + } + + @Override + public boolean isCancelled() { + return this.cancelled; + } + + @Override + public void setCancelled(boolean cancel) { + this.cancelled = cancel; + } + + @NotNull + @Override + public HandlerList getHandlers() { + return HANDLER_LIST; + } + + public static HandlerList getHandlerList() { + return HANDLER_LIST; + } +} diff --git a/eternalcore-api/src/main/java/com/eternalcode/core/feature/ignore/event/UnIgnoreEvent.java b/eternalcore-api/src/main/java/com/eternalcode/core/feature/ignore/event/UnIgnoreEvent.java new file mode 100644 index 000000000..5567c55b7 --- /dev/null +++ b/eternalcore-api/src/main/java/com/eternalcode/core/feature/ignore/event/UnIgnoreEvent.java @@ -0,0 +1,59 @@ +package com.eternalcode.core.feature.ignore.event; + +import java.util.UUID; +import org.bukkit.event.Cancellable; +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; +import org.jetbrains.annotations.NotNull; + +/** + * This event is called when a player unignores another player. + */ +public class UnIgnoreEvent extends Event implements Cancellable { + + private static final HandlerList HANDLER_LIST = new HandlerList(); + + private final UUID requester; + private final UUID target; + private boolean cancelled; + + public UnIgnoreEvent(UUID requester, UUID target) { + super(false); + this.requester = requester; + this.target = target; + } + + /** + * @return the player executing the unignore action. + */ + public UUID getRequester() { + return this.requester; + } + + /** + * @return the player being targeted by the unignore action. + */ + public UUID getTarget() { + return this.target; + } + + @Override + public boolean isCancelled() { + return this.cancelled; + } + + @Override + public void setCancelled(boolean cancel) { + this.cancelled = cancel; + } + + @NotNull + @Override + public HandlerList getHandlers() { + return HANDLER_LIST; + } + + public static HandlerList getHandlerList() { + return HANDLER_LIST; + } +} diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/EternalCoreApiImpl.java b/eternalcore-core/src/main/java/com/eternalcode/core/EternalCoreApiImpl.java index 8fbdd491f..28998f2c1 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/EternalCoreApiImpl.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/EternalCoreApiImpl.java @@ -3,6 +3,7 @@ import com.eternalcode.core.feature.afk.AfkService; import com.eternalcode.core.feature.catboy.CatboyService; import com.eternalcode.core.feature.home.HomeService; +import com.eternalcode.core.feature.ignore.IgnoreService; import com.eternalcode.core.feature.jail.JailService; import com.eternalcode.core.feature.language.LanguageService; import com.eternalcode.core.feature.privatechat.PrivateChatService; @@ -26,23 +27,28 @@ public AfkService getAfkService() { } @Override - public SpawnService getSpawnService() { - return this.dependencyProvider.getDependency(SpawnService.class); + public CatboyService getCatboyService() { + return this.dependencyProvider.getDependency(CatboyService.class); } @Override - public CatboyService getCatboyService() { - return this.dependencyProvider.getDependency(CatboyService.class); + public IgnoreService getIgnoreService() { + return this.dependencyProvider.getDependency(IgnoreService.class); } @Override - public TeleportService getTeleportService() { - return this.dependencyProvider.getDependency(TeleportService.class); + public HomeService getHomeService() { + return this.dependencyProvider.getDependency(HomeService.class); } @Override - public RandomTeleportService getRandomTeleportService() { - return this.dependencyProvider.getDependency(RandomTeleportService.class); + public JailService getJailService() { + return this.dependencyProvider.getDependency(JailService.class); + } + + @Override + public LanguageService getLanguageService() { + return this.dependencyProvider.getDependency(LanguageService.class); } @Override @@ -51,22 +57,22 @@ public PrivateChatService getPrivateChatService() { } @Override - public WarpService getWarpService() { - return this.dependencyProvider.getDependency(WarpService.class); + public RandomTeleportService getRandomTeleportService() { + return this.dependencyProvider.getDependency(RandomTeleportService.class); } @Override - public JailService getJailService() { - return this.dependencyProvider.getDependency(JailService.class); + public SpawnService getSpawnService() { + return this.dependencyProvider.getDependency(SpawnService.class); } @Override - public HomeService getHomeService() { - return this.dependencyProvider.getDependency(HomeService.class); + public TeleportService getTeleportService() { + return this.dependencyProvider.getDependency(TeleportService.class); } @Override - public LanguageService getLanguageService() { - return this.dependencyProvider.getDependency(LanguageService.class); + public WarpService getWarpService() { + return this.dependencyProvider.getDependency(WarpService.class); } } diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/database/wrapper/AbstractRepositoryOrmLite.java b/eternalcore-core/src/main/java/com/eternalcode/core/database/wrapper/AbstractRepositoryOrmLite.java index c95848e79..420fb3234 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/database/wrapper/AbstractRepositoryOrmLite.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/database/wrapper/AbstractRepositoryOrmLite.java @@ -40,6 +40,10 @@ protected CompletableFuture delete(Class type, T warp) { return this.action(type, dao -> dao.delete(warp)); } + protected CompletableFuture deleteAll(Class type) { + return this.action(type, dao -> dao.deleteBuilder().delete()); + } + protected CompletableFuture deleteById(Class type, ID id) { return this.action(type, dao -> dao.deleteById(id)); } diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/ignore/IgnoreCommand.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/ignore/IgnoreCommand.java index f99f0c535..f7f7b0a3c 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/ignore/IgnoreCommand.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/ignore/IgnoreCommand.java @@ -5,23 +5,24 @@ import com.eternalcode.core.notice.NoticeService; import com.eternalcode.core.user.User; 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 dev.rollczi.litecommands.annotations.command.Command; import java.util.UUID; + @Command(name = "ignore") @Permission("eternalcore.ignore") class IgnoreCommand { - private final IgnoreRepository repository; + private final IgnoreService ignoreService; private final NoticeService noticeService; @Inject - IgnoreCommand(IgnoreRepository repository, NoticeService noticeService) { - this.repository = repository; + IgnoreCommand(IgnoreService ignoreService, NoticeService noticeService) { + this.ignoreService = ignoreService; this.noticeService = noticeService; } @@ -36,7 +37,7 @@ void ignore(@Context User sender, @Arg User target) { return; } - this.repository.isIgnored(senderUuid, targetUuid).thenAccept(isIgnored -> { + this.ignoreService.isIgnored(senderUuid, targetUuid).thenAccept(isIgnored -> { if (isIgnored) { this.noticeService.create() .user(sender) @@ -47,11 +48,17 @@ void ignore(@Context User sender, @Arg User target) { return; } - this.repository.ignore(senderUuid, targetUuid).thenAccept(unused -> this.noticeService.create() - .player(senderUuid) - .placeholder("{PLAYER}", target.getName()) - .notice(translation -> translation.privateChat().ignorePlayer()) - .send()); + this.ignoreService.ignore(senderUuid, targetUuid).thenAccept(cancelled -> { + if (cancelled) { + return; + } + + this.noticeService.create() + .player(senderUuid) + .placeholder("{PLAYER}", target.getName()) + .notice(translation -> translation.privateChat().ignorePlayer()) + .send(); + }); }); } @@ -60,10 +67,16 @@ void ignore(@Context User sender, @Arg User target) { void ignoreAll(@Context User sender) { UUID senderUuid = sender.getUniqueId(); - this.repository.ignoreAll(senderUuid).thenAccept(blank -> this.noticeService.create() - .player(senderUuid) - .notice(translation -> translation.privateChat().ignoreAll()) - .send()); + this.ignoreService.ignoreAll(senderUuid).thenAccept(cancelled -> { + if (cancelled) { + return; + } + + this.noticeService.create() + .player(senderUuid) + .notice(translation -> translation.privateChat().ignoreAll()) + .send(); + }); } } diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/ignore/IgnoreRepository.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/ignore/IgnoreRepository.java index b68e771f9..d1ddcd469 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/ignore/IgnoreRepository.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/ignore/IgnoreRepository.java @@ -1,9 +1,7 @@ package com.eternalcode.core.feature.ignore; -import java.lang.Void; -import java.util.concurrent.CompletableFuture; - import java.util.UUID; +import java.util.concurrent.CompletableFuture; interface IgnoreRepository { @@ -17,4 +15,6 @@ interface IgnoreRepository { CompletableFuture unIgnoreAll(UUID by); + CompletableFuture purgeAll(); + } diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/ignore/IgnoreRepositoryOrmLite.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/ignore/IgnoreRepositoryOrmLite.java index 8839a6c73..7531dc581 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/ignore/IgnoreRepositoryOrmLite.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/ignore/IgnoreRepositoryOrmLite.java @@ -13,6 +13,9 @@ import com.j256.ormlite.stmt.DeleteBuilder; import com.j256.ormlite.table.DatabaseTable; import com.j256.ormlite.table.TableUtils; +import org.jetbrains.annotations.ApiStatus; +import org.jetbrains.annotations.NotNull; + import java.sql.SQLException; import java.time.Duration; import java.util.Set; @@ -20,7 +23,6 @@ import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutionException; import java.util.stream.Collectors; -import org.jetbrains.annotations.NotNull; @Repository class IgnoreRepositoryOrmLite extends AbstractRepositoryOrmLite implements IgnoreRepository { @@ -34,6 +36,7 @@ class IgnoreRepositoryOrmLite extends AbstractRepositoryOrmLite implements Ignor private IgnoreRepositoryOrmLite(DatabaseManager databaseManager, Scheduler scheduler) throws SQLException { super(databaseManager, scheduler); this.cachedDao = databaseManager.getDao(IgnoreWrapper.class); + this.ignores = CacheBuilder.newBuilder() .expireAfterAccess(Duration.ofMinutes(15)) .refreshAfterWrite(Duration.ofMinutes(3)) @@ -105,6 +108,13 @@ public CompletableFuture unIgnoreAll(UUID by) { .thenRun(() -> this.ignores.refresh(by)); } + @ApiStatus.Internal + @Override + public CompletableFuture purgeAll() { + return this.deleteAll(IgnoreWrapper.class) + .thenRun(this.ignores::invalidateAll); + } + @DatabaseTable(tableName = "eternal_core_ignores") private static class IgnoreWrapper { @@ -126,6 +136,7 @@ private static class IgnoreWrapper { } private class IgnoreLoader extends CacheLoader> { + @Override public @NotNull Set load(@NotNull UUID key) throws SQLException { return IgnoreRepositoryOrmLite.this.cachedDao.queryBuilder() diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/ignore/IgnoreService.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/ignore/IgnoreService.java deleted file mode 100644 index 824c95978..000000000 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/ignore/IgnoreService.java +++ /dev/null @@ -1,23 +0,0 @@ -package com.eternalcode.core.feature.ignore; - -import com.eternalcode.core.injector.annotations.Inject; -import com.eternalcode.core.injector.annotations.component.Service; -import java.util.concurrent.CompletableFuture; - -import java.util.UUID; - -@Service -public class IgnoreService { - - private final IgnoreRepository repository; - - @Inject - IgnoreService(IgnoreRepository repository) { - this.repository = repository; - } - - public CompletableFuture isIgnored(UUID by, UUID target) { - return this.repository.isIgnored(by, target); - } - -} diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/ignore/IgnoreServiceImpl.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/ignore/IgnoreServiceImpl.java new file mode 100644 index 000000000..501d36a68 --- /dev/null +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/ignore/IgnoreServiceImpl.java @@ -0,0 +1,73 @@ +package com.eternalcode.core.feature.ignore; + +import com.eternalcode.core.event.EventCaller; +import com.eternalcode.core.feature.ignore.event.IgnoreAllEvent; +import com.eternalcode.core.feature.ignore.event.IgnoreEvent; +import com.eternalcode.core.feature.ignore.event.UnIgnoreAllEvent; +import com.eternalcode.core.feature.ignore.event.UnIgnoreEvent; +import com.eternalcode.core.injector.annotations.Inject; +import com.eternalcode.core.injector.annotations.component.Service; + +import java.util.UUID; +import java.util.concurrent.CompletableFuture; + +@Service +class IgnoreServiceImpl implements IgnoreService { + + private final IgnoreRepository ignoreRepository; + private final EventCaller caller; + + @Inject + IgnoreServiceImpl(IgnoreRepository ignoreRepository, EventCaller caller) { + this.ignoreRepository = ignoreRepository; + this.caller = caller; + } + + @Override + public CompletableFuture isIgnored(UUID requester, UUID target) { + return this.ignoreRepository.isIgnored(requester, target); + } + + @Override + public CompletableFuture ignore(UUID requester, UUID target) { + IgnoreEvent event = this.caller.callEvent(new IgnoreEvent(requester, target)); + + if (event.isCancelled()) { + return CompletableFuture.completedFuture(false); + } + + return this.ignoreRepository.ignore(requester, target).thenApply(unused -> true); + } + + @Override + public CompletableFuture ignoreAll(UUID requester) { + IgnoreAllEvent event = this.caller.callEvent(new IgnoreAllEvent(requester)); + + if (event.isCancelled()) { + return CompletableFuture.completedFuture(false); + } + + return this.ignoreRepository.ignoreAll(requester).thenApply(unused -> true); + } + + @Override + public CompletableFuture unIgnore(UUID requester, UUID target) { + UnIgnoreEvent event = this.caller.callEvent(new UnIgnoreEvent(requester, target)); + + if (event.isCancelled()) { + return CompletableFuture.completedFuture(false); + } + return this.ignoreRepository.unIgnore(requester, target).thenApply(unused -> true); + } + + @Override + public CompletableFuture unIgnoreAll(UUID requester) { + UnIgnoreAllEvent event = this.caller.callEvent(new UnIgnoreAllEvent(requester)); + + if (event.isCancelled()) { + return CompletableFuture.completedFuture(false); + } + return this.ignoreRepository.unIgnoreAll(requester).thenApply(unused -> true); + } + +} diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/ignore/UnIgnoreCommand.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/ignore/UnIgnoreCommand.java index d664c89f5..1e704d940 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/ignore/UnIgnoreCommand.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/ignore/UnIgnoreCommand.java @@ -5,23 +5,24 @@ import com.eternalcode.core.notice.NoticeService; import com.eternalcode.core.user.User; 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 dev.rollczi.litecommands.annotations.command.Command; import java.util.UUID; + @Command(name = "unignore") @Permission("eternalcore.ignore") class UnIgnoreCommand { - private final IgnoreRepository repository; + private final IgnoreService ignoreService; private final NoticeService noticeService; @Inject - public UnIgnoreCommand(IgnoreRepository ignoreRepository, NoticeService noticeService) { - this.repository = ignoreRepository; + public UnIgnoreCommand(IgnoreService ignoreService, NoticeService noticeService) { + this.ignoreService = ignoreService; this.noticeService = noticeService; } @@ -36,7 +37,7 @@ void ignore(@Context User sender, @Arg User target) { return; } - this.repository.isIgnored(senderUuid, targetUuid).thenAccept(isIgnored -> { + this.ignoreService.isIgnored(senderUuid, targetUuid).thenAccept(isIgnored -> { if (!isIgnored) { this.noticeService.create() .user(sender) @@ -47,11 +48,17 @@ void ignore(@Context User sender, @Arg User target) { return; } - this.repository.unIgnore(senderUuid, targetUuid).thenAccept(blank -> this.noticeService.create() - .player(senderUuid) - .placeholder("{PLAYER}", target.getName()) - .notice(translation -> translation.privateChat().unIgnorePlayer()) - .send()); + this.ignoreService.unIgnore(senderUuid, targetUuid).thenAccept(cancelled -> { + if (cancelled) { + return; + } + + this.noticeService.create() + .player(senderUuid) + .placeholder("{PLAYER}", target.getName()) + .notice(translation -> translation.privateChat().unIgnorePlayer()) + .send(); + }); }); } @@ -60,10 +67,16 @@ void ignore(@Context User sender, @Arg User target) { void unIgnoreAll(@Context User sender) { UUID senderUuid = sender.getUniqueId(); - this.repository.unIgnoreAll(senderUuid).thenAccept(blank -> this.noticeService.create() - .player(senderUuid) - .notice(translation -> translation.privateChat().unIgnoreAll()) - .send()); + this.ignoreService.unIgnoreAll(senderUuid).thenAccept(cancelled -> { + if (cancelled) { + return; + } + + this.noticeService.create() + .player(senderUuid) + .notice(translation -> translation.privateChat().unIgnoreAll()) + .send(); + }); } }