Handling cancelled orders

pom.xml

@@ -131,7 +131,7 @@
         <dependency>
             <groupId>com.github.Podzilla</groupId>
             <artifactId>podzilla-utils-lib</artifactId>
-            <version>v1.1.11</version>
+            <version>v1.1.12</version>
         </dependency>
     </dependencies>
 

src/main/java/com/podzilla/warehouse/Controllers/ManagerController.java

@@ -13,7 +13,7 @@
 
 @Slf4j
 @RestController
-@RequestMapping("warehouse/manager")
+@RequestMapping("/manager")
 public class ManagerController {
     @Autowired
     private ManagerService managerService;

src/main/java/com/podzilla/warehouse/Controllers/PackagedOrdersController.java

@@ -14,7 +14,7 @@
 import java.util.UUID;
 
 @RestController
-@RequestMapping("warehouse/package")
+@RequestMapping("/package")
 @Validated
 public class PackagedOrdersController {
 

src/main/java/com/podzilla/warehouse/Controllers/PackagerController.java

@@ -15,7 +15,7 @@
 
 @Slf4j
 @RestController
-@RequestMapping("warehouse/packagers")
+@RequestMapping("/packagers")
 public class PackagerController {
 
     private final PackagerService packagerService;

src/main/java/com/podzilla/warehouse/Events/EventHandlerFactory.java

@@ -1,6 +1,7 @@
 package com.podzilla.warehouse.Events;
 
 import com.podzilla.mq.events.BaseEvent;
+import com.podzilla.mq.events.OrderCancelledEvent;
 import com.podzilla.mq.events.OrderPlacedEvent;
 import com.podzilla.mq.events.OrderStockReservationRequestedEvent;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -13,10 +14,13 @@ public class EventHandlerFactory {
     private final HashMap<Class<? extends BaseEvent>, EventHandler<? extends BaseEvent>> handlers;
 
     @Autowired
-    public EventHandlerFactory(OrderPlacedEventHandler OrderPlacedEventHandler,OrderStockReservationEventHandler orderStockReservationEventHandler) {
+    public EventHandlerFactory(OrderPlacedEventHandler OrderPlacedEventHandler,
+                               OrderStockReservationEventHandler orderStockReservationEventHandler,
+                               OrderCancelledEventHandler orderCancelledEventHandler) {
         handlers = new HashMap<>();
         handlers.put(OrderPlacedEvent.class, OrderPlacedEventHandler);
         handlers.put(OrderStockReservationRequestedEvent.class, orderStockReservationEventHandler);
+        handlers.put(OrderCancelledEvent.class, orderCancelledEventHandler);
     }
 
     @SuppressWarnings("unchecked")

src/main/java/com/podzilla/warehouse/Events/OrderCancelledEventHandler.java

@@ -0,0 +1,100 @@
+package com.podzilla.warehouse.Events;
+
+import com.podzilla.mq.EventPublisher;
+import com.podzilla.mq.EventsConstants;
+import com.podzilla.mq.events.InventoryUpdatedEvent;
+import com.podzilla.mq.events.OrderCancelledEvent;
+import com.podzilla.mq.events.OrderItem;
+import com.podzilla.mq.events.ProductSnapshot;
+import com.podzilla.warehouse.Models.Stock;
+import com.podzilla.warehouse.Repositories.AssignedOrdersRepository;
+import com.podzilla.warehouse.Repositories.PackagedOrdersRepository;
+import com.podzilla.warehouse.Repositories.StockRepository;
+import com.podzilla.warehouse.Services.StockService;
+import lombok.RequiredArgsConstructor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.ArrayList;
+import java.util.UUID;
+
+@RequiredArgsConstructor
+@Component
+public class OrderCancelledEventHandler implements EventHandler<OrderCancelledEvent> {
+
+    private static final Logger logger = LoggerFactory.getLogger(OrderCancelledEventHandler.class);
+    private final StockService stockService;
+    private final StockRepository stockRepository;
+    private final PackagedOrdersRepository packagedOrdersRepository;
+    private final AssignedOrdersRepository assignedOrdersRepository;
+    private final EventPublisher eventPublisher;
+
+    @Override
+    @Transactional
+    public void handle(OrderCancelledEvent event) {
+
+        logger.info("Received OrderCancelledEvent for order ID: {}. Reverting stock.", event.getOrderId());
+
+        if (event.getItems() == null || event.getItems().isEmpty()) {
+            logger.warn("OrderCancelledEvent for order ID: {} contained no items. No stock to revert.", event.getOrderId());
+            return;
+        }
+
+        try {
+            ArrayList<ProductSnapshot> snapshots = new ArrayList<>();
+            for (OrderItem item : event.getItems()) {
+                if (item.getProductId() == null || item.getQuantity() <= 0) {
+                    logger.warn("Invalid item data in OrderCancelledEvent for order ID: {}. ProductId: {}, Quantity: {}. Skipping item.",
+                            event.getOrderId(), item.getProductId(), item.getQuantity());
+                    continue;
+                }
+
+                UUID productId = UUID.fromString(item.getProductId());
+                int quantityToRevert = item.getQuantity();
+
+                Stock stock = stockRepository.findById(productId).orElse(null);
+
+                if (stock == null) {
+                    logger.warn("Product with ID: {} for order cancellation ID: {} not found in stock. Cannot revert quantity {}. " +
+                                    "This might indicate the product was deleted or never existed in this warehouse.",
+                            item.getProductId(), event.getOrderId(), quantityToRevert);
+
+                    continue;
+                }
+
+                int currentQuantity = stock.getQuantity();
+                int newQuantity = currentQuantity + quantityToRevert;
+
+                stockService.updateStock(
+                        productId,
+                        null,
+                        newQuantity,
+                        stock.getThreshold(),
+                        null,
+                        null
+                );
+
+                snapshots.add(EventFactory.createProductSnapshot(item.getProductId(), newQuantity));
+
+                logger.info("Stock reverted for product ID: {}. Order ID: {}. Quantity reverted: {}. Old quantity: {}. New quantity: {}",
+                        productId, event.getOrderId(), quantityToRevert, currentQuantity, newQuantity);
+            }
+
+            UUID orderId = UUID.fromString(event.getOrderId());
+            packagedOrdersRepository.deleteById(orderId);
+            assignedOrdersRepository.deleteById(orderId);
+
+            InventoryUpdatedEvent inventoryUpdatedEvent = EventFactory.createInventoryUpdatedEvent(snapshots);
+            eventPublisher.publishEvent(EventsConstants.INVENTORY_UPDATED, inventoryUpdatedEvent);
+
+            logger.info("Successfully reverted stock for all items in cancelled order ID: {}", event.getOrderId());
+
+        } catch (IllegalArgumentException e) {
+            logger.error("Error processing OrderCancelledEvent for order ID: {}. Invalid UUID format for a product ID. Details: {}", event.getOrderId(), e.getMessage(), e);
+        } catch (Exception e) {
+            logger.error("Critical error processing OrderCancelledEvent for order ID: {}. Details: {}", event.getOrderId(), e.getMessage(), e);
+        }
+    }
+}

src/main/resources/application.yml

@@ -65,3 +65,7 @@ spring:
 appconfig:
   cache:
     enabled: true
+
+server:
+  servlet:
+    context-path: /api