Hot fix

build_and_run.sh

@@ -0,0 +1,3 @@
+mvn clean package -DskipTests
+docker compose down
+docker compose up -d --build

docker-compose.yml

@@ -3,16 +3,22 @@ services:
     image: openjdk:25-ea-4-jdk-oraclelinux9
     container_name: warehouse-backend
     ports:
-      - "8080:8080"
+      - "8082:8080"
     depends_on:
       - redis
-      - rabbitmq
     env_file:
       - .env
+    environment:
+      SPRING_RABBITMQ_HOST: host.docker.internal
+      SPRING_RABBITMQ_PORT: 5672
+      SPRING_RABBITMQ_USERNAME: guest
+      SPRING_RABBITMQ_PASSWORD: guest
     volumes:
       - ./target/warehouse-0.0.1-SNAPSHOT.jar:/app/warehouse-0.0.1-SNAPSHOT.jar
       - ./logs:/logs
     command: [ "java", "-jar", "/app/warehouse-0.0.1-SNAPSHOT.jar" ]
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
 
 #  warehouse_db:
 #    image: postgres:latest
@@ -28,54 +34,18 @@ services:
     image: redis:latest
     container_name: redis
     ports:
-      - "6379:6379"
+      - "6390:6379"
     expose:
       - "9121"
 
   redisinsight:
     image: redislabs/redisinsight:latest
     container_name: redisinsight
     ports:
-      - "5540:5540"
+      - "8100:8001"
     environment:
       - REDIS_HOST=redis
       - REDIS_PORT=6379
     depends_on:
       - redis
     restart: unless-stopped
-
-
-  rabbitmq:
-    image: rabbitmq:management
-    container_name: rabbitmq
-    ports:
-      - "5672:5672"
-      - "15672:15672"
-    environment:
-      RABBITMQ_DEFAULT_USER: guest
-      RABBITMQ_DEFAULT_PASS: guest
-
-  loki:
-    image: grafana/loki:latest
-    container_name: loki
-    ports:
-      - "3100:3100"
-    command: -config.file=/etc/loki/local-config.yaml
-
-  promtail:
-    image: grafana/promtail:latest
-    container_name: promtail
-    volumes:
-      - ./promtail-config.yml:/etc/promtail/promtail-config.yaml
-      - ./logs:/logs
-    command: -config.file=/etc/promtail/promtail-config.yaml
-    depends_on:
-      - loki
-
-  grafana:
-    image: grafana/grafana:latest
-    container_name: grafana
-    ports:
-      - "3000:3000"
-    depends_on:
-      - loki

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

@@ -2,7 +2,10 @@
 
 import com.podzilla.warehouse.Commands.AssignOrderCommand;
 import com.podzilla.warehouse.Models.AssignedOrders;
+import com.podzilla.warehouse.Models.Assigner;
 import com.podzilla.warehouse.Services.AssignedOrdersService;
+import com.podzilla.warehouse.Services.AssignerService;
+
 import io.swagger.v3.oas.annotations.Operation;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -19,16 +22,20 @@
 public class AssignerController {
 
     @Autowired
-    private AssignedOrdersService assignerService;
+    private AssignedOrdersService assignedOrdersService;
+
+    @Autowired
+    private AssignerService assignerService;
 
     @Operation(summary = "Assign an order to a courier")
     @PostMapping("/order")
     public ResponseEntity<AssignedOrders> assignOrder(@RequestParam UUID orderId,
-                                                      @RequestParam UUID assignerId,
-                                                      @RequestParam UUID courierId) {
-        log.info("Received assignment request: orderId={}, assignerId={}, courierId={}", orderId, assignerId, courierId);
+            @RequestParam UUID assignerId,
+            @RequestParam UUID courierId) {
+        log.info("Received assignment request: orderId={}, assignerId={}, courierId={}", orderId, assignerId,
+                courierId);
 
-        AssignOrderCommand command = new AssignOrderCommand(assignerService, orderId, assignerId, courierId);
+        AssignOrderCommand command = new AssignOrderCommand(assignedOrdersService, orderId, assignerId, courierId);
         command.execute();
 
         AssignedOrders assigned = command.getAssignedOrderResult();
@@ -39,23 +46,29 @@ public ResponseEntity<AssignedOrders> assignOrder(@RequestParam UUID orderId,
     @GetMapping("/order/{orderId}")
     public ResponseEntity<List<AssignedOrders>> getByOrderId(@PathVariable UUID orderId) {
         log.info("Fetching assignments for orderId={}", orderId);
-        Optional<List<AssignedOrders>> result = assignerService.findByOrderId(orderId);
+        Optional<List<AssignedOrders>> result = assignedOrdersService.findByOrderId(orderId);
         return result.map(ResponseEntity::ok).orElseGet(() -> ResponseEntity.notFound().build());
     }
 
     @Operation(summary = "Find assignments by assigner ID")
     @GetMapping("/assigner/{assignerId}")
     public ResponseEntity<List<AssignedOrders>> getByAssignerId(@PathVariable UUID assignerId) {
         log.info("Fetching assignments by assignerId={}", assignerId);
-        Optional<List<AssignedOrders>> result = assignerService.findByAssignerId(assignerId);
+        Optional<List<AssignedOrders>> result = assignedOrdersService.findByAssignerId(assignerId);
         return result.map(ResponseEntity::ok).orElseGet(() -> ResponseEntity.notFound().build());
     }
 
     @Operation(summary = "Find unassigned orders")
     @GetMapping("/unassigned")
     public ResponseEntity<List<AssignedOrders>> getUnassignedOrders() {
         log.info("Fetching unassigned orders");
-        Optional<List<AssignedOrders>> result = assignerService.findByAssignerIdIsNull();
+        Optional<List<AssignedOrders>> result = assignedOrdersService.findByAssignerIdIsNull();
         return result.map(ResponseEntity::ok).orElseGet(() -> ResponseEntity.notFound().build());
     }
+
+    @PostMapping
+    public ResponseEntity<Assigner> createAssigner(@RequestBody Assigner assigner) {
+        log.info("Creating new assigner");
+        return ResponseEntity.ok(assignerService.createAssigner(assigner).get());
+    }
 }

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

@@ -1,23 +1,43 @@
 package com.podzilla.warehouse.Events;
 
-import com.podzilla.mq.events.InventoryUpdatedEvent;
 import com.podzilla.mq.events.OrderPlacedEvent;
 import com.podzilla.warehouse.Models.PackagedOrders;
+import com.podzilla.warehouse.Models.Stock;
 import com.podzilla.warehouse.Repositories.PackagedOrdersRepository;
+import com.podzilla.warehouse.Repositories.StockRepository;
+
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Component;
 
+import java.util.List;
 import java.util.UUID;
 
 @RequiredArgsConstructor
 @Component
 public class OrderPlacedEventHandler implements EventHandler<OrderPlacedEvent> {
     private final PackagedOrdersRepository packagedOrdersRepository;
+    private final StockRepository stockRepository;
 
     @Override
     public void handle(OrderPlacedEvent event) {
-        //create packaged order
-        PackagedOrders packagedOrder = new PackagedOrders(UUID.fromString(event.getOrderId()));
+        // create packaged order
+        System.out.println("Received OrderPlacedEvent: " + event);
+        List<Stock> stocks = event.getItems().stream()
+                .map(item -> stockRepository.findById(UUID.fromString(item.getProductId()))
+                        .get())
+                .toList();
+
+        PackagedOrders packagedOrder = PackagedOrders.builder()
+                .orderId(UUID.fromString(event.getOrderId()))
+                .deliveryAddress(event.getDeliveryAddress())
+                .items(stocks)
+                .totalAmount(event.getTotalAmount())
+                .orderLatitude(event.getOrderLatitude())
+                .orderLongitude(event.getOrderLongitude())
+                .confirmationType(event.getConfirmationType())
+                .signature(event.getSignature())
+                .build();
+        System.out.println("Packaged order created: " + packagedOrder);
         packagedOrdersRepository.save(packagedOrder);
     }
 }

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

@@ -22,6 +22,7 @@ public class OrderStockReservationEventHandler implements EventHandler<OrderStoc
 
     @Override
     public void handle(OrderStockReservationRequestedEvent event) {
+        System.err.println("Received OrderStockReservationRequestedEvent: " + event);
         boolean allAvailable = true;
 
         // Check if all items are available in stock

src/main/java/com/podzilla/warehouse/Models/AssignedOrders.java

@@ -3,6 +3,7 @@
 import com.podzilla.mq.events.ConfirmationType;
 import com.podzilla.mq.events.DeliveryAddress;
 import jakarta.persistence.*;
+import lombok.Builder;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
@@ -17,6 +18,7 @@
 @Setter
 @NoArgsConstructor
 @Getter
+@Builder
 @Table(name = "Assignments")
 public class AssignedOrders {
     @Id
@@ -32,21 +34,20 @@ public class AssignedOrders {
     @CreationTimestamp
     private LocalDateTime assignedAt;
 
-    @Column(nullable = false)
-    @OneToMany(mappedBy = "assignedOrder")
+    @OneToMany(mappedBy = "assignedOrder", cascade = CascadeType.ALL, orphanRemoval = true)
     private List<Stock> items;
 
-    @Column(nullable = false)
+    // @Column(nullable = false)
     private DeliveryAddress deliveryAddress;
-    @Column(nullable = false)
+    // @Column(nullable = false)
     private BigDecimal totalAmount;
-    @Column(nullable = false)
+    // @Column(nullable = false)
     private double orderLatitude;
-    @Column(nullable = false)
+    // @Column(nullable = false)
     private double orderLongitude;
-    @Column(nullable = false)
+    // @Column(nullable = false)
     private String signature;
-    @Column(nullable = false)
+    // @Column(nullable = false)
     private ConfirmationType confirmationType;
 
     public AssignedOrders(UUID orderId, UUID assignerId, UUID courierId, List<Stock> items,

src/main/java/com/podzilla/warehouse/Models/PackagedOrders.java

@@ -3,40 +3,41 @@
 import com.podzilla.mq.events.ConfirmationType;
 import com.podzilla.mq.events.DeliveryAddress;
 import jakarta.persistence.*;
-import lombok.Getter;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
 import lombok.NoArgsConstructor;
-import lombok.Setter;
 import org.hibernate.annotations.CreationTimestamp;
 
 import java.math.BigDecimal;
 import java.time.LocalDateTime;
 import java.util.List;
 import java.util.UUID;
 
-@Setter
-@Getter
+@Data
 @Entity
 @NoArgsConstructor
+@Builder
+@AllArgsConstructor
 @Table()
 public class PackagedOrders {
     @Id
     private UUID orderId;
     private UUID packagerId;
-    @Column(nullable = false)
-    @OneToMany(mappedBy = "packagedOrder")
+    @OneToMany(mappedBy = "packagedOrder", cascade = CascadeType.ALL, orphanRemoval = true)
     private List<Stock> items;
 
-    @Column(nullable = false)
+    // @Column(nullable = false)
     private DeliveryAddress deliveryAddress;
-    @Column(nullable = false)
+    // @Column(nullable = false)
     private BigDecimal totalAmount;
-    @Column(nullable = false)
+    // @Column(nullable = false)
     private double orderLatitude;
-    @Column(nullable = false)
+    // @Column(nullable = false)
     private double orderLongitude;
-    @Column(nullable = false)
+    // @Column(nullable = false)
     private String signature;
-    @Column(nullable = false)
+    // @Column(nullable = false)
     private ConfirmationType confirmationType;
 
     @CreationTimestamp

src/main/java/com/podzilla/warehouse/Repositories/AssignedOrdersRepository.java

@@ -14,4 +14,6 @@ public interface AssignedOrdersRepository extends JpaRepository<AssignedOrders,
     List<AssignedOrders> findByAssignerId(UUID assignerId);
 
     List<AssignedOrders> findByOrderId(UUID orderId);
+
+    AssignedOrders findOneByOrderId(UUID orderId);
 }

src/main/java/com/podzilla/warehouse/Services/AssignedOrdersService.java

@@ -47,10 +47,9 @@ public Optional<List<AssignedOrders>> findByAssignerIdIsNull() {
 
     @CachePut(key = "'orderId:' + #orderId")
     public AssignedOrders assignOrder(UUID orderId, UUID assignerId, UUID courierId) {
-        PackagedOrders packagedOrder = packagedOrdersRepository.findOneByOrderId(orderId).get();
-        AssignedOrders assignment = new AssignedOrders(orderId, assignerId, courierId, packagedOrder.getItems(),
-                packagedOrder.getDeliveryAddress(), packagedOrder.getTotalAmount(), packagedOrder.getOrderLatitude(),
-                packagedOrder.getOrderLongitude(), packagedOrder.getSignature(), packagedOrder.getConfirmationType());
+        AssignedOrders assignment = assignedOrdersRepository.findOneByOrderId(orderId);
+        assignment.setAssignerId(assignerId);
+        assignment.setCourierId(courierId);
         assignedOrdersRepository.save(assignment);
 
         OrderAssignedToCourierEvent event = 

src/main/java/com/podzilla/warehouse/Services/AssignerService.java

@@ -18,7 +18,7 @@ public class AssignerService {
     @Autowired
     private AssignerRepository assignerRepository;
 
-    @CachePut(key = "#result.get().id", condition = "#result.isPresent()")
+    // @CachePut(key = "#result.get().id", condition = "#result.isPresent()")
     public Optional<Assigner> createAssigner(Assigner assigner) {
         return Optional.of(assignerRepository.save(assigner));
     }

src/main/java/com/podzilla/warehouse/Services/PackagedOrdersService.java

@@ -4,7 +4,9 @@
 import com.podzilla.mq.EventsConstants;
 import com.podzilla.mq.events.OrderPackagedEvent;
 import com.podzilla.warehouse.Events.EventFactory;
+import com.podzilla.warehouse.Models.AssignedOrders;
 import com.podzilla.warehouse.Models.PackagedOrders;
+import com.podzilla.warehouse.Repositories.AssignedOrdersRepository;
 import com.podzilla.warehouse.Repositories.PackagedOrdersRepository;
 import lombok.RequiredArgsConstructor;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -26,7 +28,9 @@
 public class PackagedOrdersService {
     private final EventPublisher eventPublisher;
     @Autowired
-    private PackagedOrdersRepository packagedOrdersRepository;
+    private final PackagedOrdersRepository packagedOrdersRepository;
+
+    private final AssignedOrdersRepository assignedOrdersRepository;
 
     @Cacheable(value = "packagedOrdersByOrderId", key = "#orderId.toString() + '-' + #pageable.pageNumber + '-' + #pageable.pageSize")
     public Page<PackagedOrders> findByOrderId(UUID orderId, Pageable pageable) {
@@ -45,11 +49,24 @@ public Page<PackagedOrders> findByPackagerIdIsNull(Pageable pageable) {
 
     @CachePut(value = "packagedOrdersByPackagerId", key = "#packagerId.toString() + '-0-10'")
     public Optional<PackagedOrders> packageOrder(UUID orderId,UUID packagerId) {
-        PackagedOrders packagedOrder = new PackagedOrders(orderId, packagerId, LocalDateTime.now());
-
+        PackagedOrders packagedOrder = packagedOrdersRepository.findOneByOrderId(orderId).get();
+        packagedOrder.setPackagerId(packagerId);
         OrderPackagedEvent event = EventFactory.createOrderPackagedEvent(orderId);
         eventPublisher.publishEvent(EventsConstants.ORDER_PACKAGED, event);
 
+        AssignedOrders assignment = AssignedOrders.builder()
+                .orderId(orderId)
+                .items(packagedOrder.getItems())
+                .deliveryAddress(packagedOrder.getDeliveryAddress())
+                .totalAmount(packagedOrder.getTotalAmount())
+                .orderLatitude(packagedOrder.getOrderLatitude())
+                .orderLongitude(packagedOrder.getOrderLongitude())
+                .confirmationType(packagedOrder.getConfirmationType())
+                .signature(packagedOrder.getSignature())
+                .build();
+
+        assignedOrdersRepository.save(assignment);
+
         return Optional.of(packagedOrdersRepository.save(packagedOrder));
     }
 

src/main/resources/application.yml

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