public void doIt(OrderRequest r) {
    if (r != null && r.items() != null && r.items().size() > 0) {
        double t = 0;
        for (var i : r.items()) {
            if (i.price() > 0 && i.qty() > 0) {
                t += i.price() * i.qty();
            }
        }
        if (r.vip()) {
            t = t * 0.9;
        }
        repo.save(new OrderEntity(r.customerId(), t, "NEW"));
    }
}

public OrderId placeOrder(PlaceOrderCommand command) {
    var draft = orderDraftFactory.from(command);
    var pricedOrder = pricingService.price(draft);
    var order = Order.place(pricedOrder);
    orderRepository.save(order);
    return order.id();
}

public class Order {
    public List<OrderLine> lines;
    public String status;
    public BigDecimal total;
}

public class OrderService {
    public void cancel(Order order) {
        if (order.status.equals("SHIPPED")) {
            throw new IllegalStateException("too late");
        }
        order.status = "CANCELLED";
    }
}

public final class Order {
    private final OrderId id;
    private final List<OrderLine> lines;
    private OrderStatus status;

    public void cancel() {
        if (status == OrderStatus.SHIPPED) {
            throw new OrderAlreadyShippedException(id);
        }
        status = OrderStatus.CANCELLED;
    }
}

public final class Money {
    private final BigDecimal amount;
    private final Currency currency;

    private Money(BigDecimal amount, Currency currency) {
        if (amount.scale() > 2) {
            throw new IllegalArgumentException("Money supports max 2 decimals");
        }
        this.amount = amount;
        this.currency = Objects.requireNonNull(currency);
    }

    public static Money eur(String amount) {
        return new Money(new BigDecimal(amount), Currency.getInstance("EUR"));
    }

    public static Money of(BigDecimal amount, Currency currency) {
        return new Money(amount, currency);
    }
}

Order order = Order.builder()
    .customerId(customerId)
    .addLine(productId, Quantity.of(2), Money.eur("19.90"))
    .discountCode("SUMMER10")
    .build();

public record PlaceOrderCommand(
    CustomerId customerId,
    List<PlaceOrderLine> lines,
    Optional<String> discountCode
) {
    public PlaceOrderCommand {
        Objects.requireNonNull(customerId);
        lines = List.copyOf(lines);
        if (lines.isEmpty()) {
            throw new IllegalArgumentException("Order must contain at least one line");
        }
    }
}

public Optional<Customer> findByEmail(Email email) {
    return customerRepository.findByEmail(email);
}

public void sendInvoice(Optional<Order> order) { // nicht als Parameter erzwingen
    order.ifPresent(this::sendInvoice);
}

public final class OrderAlreadyShippedException extends RuntimeException {
    public OrderAlreadyShippedException(OrderId id) {
        super("Order " + id.value() + " is already shipped and cannot be cancelled");
    }
}

try (var stream = Files.lines(path)) {
    return stream.filter(line -> !line.isBlank()).toList();
}

public enum OrderStatus {
    NEW {
        @Override boolean canCancel() { return true; }
    },
    PAID {
        @Override boolean canCancel() { return true; }
    },
    SHIPPED {
        @Override boolean canCancel() { return false; }
    };

    abstract boolean canCancel();
}

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    var payment = executor.submit(() -> paymentClient.authorize(order));
    var inventory = executor.submit(() -> inventoryClient.reserve(order));

    return new CheckoutResult(payment.get(), inventory.get());
}

public interface DiscountPolicy {
    Money apply(OrderDraft order);
}

public final class VipDiscountPolicy implements DiscountPolicy {
    public Money apply(OrderDraft order) {
        return order.subtotal().multiply("0.10");
    }
}

public final class NoDiscountPolicy implements DiscountPolicy {
    public Money apply(OrderDraft order) {
        return Money.zero(order.currency());
    }
}

public PricedOrder price(OrderDraft draft, DiscountPolicy discountPolicy) {
    Money discount = discountPolicy.apply(draft);
    return new PricedOrder(draft, draft.subtotal().minus(discount));
}

public final class PaymentProviderFactory {
    public PaymentProvider providerFor(PaymentMethod method) {
        return switch (method) {
            case CARD -> new CardPaymentProvider();
            case PAYPAL -> new PaypalPaymentProvider();
            case INVOICE -> new InvoicePaymentProvider();
        };
    }
}

public final class StripePaymentAdapter implements PaymentPort {
    private final StripeClient client;

    public PaymentResult authorize(PaymentRequest request) {
        StripeResponse response = client.charge(toStripeRequest(request));
        return toPaymentResult(response);
    }
}

public record OrderPlaced(OrderId orderId, CustomerId customerId) implements DomainEvent {}

public final class Order {
    private final List<DomainEvent> events = new ArrayList<>();

    public static Order place(PricedOrder pricedOrder) {
        Order order = new Order(pricedOrder);
        order.events.add(new OrderPlaced(order.id, order.customerId));
        return order;
    }
}

public final class PlaceOrderService {
    private final OrderRepository orders;
    private final PricingService pricing;
    private final TransactionRunner tx;

    public OrderId place(PlaceOrderCommand command) {
        return tx.inTransaction(() -> {
            var draft = OrderDraft.from(command);
            var order = Order.place(pricing.price(draft));
            orders.save(order);
            return order.id();
        });
    }
}

public interface OrderRepository {
    Optional<Order> findById(OrderId id);
    void save(Order order);
}

public record PlaceOrderRequest(String customerId, List<LineRequest> lines) {}
public record PlaceOrderResponse(String orderId) {}

package com.seb4u.demo.spring.api;

import jakarta.validation.Valid;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Positive;
import jakarta.validation.constraints.Size;
import java.util.List;

public record PlaceOrderRequest(
    @NotBlank @Size(max = 80) String customerId,
    @NotBlank @Size(max = 80) String idempotencyKey,
    @NotBlank @Size(max = 3) String currency,
    @Valid @NotEmpty @Size(max = 100) List<LineRequest> lines,
    @Size(max = 40) String couponCode
) {
    public record LineRequest(
        @NotBlank @Size(max = 80) String productId,
        @Positive int quantity,
        @NotNull MoneyRequest unitPrice
    ) {}

    public record MoneyRequest(
        @NotBlank String amount,
        @NotBlank @Size(max = 3) String currency
    ) {}
}

package com.seb4u.demo.spring.api;

import com.seb4u.demo.spring.application.IdempotencyKey;
import com.seb4u.demo.spring.application.PlaceOrderCommand;
import com.seb4u.demo.spring.domain.CustomerId;
import com.seb4u.demo.spring.domain.Money;
import com.seb4u.demo.spring.domain.OrderLineDraft;
import com.seb4u.demo.spring.domain.ProductId;
import java.util.Currency;

final class PlaceOrderApiMapper {
    private PlaceOrderApiMapper() {}

    static PlaceOrderCommand toCommand(PlaceOrderRequest request, String authenticatedUserId) {
        var currency = Currency.getInstance(request.currency());

        var lines = request.lines().stream()
            .map(line -> new OrderLineDraft(
                new ProductId(line.productId()),
                line.quantity(),
                new Money(line.unitPrice().amount(), Currency.getInstance(line.unitPrice().currency()))
            ))
            .toList();

        return new PlaceOrderCommand(
            new CustomerId(request.customerId()),
            authenticatedUserId,
            new IdempotencyKey(request.idempotencyKey()),
            currency,
            lines,
            request.couponCode()
        );
    }
}

package com.seb4u.demo.spring.api;

import com.seb4u.demo.spring.application.PlaceOrderUseCase;
import jakarta.validation.Valid;
import java.net.URI;
import org.springframework.http.ResponseEntity;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api/orders")
public final class OrderController {
    private final PlaceOrderUseCase placeOrder;

    public OrderController(PlaceOrderUseCase placeOrder) {
        this.placeOrder = placeOrder;
    }

    @PostMapping
    public ResponseEntity<OrderResponse> place(
        @Valid @RequestBody PlaceOrderRequest request,
        @AuthenticationPrincipal(expression = "name") String userId
    ) {
        var command = PlaceOrderApiMapper.toCommand(request, userId);
        var result = placeOrder.place(command);
        var response = OrderResponse.from(result);

        return ResponseEntity
            .created(URI.create("/api/orders/" + response.orderId()))
            .body(response);
    }
}

// file: PlaceOrderCommand.java
package com.seb4u.demo.spring.application;

import com.seb4u.demo.spring.domain.CustomerId;
import com.seb4u.demo.spring.domain.OrderLineDraft;
import java.util.Currency;
import java.util.List;

public record PlaceOrderCommand(
    CustomerId customerId,
    String authenticatedUserId,
    IdempotencyKey idempotencyKey,
    Currency currency,
    List<OrderLineDraft> lines,
    String couponCode
) {
    public PlaceOrderCommand {
        if (lines == null || lines.isEmpty()) {
            throw new IllegalArgumentException("Order must contain at least one line");
        }
        lines = List.copyOf(lines);
    }
}

// file: IdempotencyKey.java
package com.seb4u.demo.spring.application;

public record IdempotencyKey(String value) {
    public IdempotencyKey {
        if (value == null || value.isBlank() || value.length() > 80) {
            throw new IllegalArgumentException("Invalid idempotency key");
        }
    }
}

package com.seb4u.demo.spring.application;

public interface PlaceOrderUseCase {
    PlaceOrderResult place(PlaceOrderCommand command);
}

package com.seb4u.demo.spring.application;

import com.seb4u.demo.spring.application.ports.CustomerAccessPolicy;
import com.seb4u.demo.spring.application.ports.OrderRepository;
import com.seb4u.demo.spring.application.ports.OutboxWriter;
import com.seb4u.demo.spring.application.ports.PaymentPort;
import com.seb4u.demo.spring.application.ports.ProductCatalogPort;
import com.seb4u.demo.spring.domain.Order;
import com.seb4u.demo.spring.domain.OrderId;
import com.seb4u.demo.spring.domain.OrderPricing;
import com.seb4u.demo.spring.shared.BusinessException;
import com.seb4u.demo.spring.shared.ErrorCode;
import java.time.Clock;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public final class PlaceOrderService implements PlaceOrderUseCase {
    private final CustomerAccessPolicy accessPolicy;
    private final ProductCatalogPort productCatalog;
    private final PaymentPort payment;
    private final OrderRepository orders;
    private final OutboxWriter outbox;
    private final Clock clock;

    public PlaceOrderService(
        CustomerAccessPolicy accessPolicy,
        ProductCatalogPort productCatalog,
        PaymentPort payment,
        OrderRepository orders,
        OutboxWriter outbox,
        Clock clock
    ) {
        this.accessPolicy = accessPolicy;
        this.productCatalog = productCatalog;
        this.payment = payment;
        this.orders = orders;
        this.outbox = outbox;
        this.clock = clock;
    }

    @Override
    @Transactional
    public PlaceOrderResult place(PlaceOrderCommand command) {
        accessPolicy.assertCanPlaceOrder(command.authenticatedUserId(), command.customerId());

        var existing = orders.findByIdempotencyKey(command.customerId(), command.idempotencyKey());
        if (existing.isPresent()) {
            return PlaceOrderResult.alreadyAccepted(existing.get().id(), existing.get().status());
        }

        var catalogSnapshot = productCatalog.snapshotFor(command.lines());
        var pricing = OrderPricing.from(command.lines(), catalogSnapshot, command.currency(), command.couponCode());

        var order = Order.place(
            OrderId.newId(),
            command.customerId(),
            command.idempotencyKey().value(),
            pricing,
            clock.instant()
        );

        var authorization = payment.authorize(order.paymentRequest());
        order.markPaymentAuthorized(authorization.authorizationId(), clock.instant());

        orders.save(order);
        outbox.append(order.pullDomainEvents());

        return PlaceOrderResult.accepted(order.id(), order.status(), order.total());
    }
}

package com.seb4u.demo.spring.domain;

import com.seb4u.demo.spring.shared.BusinessException;
import com.seb4u.demo.spring.shared.ErrorCode;
import java.time.Instant;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

public final class Order {
    private final OrderId id;
    private final CustomerId customerId;
    private final String idempotencyKey;
    private final List<OrderLine> lines;
    private final List<DomainEvent> events = new ArrayList<>();
    private OrderStatus status;
    private Money total;
    private String paymentAuthorizationId;

    private Order(OrderId id, CustomerId customerId, String idempotencyKey, List<OrderLine> lines, Money total) {
        this.id = Objects.requireNonNull(id);
        this.customerId = Objects.requireNonNull(customerId);
        this.idempotencyKey = requireText(idempotencyKey, "idempotencyKey");
        this.lines = List.copyOf(lines);
        this.total = Objects.requireNonNull(total);
        this.status = OrderStatus.PENDING_PAYMENT;

        if (this.lines.isEmpty()) {
            throw new BusinessException(ErrorCode.EMPTY_ORDER, "Order must contain at least one line");
        }
    }

    public static Order place(OrderId id, CustomerId customerId, String idempotencyKey, OrderPricing pricing, Instant occurredAt) {
        var order = new Order(id, customerId, idempotencyKey, pricing.lines(), pricing.total());
        order.events.add(new OrderPlaced(id.value(), customerId.value(), pricing.total().amount(), occurredAt));
        return order;
    }

    public void markPaymentAuthorized(String authorizationId, Instant occurredAt) {
        if (status != OrderStatus.PENDING_PAYMENT) {
            throw new BusinessException(ErrorCode.INVALID_ORDER_STATE, "Only pending orders can be paid");
        }
        this.paymentAuthorizationId = requireText(authorizationId, "authorizationId");
        this.status = OrderStatus.PAID;
        this.events.add(new OrderPaymentAuthorized(id.value(), authorizationId, total.amount(), occurredAt));
    }

    public void cancel(String reason, Instant occurredAt) {
        if (!status.canBeCancelled()) {
            throw new BusinessException(ErrorCode.INVALID_ORDER_STATE, "Order cannot be cancelled from " + status);
        }
        this.status = OrderStatus.CANCELLED;
        this.events.add(new OrderCancelled(id.value(), reason, occurredAt));
    }

    public PaymentRequest paymentRequest() {
        if (status != OrderStatus.PENDING_PAYMENT) {
            throw new BusinessException(ErrorCode.INVALID_ORDER_STATE, "Payment request already consumed");
        }
        return new PaymentRequest(id.value(), customerId.value(), total.amount(), total.currency());
    }

    public List<DomainEvent> pullDomainEvents() {
        var copy = List.copyOf(events);
        events.clear();
        return copy;
    }

    public OrderId id() { return id; }
    public CustomerId customerId() { return customerId; }
    public OrderStatus status() { return status; }
    public Money total() { return total; }

    private static String requireText(String value, String field) {
        if (value == null || value.isBlank()) {
            throw new IllegalArgumentException(field + " must not be blank");
        }
        return value;
    }
}

package com.seb4u.demo.spring.domain;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Currency;
import java.util.Objects;

public record Money(BigDecimal amount, Currency currency) implements Comparable<Money> {
    public Money(String amount, Currency currency) {
        this(new BigDecimal(amount), currency);
    }

    public Money {
        Objects.requireNonNull(amount, "amount");
        Objects.requireNonNull(currency, "currency");
        amount = amount.setScale(currency.getDefaultFractionDigits(), RoundingMode.HALF_EVEN);
        if (amount.signum() < 0) {
            throw new IllegalArgumentException("Money must not be negative");
        }
    }

    public Money add(Money other) {
        assertSameCurrency(other);
        return new Money(amount.add(other.amount), currency);
    }

    public Money multiply(int factor) {
        if (factor < 0) {
            throw new IllegalArgumentException("factor must not be negative");
        }
        return new Money(amount.multiply(BigDecimal.valueOf(factor)), currency);
    }

    public Money percentage(String percent) {
        var ratio = new BigDecimal(percent).movePointLeft(2);
        return new Money(amount.multiply(ratio), currency);
    }

    private void assertSameCurrency(Money other) {
        if (!currency.equals(other.currency)) {
            throw new IllegalArgumentException("Currency mismatch: " + currency + " != " + other.currency);
        }
    }

    @Override
    public int compareTo(Money other) {
        assertSameCurrency(other);
        return amount.compareTo(other.amount);
    }
}

package com.seb4u.demo.spring.application.ports;

import com.seb4u.demo.spring.application.IdempotencyKey;
import com.seb4u.demo.spring.domain.CustomerId;
import com.seb4u.demo.spring.domain.Order;
import com.seb4u.demo.spring.domain.OrderId;
import java.util.Optional;

public interface OrderRepository {
    Optional<Order> findById(OrderId id);
    Optional<Order> findByIdempotencyKey(CustomerId customerId, IdempotencyKey key);
    void save(Order order);
}

package com.seb4u.demo.spring.application.ports;

import com.seb4u.demo.spring.domain.DomainEvent;
import java.util.List;

public interface OutboxWriter {
    void append(List<DomainEvent> events);
}

package com.seb4u.demo.spring.application.ports;

import com.seb4u.demo.spring.domain.PaymentAuthorization;
import com.seb4u.demo.spring.domain.PaymentRequest;

public interface PaymentPort {
    PaymentAuthorization authorize(PaymentRequest request);
}

package com.seb4u.demo.spring.infrastructure.persistence;

import com.seb4u.demo.spring.application.IdempotencyKey;
import com.seb4u.demo.spring.application.ports.OrderRepository;
import com.seb4u.demo.spring.domain.CustomerId;
import com.seb4u.demo.spring.domain.Order;
import com.seb4u.demo.spring.domain.OrderId;
import java.util.Optional;
import org.springframework.stereotype.Repository;

@Repository
public final class JpaOrderRepository implements OrderRepository {
    private final SpringDataOrderJpaRepository jpa;
    private final OrderPersistenceMapper mapper;

    public JpaOrderRepository(SpringDataOrderJpaRepository jpa, OrderPersistenceMapper mapper) {
        this.jpa = jpa;
        this.mapper = mapper;
    }

    @Override
    public Optional<Order> findById(OrderId id) {
        return jpa.findById(id.value()).map(mapper::toDomain);
    }

    @Override
    public Optional<Order> findByIdempotencyKey(CustomerId customerId, IdempotencyKey key) {
        return jpa.findByCustomerIdAndIdempotencyKey(customerId.value(), key.value()).map(mapper::toDomain);
    }

    @Override
    public void save(Order order) {
        jpa.save(mapper.toEntity(order));
    }
}

package com.seb4u.demo.spring.infrastructure.outbox;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.seb4u.demo.spring.application.ports.OutboxWriter;
import com.seb4u.demo.spring.domain.DomainEvent;
import java.time.Clock;
import java.util.List;
import java.util.UUID;
import org.springframework.jdbc.core.simple.JdbcClient;
import org.springframework.stereotype.Component;

@Component
public final class JdbcOutboxWriter implements OutboxWriter {
    private final JdbcClient jdbc;
    private final ObjectMapper objectMapper;
    private final Clock clock;

    public JdbcOutboxWriter(JdbcClient jdbc, ObjectMapper objectMapper, Clock clock) {
        this.jdbc = jdbc;
        this.objectMapper = objectMapper;
        this.clock = clock;
    }

    @Override
    public void append(List<DomainEvent> events) {
        for (var event : events) {
            jdbc.sql("""
                insert into outbox_event(id, aggregate_id, event_type, payload, occurred_at, published_at)
                values (:id, :aggregateId, :eventType, cast(:payload as jsonb), :occurredAt, null)
                """)
                .param("id", UUID.randomUUID())
                .param("aggregateId", event.aggregateId())
                .param("eventType", event.eventType())
                .param("payload", toJson(event))
                .param("occurredAt", event.occurredAt(clock))
                .update();
        }
    }

    private String toJson(DomainEvent event) {
        try {
            return objectMapper.writeValueAsString(event);
        } catch (Exception ex) {
            throw new IllegalStateException("Could not serialize domain event " + event.eventType(), ex);
        }
    }
}

// file: ErrorCode.java
package com.seb4u.demo.spring.shared;

public enum ErrorCode {
    EMPTY_ORDER,
    INVALID_ORDER_STATE,
    PAYMENT_DECLINED,
    PRODUCT_NOT_FOUND,
    ACCESS_DENIED,
    IDEMPOTENCY_CONFLICT
}

// file: BusinessException.java
package com.seb4u.demo.spring.shared;

public final class BusinessException extends RuntimeException {
    private final ErrorCode code;

    public BusinessException(ErrorCode code, String message) {
        super(message);
        this.code = code;
    }

    public ErrorCode code() {
        return code;
    }
}

package com.seb4u.demo.spring.api;

import com.seb4u.demo.spring.shared.BusinessException;
import java.net.URI;
import org.springframework.http.HttpStatus;
import org.springframework.http.ProblemDetail;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice
public final class ApiExceptionHandler {
    @ExceptionHandler(BusinessException.class)
    ProblemDetail handleBusiness(BusinessException ex) {
        var status = switch (ex.code()) {
            case ACCESS_DENIED -> HttpStatus.FORBIDDEN;
            case PRODUCT_NOT_FOUND -> HttpStatus.NOT_FOUND;
            case PAYMENT_DECLINED, IDEMPOTENCY_CONFLICT, INVALID_ORDER_STATE, EMPTY_ORDER -> HttpStatus.CONFLICT;
        };
        var problem = ProblemDetail.forStatusAndDetail(status, ex.getMessage());
        problem.setType(URI.create("https://orderflow.dev/problems/" + ex.code().name().toLowerCase()));
        problem.setTitle(ex.code().name());
        problem.setProperty("code", ex.code().name());
        return problem;
    }

    @ExceptionHandler(MethodArgumentNotValidException.class)
    ProblemDetail handleValidation(MethodArgumentNotValidException ex) {
        var problem = ProblemDetail.forStatusAndDetail(HttpStatus.BAD_REQUEST, "Request validation failed");
        var fields = ex.getBindingResult().getFieldErrors().stream()
            .map(error -> error.getField() + ": " + error.getDefaultMessage())
            .toList();
        problem.setProperty("fields", fields);
        return problem;
    }
}

package com.seb4u.demo.spring.domain;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;

import java.time.Instant;
import org.junit.jupiter.api.Test;

class OrderTest {
    @Test
    void paidOrderCannotBePaidTwice() {
        var order = TestOrders.pendingOrder();

        order.markPaymentAuthorized("auth-1", Instant.parse("2026-01-01T10:00:00Z"));

        assertThatThrownBy(() -> order.markPaymentAuthorized("auth-2", Instant.parse("2026-01-01T10:01:00Z")))
            .isInstanceOf(BusinessException.class)
            .hasMessageContaining("Only pending orders can be paid");
    }

    @Test
    void placingOrderRaisesOrderPlacedEvent() {
        var order = TestOrders.pendingOrder();

        var events = order.pullDomainEvents();

        assertThat(events).hasExactlyElementsOfTypes(OrderPlaced.class);
        assertThat(order.pullDomainEvents()).isEmpty();
    }
}

package com.seb4u.demo.spring.application;

import static org.assertj.core.api.Assertions.assertThat;

import java.time.Clock;
import java.time.Instant;
import java.time.ZoneOffset;
import org.junit.jupiter.api.Test;

class PlaceOrderServiceTest {
    @Test
    void secondRequestWithSameIdempotencyKeyReturnsExistingOrder() {
        var orders = new InMemoryOrderRepository();
        var outbox = new RecordingOutboxWriter();
        var service = new PlaceOrderService(
            new AllowAllCustomerAccessPolicy(),
            new StubProductCatalogPort(),
            new AlwaysAuthorizedPaymentPort(),
            orders,
            outbox,
            Clock.fixed(Instant.parse("2026-01-01T10:00:00Z"), ZoneOffset.UTC)
        );
        var command = TestCommands.placeOrder("idem-123");

        var first = service.place(command);
        var second = service.place(command);

        assertThat(second.orderId()).isEqualTo(first.orderId());
        assertThat(second.acceptance()).isEqualTo(OrderAcceptance.ALREADY_ACCEPTED);
        assertThat(outbox.recordedEvents()).hasSize(2); // placed + payment-authorized only once
    }
}