public void AddOrder(Order order)
{
try
{
_orderRepository.AddItem(order);
}
catch (Exception exception)
{
//_logger.WriteLog("Cannot insert data \n-----------------\n"+ exception);
throw;
}
}
public IActionResult Cart(string code)
{
if (!string.IsNullOrEmpty(code))
{
orderRepository.AddItem(code);
}
Order order = orderRepository.GetOrder();
var cart = orderRepository.GetProductOrder(order.Id);
return(View(cart));
}
public async Task <IActionResult> BuyChart(string code)
{
if (!string.IsNullOrEmpty(code))
{
await orderRepository.AddItem(code);
}
Order order = await orderRepository.GetOrder();
List <ItemOrder> itens = order.Itens;
ChartViewModel chartViewModel = new ChartViewModel(itens);
return(View(chartViewModel));
}
public IActionResult ShoppingCart(string internalId)
{
if (!string.IsNullOrEmpty(internalId))
{
OrderRepository.AddItem(internalId);
}
Order order = OrderRepository.GetOrder();
List <OrderItem> items = order.Items;
ShoppingCartViewModel shoppingCartViewModel = new ShoppingCartViewModel(items);
return(base.View(shoppingCartViewModel));
}
public IActionResult Post(OrderItemRequest orderItemRequest)
{
var errorMessage = _orderRepository.AddItem(orderItemRequest);
var response = new DefaultResponse
{
Success = string.IsNullOrWhiteSpace(errorMessage),
ErrorMessage = errorMessage
};
if (!response.Success)
{
return(BadRequest(response));
}
return(Ok(response));
}
public async Task <bool> Handle(AddOrderItemCommand message, CancellationToken cancellationToken)
{
if (!IsCommandValid(message))
{
return(false);
}
var order = await _orderRepository.GetOrderDraftByClientId(message.ClientId);
var item = new OrderItem(message.ProductId, message.ProductName, message.Quantity, message.UnitPrice);
if (order == null)
{
order = Order.OrderFactory.NewOrderDraft(message.ClientId);
order.AddItemOrder(item);
_orderRepository.Add(order);
order.AddEvents(new OrderDraftStartedEvent(message.ClientId, order.Id));
}
else
{
var existingItem = order.IsAlreadyItemInOrder(item);
order.AddItemOrder(item);
if (existingItem)
{
_orderRepository.UpdateItem(order.OrderItems.FirstOrDefault(i => i.ProductId == item.ProductId));
}
else
{
_orderRepository.AddItem(item);
}
order.AddEvents(new OrderUpdatedEvent(message.ClientId, order.Id, order.TotalOrder));
}
order.AddEvents(new OrderItemAddedEvent(message.ClientId, order.Id, message.ProductId,
message.ProductName, message.UnitPrice, message.Quantity));
return(await _orderRepository.UnitOfWork.Commit());
}
public async Task <bool> Handle(AddOrderItemCommand message, CancellationToken cancellationToken)
{
if (!IsValid(message))
{
return(false);
}
var order = await _orderRepository.GetDraftOrderByClientId(message.ClientId);
var orderItem = new OrderItem(message.CourseId, message.CourseName, message.Price);
if (order == null)
{
order = Order.OrderFactory.NewDraftOrder(message.ClientId);
order.AddItem(orderItem);
_orderRepository.Add(order);
order.AddEvent(new OrderDraftStartedEvent(order.Id, message.CourseId, message.CourseName, message.ClientId));
}
else
{
var hasOrderItem = order.HasOrderItem(orderItem);
order.AddItem(orderItem);
if (hasOrderItem)
{
_orderRepository.UpdateItem(order.OrderItems.FirstOrDefault(p => p.CourseId == orderItem.CourseId));
}
else
{
_orderRepository.AddItem(orderItem);
}
// order.AddEvent(new OrderItemAddedEvent(order.Id, message.CourseId, message.CourseName, message.ClientId));
}
order.AddEvent(new OrderUpdatedEvent(order.Id, message.ClientId, order.TotalValue));
return(await _orderRepository.UnitOfWork.Commit());
}
public async Task <bool> Handle(AddOrderItemCommand command, CancellationToken cancellationToken)
{
if (!ValidateCommand(command))
{
return(false);
}
var order = await _orderRepository.GetOrderDraftByCustomerId(command.CustomerId);
var item = new OrderItem(command.ProductId, command.Name, command.Quantity, command.Amount);
if (order is null)
{
order = Order.OrderFactory.NewDraftOrder(command.CustomerId);
order.AddOrderItem(item);
_orderRepository.Add(order);
order.AddEvent(new DraftOrderCreatedEvent(command.CustomerId, order.Id));
}
else
{
var itemExists = order.OrderItemExists(item);
order.AddOrderItem(item);
if (itemExists)
{
_orderRepository.UpdateItem(order.OrderItems.FirstOrDefault(o => o.ProductId == item.ProductId));
}
else
{
_orderRepository.AddItem(item);
}
order.AddEvent(new OrderUpdatedEvent(order.CustomerId, order.Id, order.TotalAmount));
}
order.AddEvent(new OrderItemAddedEvent(order.CustomerId, order.Id, command.ProductId, command.Amount, command.Quantity));
return(await _orderRepository.UnitOfWork.Commit());
}
public async Task <Order> OrderAddItem(Guid?orderId, [FromBody] OrderItem item)
{
return(await _orderRepository.AddItem(orderId, item));
}
