header:
{  
   "id"        :    "1bd92ce5-b419-4adc-879f-19b20c1bf9e0",

   "ns"        :    "jugsaxony",
   "type"      :    "camp.jugsaxony.es.event.cart.LineItemAdded",

   "aggIds"    :    [  
                      "5c000000-0000-0000-0000-000000000001"
                    ]
}

payload:
{  
   "cartId"    :    "5c000000-0000-0000-0000-000000000001",
   "customerId":    "c0000000-0000-0000-0000-000000000001",
   "articleId" :    "a0000000-0000-0000-0000-000000000002",
   "quantity"  :    2
}

@Builder @Getter
public class LineItemAdded implements Event{

    UUID customerId; // not stricly necessary, but helpful Context information

    @AggregateId
    UUID cartId;

    UUID articleId;

    int quantity;
}

LineItemAdded event = new LineItemAdded()
                .articleId(tshirtId)
                .cartId(cartId)
                .customerId(customerId)
                .quantity(2);

eventStore.publish( Util.toFact(event) );

@Data
public class Cart {
    final UUID customerId;
    final UUID cartId;
    final Map<UUID, LineItem> lineItems = new HashMap<>();
    boolean closed = false;
}

@Data
public class LineItem {
    final UUID articleId;
    int quantity = 1;
}

class CartReadModel extends PullReadModel {

    @Getter private Cart cart;

    CartReadModel(FactCast eventStore, UUID cartId) {
        super(eventStore,()->FactSpec.ns("jugsaxony").aggId(cartId));
        cart = new Cart(cartId);
    }

    public void apply(LineItemAdded event) {
        LineItem li = new LineItem(event.getArticleId());
        li.setQuantity(event.getQuantity());
        cart.getLineItems().put(li.getArticleId(), li);
    }

    public void apply(LineItemRemoved event) {
        cart.getLineItems().remove(event.getArticleId());
    }

    public void apply(LineItemQuantityChanged fact) {
        cart.getLineItems().get(fact.getArticleId()).setQuantity(fact.getQuantity());
    }

    public void apply(CheckoutStarted event) {
        cart.setClosed(true);
    }
}

public class PullReadModel extends ReadModel {

    public PullReadModel(FactCast eventStore, Supplier<FactSpec> spec) {
        super(eventStore, spec);
    }

    private void pullFromScratch() {

        eventStore.subscribeToFacts(
            SubscriptionRequest.catchup(factsOfInterest).fromScratch(),
            this)
            .awaitComplete();
    }
    //...
}
            

public interface CartRepository {
    Cart findByCartId(UUID cartId);
}

@Component @RequiredArgsConstructor
public class CartRepositoryImpl implements CartRepository {
    final FactCast eventStore;

    @Override
    public Cart findByCartId(UUID cartId) {
        return new CartReadModel(eventStore, cartId).pull();
    }
}
            
            
            

@Service @RequiredArgsConstructor
public class CartSnapshotRepositoryImpl implements CartRepository {

    final FactCast eventStore;

    final Map<UUID, CartReadModel> modelCache = new LRUMap<>();

    @Override
    public Cart findByCartId(UUID cartId) {
        CartReadModel readModel = modelCache.computeIfAbsent(cartId, 
            id -> new CartReadModel( eventStore, id ) );
        readModel.pull();
        return readModel.getCart();
    }

}

@Service
public class RecommendedArticles extends PushReadModel {

    final Map<UUID, Set<UUID>> recommendedArticlesByCustomer = 
            new ConcurrentHashMap<>();

    public void apply(LineItemRemoved event) {
        Set<UUID> list = getForCustomer(event.getCustomerId());
        list.add(event.getArticleId());
    }

    public void apply(CheckoutStarted event) {
        List<UUID> articlesInCart = event.getLineItems()
                .stream()
                .map(LineItem::getArticleId)
                .collect(Collectors.toList());
        Set<UUID> list = getForCustomer(event.getCustomerId());
        list.removeAll(articlesInCart);
    }
    // ...
}

public class PushReadModel extends ReadModel implements SmartInitializingSingleton {

    public PushReadModel(FactCast eventStore, Supplier<FactSpec> spec) {
        super(eventStore, spec);
    }

    @Override
    public void afterSingletonsInstantiated() {
 
       eventStore.subscribeToFacts(
                SubscriptionRequest.follow(factsOfInterest).fromScratch(), this);
 
   }
}
            
            

@service @RequiredArgsConstructor public class CartService {

    public void addToCart(UUID cartId, UUID articleId, UUID customerId, int quantity) {
        // acquire necessary locks

        Cart currentCart = cartRepo.findByCartId(cartId);
        if (currentCart.isClosed()) {
            throw new IllegalStateException("Already closed");
        }

        if (currentCart.getLineItems().containsKey(articleId)) {

            // increaseQuantity of the corresponding LineItem;
            LineItem lineItem = currentCart.getLineItems().get(articleId);
            LineItemQuantityChanged event = new LineItemQuantityChanged()...
            eventStore.publish(Util.toFact(event));

        } else {

            // add new LineItem
            LineItemAdded event = new LineItemAdded()...
            eventStore.publish(Util.toFact(event));

        }
        // release locks
    }
    // ...
}