feat(production): Produktionsauftrag umterminieren und abfragen (US-P17)

Reschedule (PLANNED/RELEASED) mit Datumsvalidierung und List-Endpoint
mit optionaler Filterung nach Datum/Status als Full Vertical Slice.
Lasttests um neue Szenarien erweitert.

backend/src/main/java/de/effigenix/application/production/ListProductionOrders.java

@@ -0,0 +1,64 @@
+package de.effigenix.application.production;
+
+import de.effigenix.domain.production.*;
+import de.effigenix.shared.common.RepositoryError;
+import de.effigenix.shared.common.Result;
+import de.effigenix.shared.security.ActorId;
+import de.effigenix.shared.security.AuthorizationPort;
+
+import java.time.LocalDate;
+import java.util.List;
+
+public class ListProductionOrders {
+
+    private final ProductionOrderRepository productionOrderRepository;
+    private final AuthorizationPort authorizationPort;
+
+    public ListProductionOrders(
+            ProductionOrderRepository productionOrderRepository,
+            AuthorizationPort authorizationPort
+    ) {
+        this.productionOrderRepository = productionOrderRepository;
+        this.authorizationPort = authorizationPort;
+    }
+
+    public Result<ProductionOrderError, List<ProductionOrder>> execute(ActorId performedBy) {
+        if (!authorizationPort.can(performedBy, ProductionAction.PRODUCTION_ORDER_READ)) {
+            return Result.failure(new ProductionOrderError.Unauthorized("Not authorized to list production orders"));
+        }
+
+        return wrapResult(productionOrderRepository.findAll());
+    }
+
+    public Result<ProductionOrderError, List<ProductionOrder>> executeByDateRange(LocalDate from, LocalDate to, ActorId performedBy) {
+        if (!authorizationPort.can(performedBy, ProductionAction.PRODUCTION_ORDER_READ)) {
+            return Result.failure(new ProductionOrderError.Unauthorized("Not authorized to list production orders"));
+        }
+
+        return wrapResult(productionOrderRepository.findByDateRange(from, to));
+    }
+
+    public Result<ProductionOrderError, List<ProductionOrder>> executeByStatus(ProductionOrderStatus status, ActorId performedBy) {
+        if (!authorizationPort.can(performedBy, ProductionAction.PRODUCTION_ORDER_READ)) {
+            return Result.failure(new ProductionOrderError.Unauthorized("Not authorized to list production orders"));
+        }
+
+        return wrapResult(productionOrderRepository.findByStatus(status));
+    }
+
+    public Result<ProductionOrderError, List<ProductionOrder>> executeByDateRangeAndStatus(
+            LocalDate from, LocalDate to, ProductionOrderStatus status, ActorId performedBy) {
+        if (!authorizationPort.can(performedBy, ProductionAction.PRODUCTION_ORDER_READ)) {
+            return Result.failure(new ProductionOrderError.Unauthorized("Not authorized to list production orders"));
+        }
+
+        return wrapResult(productionOrderRepository.findByDateRangeAndStatus(from, to, status));
+    }
+
+    private Result<ProductionOrderError, List<ProductionOrder>> wrapResult(Result<RepositoryError, List<ProductionOrder>> repoResult) {
+        return switch (repoResult) {
+            case Result.Failure(var err) -> Result.failure(new ProductionOrderError.RepositoryFailure(err.message()));
+            case Result.Success(var orders) -> Result.success(orders);
+        };
+    }
+}

backend/src/main/java/de/effigenix/application/production/RescheduleProductionOrder.java

@@ -0,0 +1,60 @@
+package de.effigenix.application.production;
+
+import de.effigenix.application.production.command.RescheduleProductionOrderCommand;
+import de.effigenix.domain.production.*;
+import de.effigenix.shared.common.Result;
+import de.effigenix.shared.persistence.UnitOfWork;
+import de.effigenix.shared.security.ActorId;
+import de.effigenix.shared.security.AuthorizationPort;
+
+public class RescheduleProductionOrder {
+
+    private final ProductionOrderRepository productionOrderRepository;
+    private final AuthorizationPort authorizationPort;
+    private final UnitOfWork unitOfWork;
+
+    public RescheduleProductionOrder(
+            ProductionOrderRepository productionOrderRepository,
+            AuthorizationPort authorizationPort,
+            UnitOfWork unitOfWork
+    ) {
+        this.productionOrderRepository = productionOrderRepository;
+        this.authorizationPort = authorizationPort;
+        this.unitOfWork = unitOfWork;
+    }
+
+    public Result<ProductionOrderError, ProductionOrder> execute(RescheduleProductionOrderCommand cmd, ActorId performedBy) {
+        if (!authorizationPort.can(performedBy, ProductionAction.PRODUCTION_ORDER_WRITE)) {
+            return Result.failure(new ProductionOrderError.Unauthorized("Not authorized to reschedule production orders"));
+        }
+
+        var orderId = ProductionOrderId.of(cmd.productionOrderId());
+        ProductionOrder order;
+        switch (productionOrderRepository.findById(orderId)) {
+            case Result.Failure(var err) -> {
+                return Result.failure(new ProductionOrderError.RepositoryFailure(err.message()));
+            }
+            case Result.Success(var opt) -> {
+                if (opt.isEmpty()) {
+                    return Result.failure(new ProductionOrderError.ProductionOrderNotFound(orderId));
+                }
+                order = opt.get();
+            }
+        }
+
+        switch (order.reschedule(cmd.newPlannedDate())) {
+            case Result.Failure(var err) -> { return Result.failure(err); }
+            case Result.Success(var ignored) -> { }
+        }
+
+        return unitOfWork.executeAtomically(() -> {
+            switch (productionOrderRepository.save(order)) {
+                case Result.Failure(var err) -> {
+                    return Result.failure(new ProductionOrderError.RepositoryFailure(err.message()));
+                }
+                case Result.Success(var ignored) -> { }
+            }
+            return Result.success(order);
+        });
+    }
+}

backend/src/main/java/de/effigenix/application/production/command/RescheduleProductionOrderCommand.java

@@ -0,0 +1,6 @@
+package de.effigenix.application.production.command;
+
+import java.time.LocalDate;
+
+public record RescheduleProductionOrderCommand(String productionOrderId, LocalDate newPlannedDate) {
+}

backend/src/main/java/de/effigenix/domain/production/ProductionOrder.java

@@ -25,6 +25,7 @@ import java.time.ZoneOffset;
  * 10. Only IN_PROGRESS → COMPLETED transition allowed via complete() (Batch must be COMPLETED – enforced by Use Case)
  * 11. Only PLANNED or RELEASED → CANCELLED transition allowed via cancel(reason)
  * 12. CancelledReason is set exactly once during cancel() and must not be blank
+ * 13. Reschedule only in PLANNED or RELEASED, new date must not be in the past
  */
 public class ProductionOrder {
 
@@ -33,7 +34,7 @@ public class ProductionOrder {
     private ProductionOrderStatus status;
     private BatchId batchId;
     private final Quantity plannedQuantity;
-    private final LocalDate plannedDate;
+    private LocalDate plannedDate;
     private final Priority priority;
     private final String notes;
     private String cancelledReason;
@@ -193,6 +194,18 @@ public class ProductionOrder {
         return Result.success(null);
     }
 
+    public Result<ProductionOrderError, Void> reschedule(LocalDate newDate) {
+        if (status != ProductionOrderStatus.PLANNED && status != ProductionOrderStatus.RELEASED) {
+            return Result.failure(new ProductionOrderError.InvalidStatusTransition(status, status));
+        }
+        if (newDate.isBefore(LocalDate.now())) {
+            return Result.failure(new ProductionOrderError.PlannedDateInPast(newDate));
+        }
+        this.plannedDate = newDate;
+        this.updatedAt = OffsetDateTime.now(ZoneOffset.UTC);
+        return Result.success(null);
+    }
+
     public Result<ProductionOrderError, Void> cancel(String reason) {
         if (reason == null || reason.isBlank()) {
             return Result.failure(new ProductionOrderError.ValidationFailure("Cancellation reason must not be blank"));

backend/src/main/java/de/effigenix/domain/production/ProductionOrderRepository.java

@@ -3,6 +3,7 @@ package de.effigenix.domain.production;
 import de.effigenix.shared.common.RepositoryError;
 import de.effigenix.shared.common.Result;
 
+import java.time.LocalDate;
 import java.util.List;
 import java.util.Optional;
 
@@ -12,5 +13,11 @@ public interface ProductionOrderRepository {
 
     Result<RepositoryError, List<ProductionOrder>> findAll();
 
+    Result<RepositoryError, List<ProductionOrder>> findByDateRange(LocalDate from, LocalDate to);
+
+    Result<RepositoryError, List<ProductionOrder>> findByStatus(ProductionOrderStatus status);
+
+    Result<RepositoryError, List<ProductionOrder>> findByDateRangeAndStatus(LocalDate from, LocalDate to, ProductionOrderStatus status);
+
     Result<RepositoryError, Void> save(ProductionOrder productionOrder);
 }

backend/src/main/java/de/effigenix/infrastructure/config/ProductionUseCaseConfiguration.java

@@ -7,7 +7,9 @@ import de.effigenix.application.production.AddRecipeIngredient;
 import de.effigenix.application.production.CancelProductionOrder;
 import de.effigenix.application.production.CompleteProductionOrder;
 import de.effigenix.application.production.CreateProductionOrder;
+import de.effigenix.application.production.ListProductionOrders;
 import de.effigenix.application.production.ReleaseProductionOrder;
+import de.effigenix.application.production.RescheduleProductionOrder;
 import de.effigenix.application.production.StartProductionOrder;
 import de.effigenix.application.production.CancelBatch;
 import de.effigenix.application.production.CompleteBatch;
@@ -177,4 +179,17 @@ public class ProductionUseCaseConfiguration {
                                                         UnitOfWork unitOfWork) {
         return new CancelProductionOrder(productionOrderRepository, authorizationPort, unitOfWork);
     }
+
+    @Bean
+    public RescheduleProductionOrder rescheduleProductionOrder(ProductionOrderRepository productionOrderRepository,
+                                                                AuthorizationPort authorizationPort,
+                                                                UnitOfWork unitOfWork) {
+        return new RescheduleProductionOrder(productionOrderRepository, authorizationPort, unitOfWork);
+    }
+
+    @Bean
+    public ListProductionOrders listProductionOrders(ProductionOrderRepository productionOrderRepository,
+                                                      AuthorizationPort authorizationPort) {
+        return new ListProductionOrders(productionOrderRepository, authorizationPort);
+    }
 }

backend/src/main/java/de/effigenix/infrastructure/production/persistence/JdbcProductionOrderRepository.java

@@ -13,6 +13,7 @@ import org.springframework.stereotype.Repository;
 
 import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.time.LocalDate;
 import java.time.OffsetDateTime;
 import java.util.List;
 import java.util.Optional;
@@ -56,6 +57,51 @@ public class JdbcProductionOrderRepository implements ProductionOrderRepository
         }
     }
 
+    @Override
+    public Result<RepositoryError, List<ProductionOrder>> findByDateRange(LocalDate from, LocalDate to) {
+        try {
+            var orders = jdbc.sql("SELECT * FROM production_orders WHERE planned_date BETWEEN :from AND :to ORDER BY planned_date, created_at DESC")
+                    .param("from", from)
+                    .param("to", to)
+                    .query(this::mapRow)
+                    .list();
+            return Result.success(orders);
+        } catch (Exception e) {
+            logger.trace("Database error in findByDateRange", e);
+            return Result.failure(new RepositoryError.DatabaseError(e.getMessage()));
+        }
+    }
+
+    @Override
+    public Result<RepositoryError, List<ProductionOrder>> findByStatus(ProductionOrderStatus status) {
+        try {
+            var orders = jdbc.sql("SELECT * FROM production_orders WHERE status = :status ORDER BY planned_date, created_at DESC")
+                    .param("status", status.name())
+                    .query(this::mapRow)
+                    .list();
+            return Result.success(orders);
+        } catch (Exception e) {
+            logger.trace("Database error in findByStatus", e);
+            return Result.failure(new RepositoryError.DatabaseError(e.getMessage()));
+        }
+    }
+
+    @Override
+    public Result<RepositoryError, List<ProductionOrder>> findByDateRangeAndStatus(LocalDate from, LocalDate to, ProductionOrderStatus status) {
+        try {
+            var orders = jdbc.sql("SELECT * FROM production_orders WHERE planned_date BETWEEN :from AND :to AND status = :status ORDER BY planned_date, created_at DESC")
+                    .param("from", from)
+                    .param("to", to)
+                    .param("status", status.name())
+                    .query(this::mapRow)
+                    .list();
+            return Result.success(orders);
+        } catch (Exception e) {
+            logger.trace("Database error in findByDateRangeAndStatus", e);
+            return Result.failure(new RepositoryError.DatabaseError(e.getMessage()));
+        }
+    }
+
     @Override
     public Result<RepositoryError, Void> save(ProductionOrder order) {
         try {
@@ -63,6 +109,7 @@ public class JdbcProductionOrderRepository implements ProductionOrderRepository
                     UPDATE production_orders
                     SET status = :status, batch_id = :batchId, priority = :priority,
                         notes = :notes, cancelled_reason = :cancelledReason,
+                        planned_date = :plannedDate,
                         updated_at = :updatedAt, version = version + 1
                     WHERE id = :id AND version = :version
                     """)
@@ -72,6 +119,7 @@ public class JdbcProductionOrderRepository implements ProductionOrderRepository
                     .param("priority", order.priority().name())
                     .param("notes", order.notes())
                     .param("cancelledReason", order.cancelledReason())
+                    .param("plannedDate", order.plannedDate())
                     .param("updatedAt", order.updatedAt())
                     .param("version", order.version())
                     .update();

backend/src/main/java/de/effigenix/infrastructure/production/web/controller/ProductionOrderController.java

@@ -3,17 +3,22 @@ package de.effigenix.infrastructure.production.web.controller;
 import de.effigenix.application.production.CancelProductionOrder;
 import de.effigenix.application.production.CompleteProductionOrder;
 import de.effigenix.application.production.CreateProductionOrder;
+import de.effigenix.application.production.ListProductionOrders;
 import de.effigenix.application.production.ReleaseProductionOrder;
+import de.effigenix.application.production.RescheduleProductionOrder;
 import de.effigenix.application.production.StartProductionOrder;
 import de.effigenix.application.production.command.CancelProductionOrderCommand;
 import de.effigenix.application.production.command.CompleteProductionOrderCommand;
 import de.effigenix.application.production.command.CreateProductionOrderCommand;
 import de.effigenix.application.production.command.ReleaseProductionOrderCommand;
+import de.effigenix.application.production.command.RescheduleProductionOrderCommand;
 import de.effigenix.application.production.command.StartProductionOrderCommand;
 import de.effigenix.domain.production.ProductionOrderError;
+import de.effigenix.domain.production.ProductionOrderStatus;
 import de.effigenix.infrastructure.production.web.dto.CancelProductionOrderRequest;
 import de.effigenix.infrastructure.production.web.dto.CreateProductionOrderRequest;
 import de.effigenix.infrastructure.production.web.dto.ProductionOrderResponse;
+import de.effigenix.infrastructure.production.web.dto.RescheduleProductionOrderRequest;
 import de.effigenix.infrastructure.production.web.dto.StartProductionOrderRequest;
 import de.effigenix.shared.security.ActorId;
 import io.swagger.v3.oas.annotations.security.SecurityRequirement;
@@ -21,12 +26,16 @@ import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.validation.Valid;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.format.annotation.DateTimeFormat;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.security.access.prepost.PreAuthorize;
 import org.springframework.security.core.Authentication;
 import org.springframework.web.bind.annotation.*;
 
+import java.time.LocalDate;
+import java.util.List;
+
 @RestController
 @RequestMapping("/api/production/production-orders")
 @SecurityRequirement(name = "Bearer Authentication")
@@ -37,20 +46,57 @@ public class ProductionOrderController {
 
     private final CreateProductionOrder createProductionOrder;
     private final ReleaseProductionOrder releaseProductionOrder;
+    private final RescheduleProductionOrder rescheduleProductionOrder;
     private final StartProductionOrder startProductionOrder;
     private final CompleteProductionOrder completeProductionOrder;
     private final CancelProductionOrder cancelProductionOrder;
+    private final ListProductionOrders listProductionOrders;
 
     public ProductionOrderController(CreateProductionOrder createProductionOrder,
                                      ReleaseProductionOrder releaseProductionOrder,
+                                     RescheduleProductionOrder rescheduleProductionOrder,
                                      StartProductionOrder startProductionOrder,
                                      CompleteProductionOrder completeProductionOrder,
-                                     CancelProductionOrder cancelProductionOrder) {
+                                     CancelProductionOrder cancelProductionOrder,
+                                     ListProductionOrders listProductionOrders) {
         this.createProductionOrder = createProductionOrder;
         this.releaseProductionOrder = releaseProductionOrder;
+        this.rescheduleProductionOrder = rescheduleProductionOrder;
         this.startProductionOrder = startProductionOrder;
         this.completeProductionOrder = completeProductionOrder;
         this.cancelProductionOrder = cancelProductionOrder;
+        this.listProductionOrders = listProductionOrders;
+    }
+
+    @GetMapping
+    @PreAuthorize("hasAuthority('PRODUCTION_ORDER_READ')")
+    public ResponseEntity<List<ProductionOrderResponse>> listProductionOrders(
+            @RequestParam(required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate dateFrom,
+            @RequestParam(required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate dateTo,
+            @RequestParam(required = false) String status,
+            Authentication authentication
+    ) {
+        logger.info("Listing production orders by actor: {}", authentication.getName());
+
+        var actor = ActorId.of(authentication.getName());
+        ProductionOrderStatus statusEnum = status != null ? ProductionOrderStatus.valueOf(status) : null;
+
+        var result = (dateFrom != null && dateTo != null && statusEnum != null)
+                ? listProductionOrders.executeByDateRangeAndStatus(dateFrom, dateTo, statusEnum, actor)
+                : (dateFrom != null && dateTo != null)
+                ? listProductionOrders.executeByDateRange(dateFrom, dateTo, actor)
+                : (statusEnum != null)
+                ? listProductionOrders.executeByStatus(statusEnum, actor)
+                : listProductionOrders.execute(actor);
+
+        if (result.isFailure()) {
+            throw new ProductionOrderDomainErrorException(result.unsafeGetError());
+        }
+
+        var responses = result.unsafeGetValue().stream()
+                .map(ProductionOrderResponse::from)
+                .toList();
+        return ResponseEntity.ok(responses);
     }
 
     @PostMapping
@@ -80,6 +126,25 @@ public class ProductionOrderController {
                 .body(ProductionOrderResponse.from(result.unsafeGetValue()));
     }
 
+    @PostMapping("/{id}/reschedule")
+    @PreAuthorize("hasAuthority('PRODUCTION_ORDER_WRITE')")
+    public ResponseEntity<ProductionOrderResponse> rescheduleProductionOrder(
+            @PathVariable String id,
+            @Valid @RequestBody RescheduleProductionOrderRequest request,
+            Authentication authentication
+    ) {
+        logger.info("Rescheduling production order: {} to {} by actor: {}", id, request.newPlannedDate(), authentication.getName());
+
+        var cmd = new RescheduleProductionOrderCommand(id, request.newPlannedDate());
+        var result = rescheduleProductionOrder.execute(cmd, ActorId.of(authentication.getName()));
+
+        if (result.isFailure()) {
+            throw new ProductionOrderDomainErrorException(result.unsafeGetError());
+        }
+
+        return ResponseEntity.ok(ProductionOrderResponse.from(result.unsafeGetValue()));
+    }
+
     @PostMapping("/{id}/release")
     @PreAuthorize("hasAuthority('PRODUCTION_ORDER_WRITE')")
     public ResponseEntity<ProductionOrderResponse> releaseProductionOrder(

backend/src/main/java/de/effigenix/infrastructure/production/web/dto/RescheduleProductionOrderRequest.java

@@ -0,0 +1,8 @@
+package de.effigenix.infrastructure.production.web.dto;
+
+import jakarta.validation.constraints.NotNull;
+
+import java.time.LocalDate;
+
+public record RescheduleProductionOrderRequest(@NotNull LocalDate newPlannedDate) {
+}

backend/src/main/java/de/effigenix/infrastructure/stub/StubProductionOrderRepository.java

@@ -3,11 +3,13 @@ package de.effigenix.infrastructure.stub;
 import de.effigenix.domain.production.ProductionOrder;
 import de.effigenix.domain.production.ProductionOrderId;
 import de.effigenix.domain.production.ProductionOrderRepository;
+import de.effigenix.domain.production.ProductionOrderStatus;
 import de.effigenix.shared.common.RepositoryError;
 import de.effigenix.shared.common.Result;
 import org.springframework.context.annotation.Profile;
 import org.springframework.stereotype.Repository;
 
+import java.time.LocalDate;
 import java.util.List;
 import java.util.Optional;
 
@@ -28,6 +30,21 @@ public class StubProductionOrderRepository implements ProductionOrderRepository
         return Result.failure(STUB_ERROR);
     }
 
+    @Override
+    public Result<RepositoryError, List<ProductionOrder>> findByDateRange(LocalDate from, LocalDate to) {
+        return Result.failure(STUB_ERROR);
+    }
+
+    @Override
+    public Result<RepositoryError, List<ProductionOrder>> findByStatus(ProductionOrderStatus status) {
+        return Result.failure(STUB_ERROR);
+    }
+
+    @Override
+    public Result<RepositoryError, List<ProductionOrder>> findByDateRangeAndStatus(LocalDate from, LocalDate to, ProductionOrderStatus status) {
+        return Result.failure(STUB_ERROR);
+    }
+
     @Override
     public Result<RepositoryError, Void> save(ProductionOrder productionOrder) {
         return Result.failure(STUB_ERROR);