EventCatalog | Events | Placed Order

Overview

The PlaceOrderCommand is a critical domain command that initiates the order creation process in the BookWorm e-commerce system. This command serves as the bridge between the Basket and Ordering bounded contexts, facilitating the transition from a transient shopping basket to a persistent order.

Purpose

Initiates the order creation process
Transfers basket data to the ordering system
Triggers the deletion of the original basket
Ensures atomic transaction between basket deletion and order creation

Command Structure

{
  "basketId": "Guid",
  "email": "string?",
  "orderId": "Guid",
  "totalMoney": "decimal"
}

Behavior

When this command is processed:

The system attempts to delete the specified basket
Upon successful deletion, a BasketDeletedCompleteIntegrationEvent is published
If deletion fails, a BasketDeletedFailedIntegrationEvent is published
The command handler ensures concurrent message processing is limited to 1 message at a time

Integration Points

Channel: basket-place-order
Concurrency: Limited to 1 concurrent message
Related Events:
- BasketDeletedCompleteIntegrationEvent
- BasketDeletedFailedIntegrationEvent

Usage Context

This command is typically triggered when:

A customer completes their shopping cart
The checkout process is initiated
The system needs to transition from basket to order state

Error Handling

The command includes built-in error handling:

Tracks failed basket deletions
Maintains order creation state
Provides feedback through integration events

Architecture

Producing

Select the language you want to produce the event in to see an example.

public class BasketProducer
{
    private readonly IPublishEndpoint _publishEndpoint;

    public BasketService(IPublishEndpoint publishEndpoint)
    {
        _publishEndpoint = publishEndpoint;
    }

    public async Task PlaceOrderAsync(Guid basketId, string email, decimal totalMoney)
    {
        var command = new PlaceOrderCommand(
            BasketId: basketId,
            Email: email,
            OrderId: Guid.NewGuid(),
            TotalMoney: totalMoney
        );

        await _publishEndpoint.Publish(command);
    }
}

@Injectable()
export class BasketProducer {
    constructor(
        @Inject('RABBITMQ_CONNECTION')
        private readonly connection: Connection
    ) {}

    async placeOrder(basketId: string, email: string, totalMoney: number) {
        const channel = await this.connection.createChannel();
        const command: PlaceOrderCommand = {
        basketId,
        email,
        orderId: uuidv4(),
        totalMoney
      }
      await channel.publish(
        'basket-exchange',
        'basket.place-order',
        Buffer.from(JSON.stringify(command))
      );
    }
}

@Service
public class BasketProducer {
    private final RabbitTemplate rabbitTemplate;

    public BasketService(RabbitTemplate rabbitTemplate) {
        this.rabbitTemplate = rabbitTemplate;
    }

    public void placeOrder(UUID basketId, String email, BigDecimal totalMoney) {
        PlaceOrderCommand command = new PlaceOrderCommand(
            basketId,
            email,
            UUID.randomUUID(),
            totalMoney
        );
        rabbitTemplate.convertAndSend(
            "basket-exchange",
            "basket.place-order",
            command
        );
    }
}

Consuming

Select the language you want to consume the event in to see an example.

public class OrderConsumer : IConsumer<PlaceOrderCommand>
{
    private readonly IBasketRepository _repository;
    private readonly IPublishEndpoint _publishEndpoint;

    public OrderConsumer(IBasketRepository repository, IPublishEndpoint publishEndpoint)
    {
        _repository = repository;
        _publishEndpoint = publishEndpoint;
    }

    public async Task Consume(ConsumeContext<PlaceOrderCommand> context)
    {
        var command = context.Message;

        var basketDeleted = await _repository.DeleteBasketAsync(command.BasketId.ToString());

        if (!basketDeleted)
        {
            await _publishEndpoint.Publish(
                new BasketDeletedFailedIntegrationEvent(command.OrderId, command.BasketId, command.Email, command.TotalMoney)
            );
        }
        else
        {
            await _publishEndpoint.Publish(
                new BasketDeletedCompleteIntegrationEvent(command.OrderId, command.BasketId, command.TotalMoney)
            );
        }
    }
}

@Injectable()
export class OrderConsumer {
    constructor(
        @Inject('BASKET_REPOSITORY')
        private readonly basketRepository: BasketRepository,
        @Inject('RABBITMQ_CONNECTION')
        private readonly connection: Connection
    ) {
        this.initializeConsumer();
    }

    private async initializeConsumer() {
        const channel = await this.connection.createChannel();
        await channel.assertQueue('basket-place-order-queue');

        await channel.consume('basket-place-order-queue', async (msg) => {
            if (msg) {
                try {
                    const command: PlaceOrderCommand = JSON.parse(msg.content.toString());
                    const basketDeleted = await this.basketRepository.deleteBasket(command.basketId);

                    if (!basketDeleted) {
                        await this.publishFailedEvent(
                            command.orderId,
                            command.basketId,
                            command.email,
                            command.totalMoney
                        );
                    } else {
                        await this.publishCompletedEvent(
                            command.orderId,
                            command.basketId,
                            command.totalMoney
                        );
                    }

                    channel.ack(msg);
                } catch (error) {
                    channel.nack(msg, false, true);
                }
            }
        });
    }

    private async publishCompletedEvent(
        orderId: string,
        basketId: string,
        totalMoney: number
    ): Promise<void> {
        const channel = await this.connection.createChannel();
        const event = new BasketDeletedCompleteIntegrationEvent(
            orderId,
            basketId,
            totalMoney
        );

        await channel.publish(
            'basket-exchange',
            'basket-checkout-complete',
            Buffer.from(JSON.stringify(event))
        );
    }

    private async publishFailedEvent(
        orderId: string,
        basketId: string,
        email: string | null,
        totalMoney: number
    ): Promise<void> {
        const channel = await this.connection.createChannel();
        const event = new BasketDeletedFailedIntegrationEvent(
            orderId,
            basketId,
            email,
            totalMoney
        );

        await channel.publish(
            'basket-exchange',
            'basket-checkout-failed',
            Buffer.from(JSON.stringify(event))
        );
    }
}

@Component
public class OrderConsumer {
    private final BasketRepository basketRepository;
    private final RabbitTemplate rabbitTemplate;

    public OrderConsumer(
        BasketRepository basketRepository,
        RabbitTemplate rabbitTemplate
    ) {
        this.basketRepository = basketRepository;
        this.rabbitTemplate = rabbitTemplate;
    }

    @RabbitListener(queues = "basket-place-order-queue")
    public void handleOrder(PlaceOrderCommand command) {
        try {
            boolean basketDeleted = basketRepository.deleteBasket(command.getBasketId());

            if (!basketDeleted) {
                publishFailedEvent(
                    command.getOrderId(),
                    command.getBasketId(),
                    command.getEmail(),
                    command.getTotalMoney()
                );
            } else {
                publishCompletedEvent(
                    command.getOrderId(),
                    command.getBasketId(),
                    command.getTotalMoney()
                );
            }
        } catch (Exception e) {
            // Handle error and potentially retry
            throw new RuntimeException("Failed to process order command", e);
        }
    }

    private void publishCompletedEvent(
        UUID orderId,
        UUID basketId,
        BigDecimal totalMoney
    ) {
        BasketDeletedCompleteIntegrationEvent event =
            new BasketDeletedCompleteIntegrationEvent(orderId, basketId, totalMoney);

        rabbitTemplate.convertAndSend(
            "basket-exchange",
            "basket-checkout-complete",
            event
        );
    }

    private void publishFailedEvent(
        UUID orderId,
        UUID basketId,
        String email,
        BigDecimal totalMoney
    ) {
        BasketDeletedFailedIntegrationEvent event =
            new BasketDeletedFailedIntegrationEvent(orderId, basketId, email, totalMoney);

        rabbitTemplate.convertAndSend(
            "basket-exchange",
            "basket-checkout-failed",
            event
        );
    }
}

Placed Order (v1.0.0)

Receive a message when an order is placed