Add custom event classes for lockers, parcels, users, and item storage

src/main/java/com/eternalcode/parcellockers/ParcelLockers.java

@@ -126,15 +126,16 @@ public void onEnable() {
             parcelContentRepository,
             scheduler,
             config,
-            this.economy
+            this.economy,
+            server
         );
 
         UserValidationService userValidationService = new UserValidator();
-        UserManager userManager = new UserManagerImpl(userRepository, userValidationService);
+        UserManager userManager = new UserManagerImpl(userRepository, userValidationService, server);
         LockerValidationService lockerValidationService = new LockerValidator();
-        LockerManager lockerManager = new LockerManager(config, lockerRepository, lockerValidationService, parcelRepository);
+        LockerManager lockerManager = new LockerManager(config, lockerRepository, lockerValidationService, parcelRepository, server);
         ParcelContentManager parcelContentManager = new ParcelContentManager(parcelContentRepository);
-        ItemStorageManager itemStorageManager = new ItemStorageManager(itemStorageRepository);
+        ItemStorageManager itemStorageManager = new ItemStorageManager(itemStorageRepository, server);
         DeliveryManager deliveryManager = new DeliveryManager(deliveryRepository);
 
         ParcelDispatchService parcelDispatchService = new ParcelDispatchService(

src/main/java/com/eternalcode/parcellockers/delivery/DeliveryManager.java

@@ -61,7 +61,7 @@ public CompletableFuture<Void> deleteAll(CommandSender sender, NoticeService not
             this.deliveryCache.invalidateAll();
             noticeService.create()
                 .viewer(sender)
-                .notice(messages -> messages.admin.deletedContents)
+                .notice(messages -> messages.admin.deletedDeliveries)
                 .placeholder("{COUNT}", deleted.toString())
                 .send();
         });

src/main/java/com/eternalcode/parcellockers/itemstorage/ItemStorageManager.java

@@ -1,5 +1,6 @@
 package com.eternalcode.parcellockers.itemstorage;
 
+import com.eternalcode.parcellockers.itemstorage.event.ItemStorageUpdateEvent;
 import com.eternalcode.parcellockers.itemstorage.repository.ItemStorageRepository;
 import com.eternalcode.parcellockers.notification.NoticeService;
 import com.github.benmanes.caffeine.cache.Cache;
@@ -9,6 +10,7 @@
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.TimeUnit;
+import org.bukkit.Server;
 import org.bukkit.command.CommandSender;
 import org.bukkit.inventory.ItemStack;
 
@@ -17,9 +19,11 @@ public class ItemStorageManager {
     private final Cache<UUID, ItemStorage> cache;
 
     private final ItemStorageRepository itemStorageRepository;
+    private final Server server;
 
-    public ItemStorageManager(ItemStorageRepository itemStorageRepository) {
+    public ItemStorageManager(ItemStorageRepository itemStorageRepository, Server server) {
         this.itemStorageRepository = itemStorageRepository;
+        this.server = server;
 
         this.cache = Caffeine.newBuilder()
             .expireAfterWrite(6, TimeUnit.HOURS)
@@ -45,13 +49,20 @@ public ItemStorage getOrCreate(UUID owner, List<ItemStack> items) {
     }
 
     public ItemStorage create(UUID owner, List<ItemStack> items) {
-        ItemStorage itemStorage = new ItemStorage(owner, items);
-        if (this.cache.getIfPresent(owner) != null) {
-            throw new IllegalStateException("ItemStorage for owner " + owner + " already exists. Use ItemStorageManager#getOrCreate method instead.");
+        ItemStorage oldItemStorage = this.cache.getIfPresent(owner);
+        ItemStorage newItemStorage = new ItemStorage(owner, items);
+
+        // This is an update operation - fire ItemStorageUpdateEvent
+        ItemStorageUpdateEvent event = new ItemStorageUpdateEvent(oldItemStorage, newItemStorage);
+        this.server.getPluginManager().callEvent(event);
+
+        if (event.isCancelled()) {
+            throw new IllegalStateException("ItemStorage update was cancelled by event");
         }
-        this.cache.put(owner, itemStorage);
-        this.itemStorageRepository.save(itemStorage);
-        return itemStorage;
+
+        this.cache.put(owner, newItemStorage);
+        this.itemStorageRepository.save(newItemStorage);
+        return newItemStorage;
     }
 
     private void cacheAll() {

src/main/java/com/eternalcode/parcellockers/itemstorage/event/ItemStorageUpdateEvent.java

@@ -0,0 +1,50 @@
+package com.eternalcode.parcellockers.itemstorage.event;
+
+import com.eternalcode.parcellockers.itemstorage.ItemStorage;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+public class ItemStorageUpdateEvent extends Event implements Cancellable {
+
+    private static final HandlerList HANDLER_LIST = new HandlerList();
+
+    private final ItemStorage oldItemStorage;
+    private final ItemStorage updatedItemStorage;
+
+    private boolean cancelled;
+
+    public ItemStorageUpdateEvent(ItemStorage oldItemStorage, ItemStorage updatedItemStorage) {
+        super(true);
+        this.oldItemStorage = oldItemStorage;
+        this.updatedItemStorage = updatedItemStorage;
+    }
+
+    public static HandlerList getHandlerList() {
+        return HANDLER_LIST;
+    }
+
+    public ItemStorage getOldItemStorage() {
+        return this.oldItemStorage;
+    }
+
+    public ItemStorage getUpdatedItemStorage() {
+        return this.updatedItemStorage;
+    }
+
+    @Override
+    public boolean isCancelled() {
+        return this.cancelled;
+    }
+
+    @Override
+    public void setCancelled(boolean cancel) {
+        this.cancelled = cancel;
+    }
+
+    @Override
+    public @NotNull HandlerList getHandlers() {
+        return HANDLER_LIST;
+    }
+}

src/main/java/com/eternalcode/parcellockers/locker/LockerManager.java

@@ -1,6 +1,8 @@
 package com.eternalcode.parcellockers.locker;
 
 import com.eternalcode.parcellockers.configuration.implementation.PluginConfig;
+import com.eternalcode.parcellockers.locker.event.LockerCreateEvent;
+import com.eternalcode.parcellockers.locker.event.LockerDeleteEvent;
 import com.eternalcode.parcellockers.locker.repository.LockerRepository;
 import com.eternalcode.parcellockers.locker.validation.LockerValidationService;
 import com.eternalcode.parcellockers.notification.NoticeService;
@@ -18,6 +20,7 @@
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
 import java.util.function.Function;
+import org.bukkit.Server;
 import org.bukkit.command.CommandSender;
 
 public class LockerManager {
@@ -26,6 +29,7 @@ public class LockerManager {
     private final LockerRepository lockerRepository;
     private final LockerValidationService validationService;
     private final ParcelRepository parcelRepository;
+    private final Server server;
 
     private final Cache<UUID, Locker> lockersByUUID;
     private final Cache<Position, Locker> lockersByPosition;
@@ -34,12 +38,14 @@ public LockerManager(
         PluginConfig config,
         LockerRepository lockerRepository,
         LockerValidationService validationService,
-        ParcelRepository parcelRepository
+        ParcelRepository parcelRepository,
+        Server server
     ) {
         this.config = config;
         this.lockerRepository = lockerRepository;
         this.validationService = validationService;
         this.parcelRepository = parcelRepository;
+        this.server = server;
 
         this.lockersByUUID = Caffeine.newBuilder()
             .expireAfterAccess(Duration.ofHours(2))
@@ -96,7 +102,7 @@ public CompletableFuture<PageResult<Locker>> get(Page page) {
         return this.lockerRepository.findPage(page);
     }
 
-    public CompletableFuture<Locker> create(UUID uniqueId, String name, Position position) {
+    public CompletableFuture<Locker> create(UUID uniqueId, String name, Position position, UUID playerUUID) {
         return CompletableFuture.supplyAsync(() -> {
 
             ValidationResult validation = this.validationService.validateCreateParameters(uniqueId, name, position);
@@ -115,19 +121,42 @@ public CompletableFuture<Locker> create(UUID uniqueId, String name, Position pos
             }
 
             Locker locker = new Locker(uniqueId, name, position);
+
+            // Fire LockerCreateEvent
+            LockerCreateEvent event = new LockerCreateEvent(locker, playerUUID);
+            this.server.getPluginManager().callEvent(event);
+
+            if (event.isCancelled()) {
+                throw new ValidationException("Locker creation cancelled by event");
+            }
+
             this.lockersByUUID.put(uniqueId, locker);
             this.lockersByPosition.put(position, locker);
 
             return this.lockerRepository.save(locker);
         }).thenCompose(Function.identity());
     }
 
-    public CompletableFuture<Void> delete(UUID uniqueId) {
-        return this.lockerRepository.delete(uniqueId).thenAccept(deleted -> {
-            if (deleted > 0) {
-                this.lockersByUUID.invalidate(uniqueId);
-                this.lockersByPosition.asMap().values().removeIf(locker -> locker.uuid().equals(uniqueId));
+    public CompletableFuture<Void> delete(UUID uniqueId, UUID playerUUID) {
+        Locker cachedLocker = this.lockersByUUID.getIfPresent(uniqueId);
+
+        CompletableFuture<Locker> lockerFuture = cachedLocker != null
+            ? CompletableFuture.completedFuture(cachedLocker)
+            : this.lockerRepository.find(uniqueId).thenApply(opt -> opt.orElse(null));
+
+        return lockerFuture.thenCompose(locker -> {
+            if (locker == null) {
+                return CompletableFuture.completedFuture(null);
+            }
+
+            LockerDeleteEvent event = new LockerDeleteEvent(locker, playerUUID);
+            this.server.getPluginManager().callEvent(event);
+
+            if (event.isCancelled()) {
+                return CompletableFuture.completedFuture(null);
             }
+
+            return this.deleteLocker(uniqueId);
         });
     }
 
@@ -148,4 +177,13 @@ public CompletableFuture<Boolean> isLockerFull(UUID uniqueId) {
         return this.parcelRepository.countDeliveredParcelsByDestinationLocker(uniqueId)
             .thenApply(count -> count > 0 && count >= this.config.settings.maxParcelsPerLocker);
     }
+
+    private CompletableFuture<Void> deleteLocker(UUID uniqueId) {
+        return this.lockerRepository.delete(uniqueId).thenAccept(deleted -> {
+            if (deleted > 0) {
+                this.lockersByUUID.invalidate(uniqueId);
+                this.lockersByPosition.asMap().values().removeIf(l -> l.uuid().equals(uniqueId));
+            }
+        });
+    }
 }

src/main/java/com/eternalcode/parcellockers/locker/controller/LockerBreakController.java

@@ -57,7 +57,7 @@ public void onBlockBreak(BlockBreakEvent event) {
                     return;
                 }
 
-                this.lockerManager.delete(locker.get().uuid());
+                this.lockerManager.delete(locker.get().uuid(), player.getUniqueId());
 
                 this.noticeService.player(player.getUniqueId(), messages -> messages.locker.deleted);
 

src/main/java/com/eternalcode/parcellockers/locker/controller/LockerPlaceController.java

@@ -128,7 +128,7 @@ public void onBlockPlace(BlockPlaceEvent event) {
                                 location.getWorld().getBlockAt(location).setBlockData(data);
                             });
 
-                            this.lockerManager.create(UUID.randomUUID(), description, PositionAdapter.convert(location))
+                            this.lockerManager.create(UUID.randomUUID(), description, PositionAdapter.convert(location), player.getUniqueId())
                                 .thenAccept(locker -> {
                                     this.noticeService.create()
                                         .player(player.getUniqueId())

src/main/java/com/eternalcode/parcellockers/locker/event/LockerCreateEvent.java

@@ -0,0 +1,51 @@
+package com.eternalcode.parcellockers.locker.event;
+
+import com.eternalcode.parcellockers.locker.Locker;
+import java.util.UUID;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+public class LockerCreateEvent extends Event implements Cancellable {
+
+    private static final HandlerList HANDLER_LIST = new HandlerList();
+
+    private final Locker locker;
+    private final UUID player;
+    private boolean cancelled;
+
+    public LockerCreateEvent(Locker locker, UUID player) {
+        super(true);
+        this.locker = locker;
+        this.player = player;
+    }
+
+    public static HandlerList getHandlerList() {
+        return HANDLER_LIST;
+    }
+
+    public Locker getLocker() {
+        return this.locker;
+    }
+
+    public UUID getPlayer() {
+        return this.player;
+    }
+
+    @Override
+    public boolean isCancelled() {
+        return this.cancelled;
+    }
+
+    @Override
+    public void setCancelled(boolean cancel) {
+        this.cancelled = cancel;
+    }
+
+    @Override
+    public @NotNull HandlerList getHandlers() {
+        return HANDLER_LIST;
+    }
+
+}

src/main/java/com/eternalcode/parcellockers/locker/event/LockerDeleteEvent.java

@@ -0,0 +1,51 @@
+package com.eternalcode.parcellockers.locker.event;
+
+import com.eternalcode.parcellockers.locker.Locker;
+import java.util.UUID;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+public class LockerDeleteEvent extends Event implements Cancellable {
+
+    private static final HandlerList HANDLER_LIST = new HandlerList();
+
+    private final Locker locker;
+    private final UUID player;
+    private boolean cancelled;
+
+    public LockerDeleteEvent(Locker locker, UUID player) {
+        super(true);
+        this.locker = locker;
+        this.player = player;
+    }
+
+    public static HandlerList getHandlerList() {
+        return HANDLER_LIST;
+    }
+
+    public Locker getLocker() {
+        return this.locker;
+    }
+
+    public UUID getPlayer() {
+        return this.player;
+    }
+
+    @Override
+    public boolean isCancelled() {
+        return this.cancelled;
+    }
+
+    @Override
+    public void setCancelled(boolean cancel) {
+        this.cancelled = cancel;
+    }
+
+    @Override
+    public @NotNull HandlerList getHandlers() {
+        return HANDLER_LIST;
+    }
+
+}