public IActionResult CreateOrder([FromBody] OrderToCreateDto orderToCreate)
{
try
{
if (orderToCreate == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(new UnprocessableEntityObjectResult(ModelState));
}
var orderEntity = Mapper.Map <Order>(orderToCreate);
_repo.AddOrder(orderEntity);
if (!_repo.Save())
{
throw new Exception("Error creating order.");
}
var eventMessage = new OrderCreatedIntegrationEvent(orderEntity);
_eventBus.Publish(eventMessage);
var orderToReturn = Mapper.Map <OrderDto>(orderEntity);
return(CreatedAtRoute("GetOrder", new { id = orderToReturn.Id }, orderToReturn));
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task <ActionResult> Post([FromBody] AlterationViewModel viewModel)
{
if (viewModel == null)
{
return(BadRequest());
}
var alterationOrder = await _alterationService.CreateAlterationAsync(viewModel.ToDomainModel());
var @event = new OrderCreatedIntegrationEvent(alterationOrder.Id, alterationOrder.CustomerId);
_eventBus.Publish(@event);
return(Ok(alterationOrder.ToViewModel()));
}
public async Task <Result <Ordering.Domain.Data.Entities.Order> > CreateOrderAsync(Ordering.Domain.Data.Entities.Order order)
{
_logger.LogInformation($"CreateOrderAsync! : {DateTime.UtcNow}");
var result = await _orderService.CreateOrderAsync(order);
// generate event data for publish to event bus
var @event = new OrderCreatedIntegrationEvent(result.Data.Id);
// public order created event to event bus
_eventBus.Publish(@event);
return(result);
}
public async Task <bool> Handle(CreateOrderCommand notification, CancellationToken cancellationToken)
{
await _unitOfWork.BeginTransactionAsync();
var orderItems = notification.OrderItems.Select(x => OrderItem.CreateOrderItem(x.ProductId, x.Quantity));
var order = Order.CreateOrder(notification.CustomerId, notification.Description, orderItems);
_orderRepository.Add(order);
await _unitOfWork.SaveEntitiesAsync();
var @event = new OrderCreatedIntegrationEvent(order, true);
await _integrationEventService.SaveEventAsync(@event);
await _unitOfWork.SaveChangesAsync();
await _unitOfWork.CommitAsync();
await _integrationEventService.PublishAsync(@event);
return(true);
}
public IActionResult Post([FromBody] IEnumerable <OrderLineItem> orderLineItems)
{
var order = new Order();
order.OrderStatus = "Created";
foreach (var item in orderLineItems)
{
order.AddOrderLineItems(item);
}
_orderRepository.CreateOrder(order);
var orderResult = _orderRepository.GetOrder(order.Id);
// generate event data for publish to event bus
var @event = new OrderCreatedIntegrationEvent()
{
OrderId = order.Id
};
@event.Products = new List <AvroSchema.Product>();
foreach (var item in orderResult.OrderLineItems)
{
@event.Products.Add(new AvroSchema.Product()
{
ProductName = item.Product.ProductName,
Quantity = item.Quantity,
UnitPrice = item.Product.UnitPrice
});
}
// public order created event to event bus
_eventBus.PublishAsync(@event).Wait();
return(Ok(orderResult));
}
