Sipariş API'sini sıfırdan yaz

// ===== DTO'lar =====
public record CreateOrderRequest(
        @NotNull Long customerId,
        @NotEmpty List<@Valid OrderItemRequest> items) {}

public record OrderItemRequest(
        @NotNull Long productId,
        @Positive int quantity) {}

public record OrderResponse(Long id, Long customerId, String status, BigDecimal total, List<OrderLineResponse> lines) {
    static OrderResponse from(Order o) { /* mapping */ }
}

// ===== OrderController.java =====
@RestController
@RequestMapping("/api/v1/orders")
public class OrderController {

    private final OrderService orderService;

    public OrderController(OrderService orderService) { this.orderService = orderService; }

    @PostMapping
    public ResponseEntity<OrderResponse> create(
            @RequestHeader(name = "Idempotency-Key", required = false) String idempotencyKey,
            @Valid @RequestBody CreateOrderRequest request) {
        OrderResponse created = orderService.create(request, idempotencyKey);
        return ResponseEntity.created(URI.create("/api/v1/orders/" + created.id())).body(created);
    }

    @GetMapping("/{id}")
    public OrderResponse get(@PathVariable long id) {
        return orderService.get(id);
    }
}

// ===== OrderService.java =====
@Service
public class OrderService {

    private final OrderRepository orderRepository;
    private final ProductRepository productRepository;

    public OrderService(OrderRepository orderRepository, ProductRepository productRepository) {
        this.orderRepository = orderRepository;
        this.productRepository = productRepository;
    }

    @Transactional
    public OrderResponse create(CreateOrderRequest request, String idempotencyKey) {
        if (idempotencyKey != null) {
            Optional<Order> existing = orderRepository.findByIdempotencyKey(idempotencyKey);
            if (existing.isPresent()) return OrderResponse.from(existing.get());   // tekrar istek: aynı cevap
        }

        Set<Long> ids = request.items().stream().map(OrderItemRequest::productId).collect(Collectors.toSet());
        Map<Long, Product> products = productRepository.findAllById(ids).stream()     // tek sorgu
                .collect(Collectors.toMap(Product::getId, Function.identity()));
        Set<Long> missing = new HashSet<>(ids);
        missing.removeAll(products.keySet());
        if (!missing.isEmpty()) throw new ProductNotFoundException(missing);

        Order order = Order.create(request.customerId(), idempotencyKey);
        for (OrderItemRequest item : request.items()) {
            Product p = products.get(item.productId());
            order.addLine(p.getId(), p.getPrice(), item.quantity());                  // fiyat DB'den
        }
        // orders.idempotency_key UNIQUE: eşzamanlı iki aynı istekten biri constraint hatası alır
        return OrderResponse.from(orderRepository.save(order));
    }

    @Transactional(readOnly = true)
    public OrderResponse get(long id) {
        return orderRepository.findById(id).map(OrderResponse::from)
                .orElseThrow(() -> new OrderNotFoundException(id));
    }
}

// ===== GlobalExceptionHandler.java =====
@RestControllerAdvice
class GlobalExceptionHandler {

    @ExceptionHandler(MethodArgumentNotValidException.class)
    ProblemDetail validation(MethodArgumentNotValidException e) {
        ProblemDetail pd = ProblemDetail.forStatusAndDetail(HttpStatus.BAD_REQUEST, "Validation failed");
        pd.setProperty("errors", e.getBindingResult().getFieldErrors().stream()
                .map(f -> Map.of("field", f.getField(), "message", String.valueOf(f.getDefaultMessage())))
                .toList());
        return pd;
    }

    @ExceptionHandler(OrderNotFoundException.class)
    ProblemDetail orderNotFound(OrderNotFoundException e) {
        return ProblemDetail.forStatusAndDetail(HttpStatus.NOT_FOUND, e.getMessage());
    }

    @ExceptionHandler(ProductNotFoundException.class)
    ProblemDetail productNotFound(ProductNotFoundException e) {
        return ProblemDetail.forStatusAndDetail(HttpStatus.UNPROCESSABLE_ENTITY, e.getMessage());
    }

    @ExceptionHandler(DataIntegrityViolationException.class)
    ProblemDetail conflict(DataIntegrityViolationException e) {
        return ProblemDetail.forStatusAndDetail(HttpStatus.CONFLICT, "Duplicate request");
    }
}