public void PlaceOrder(int userId)
{
var balance = _userRepository.GetBalance(userId);
var cartItems = _cartRepository.GetCartItems(userId);
var totalAmount = cartItems.Sum(x => x.Price * x.Quantity);
balance = balance - totalAmount;
if (balance < 0)
{
throw new BgsException((int)WebApiErrorCodes.NotEnoughBalance);
}
using (var transaction = new BgsTransactionScope())
{
_userRepository.UpdateBalance(userId, balance);
foreach (var item in cartItems)
{
var blocked = (int)_productRepository.GetBlockedProductQuantity(item.ProductId);
_productRepository.UpdateBlockedProductQuantity(item.ProductId, blocked - item.Quantity);
var stock = _productRepository.GetProductStock(item.ProductId) ?? 0;
if ((stock - item.Quantity) < 0)
{
throw new BgsException((int)WebApiErrorCodes.OutOfStock);
}
_productRepository.UpdateProductStock(item.ProductId, stock - item.Quantity);
}
_transactionRepository.AddTransaction((int)TransactionType.Payment, userId, DateTime.Now, totalAmount);
_cartRepository.DeleteCartItems(userId);
var orderId = _orderRepository.AddOrder(userId, (int)OrderStatus.Pending, totalAmount, DateTime.Now, DateTime.Now);
foreach (var item in cartItems)
{
var amount = item.Price * item.Quantity;
_orderRepository.AddOrderItem(orderId, item.ProductId, item.Quantity, item.Price, amount);
}
transaction.Complete();
}
}
public void CompleteOrder(CreateOrderViewModel viewModel, string userId)
{
var validatedOrderedItemList = _productService.ValidateStockAmounts(viewModel.OrderedItemList);
double?totalPrice = GetOrderTotalPrice(validatedOrderedItemList, viewModel.PaymentMethod.Id, viewModel.DeliveryType.Id);
var order = new Order
{
Name = viewModel.UserContactDetails.Name,
Surname = viewModel.UserContactDetails.Surname,
Email = viewModel.UserContactDetails.Email,
Address = viewModel.UserContactDetails.Address,
PostalCode = viewModel.UserContactDetails.PostalCode,
City = viewModel.UserContactDetails.City,
OrderDate = DateTime.Now,
CustomerId = userId,
PaymentMethodId = viewModel.PaymentMethod.Id,
DeliveryTypeId = viewModel.DeliveryType.Id,
TotalPrice = totalPrice,
};
order.Status = OrderStatus.Pending;
_orderRepository.Add(order);
_orderRepository.SaveChanges();
foreach (var item in validatedOrderedItemList)
{
var orderItem = new OrderItem
{
OrderId = order.Id,
ProductId = item.Product.Id,
Quantity = item.Quantity,
Price = item.Product.Price,
};
_orderRepository.AddOrderItem(orderItem);
_productService.RemoveFromStock(orderItem.ProductId, orderItem.Quantity);
}
_orderRepository.SaveChanges();
SendEmailWithOrderStatus(order.Id);
}
public async Task <bool> Handle(AddOrderItemCommand request, CancellationToken cancellationToken)
{
if (!CheckCommand(request))
{
return(false);
}
var order = await _orderRepository.GetDraftOrderByClientId(request.ClientId);
var orderItem = new OrderItem(request.ProductId, request.Name, request.Quantity, request.Value);
if (order == null)
{
order = Order.OrderFactory.NewOrderDraft(request.ClientId);
order.AddOrderItem(orderItem);
_orderRepository.Add(order);
order.AddEvent(new DraftOrderInitialEvent(request.ClientId, request.ProductId));
}
else
{
var existentOrderItem = order.OrderItemExistent(orderItem);
order.AddOrderItem(orderItem);
if (existentOrderItem)
{
_orderRepository.UpdateOrderItem(order.OrderItems.FirstOrDefault(p => p.ProductId == orderItem.ProductId));
}
else
{
_orderRepository.AddOrderItem(orderItem);
}
order.AddEvent(new OrderUpdatedEvent(order.ClientId, order.Id, order.TotalValue));
}
order.AddEvent(new OrderItemAddedEvent(order.ClientId, order.Id, request.ProductId, request.Value, request.Quantity));
return(await _orderRepository.UnitOfWork.Commit());
}
public async Task <bool> Handle(AddOrderItemCommand message, CancellationToken cancellationToken)
{
if (!ValidateCommand(message))
{
return(false);
}
var order = await _orderRepository.GetDraftOrderByClientId(message.ClientId);
var orderItem = new OrderItem(message.ProductId, message.Name, message.Quantity, message.UnitValue);
if (order == null)
{
order = Order.OrderFactory.NewOrderDraft(message.ClientId);
order.AddItem(orderItem);
_orderRepository.AddOrder(order);
order.AddEvent(new OrderDraftStartedEvent(message.ClientId, message.ProductId));
}
else
{
var orderItemExistent = order.OrderItemExist(orderItem);
order.AddItem(orderItem);
if (orderItemExistent)
{
_orderRepository.UpdateOrderItem(order.OrderItem.FirstOrDefault(p => p.ProductId == orderItem.ProductId));
}
else
{
_orderRepository.AddOrderItem(orderItem);
}
order.AddEvent(new OrderUpdatedEvent(order.ClientId, order.Id, order.TotalPrice));
}
order.AddEvent(new OrderItemAddedEvent(order.ClientId, order.Id, message.ProductId, message.Name, message.UnitValue, message.Quantity));
return(await _orderRepository.UnitOfWork.Commit());
}
public async Task <bool> Handle(AddOrderItemCommand message, CancellationToken cancellationToken)
{
if (!await IsCommandValid(message, cancellationToken))
{
return(false);
}
var order = await _orderRepository.GetDraftOrderByClientId(message.ClientId);
var item = new Item(message.ItemId, message.ItemName, message.ItemQuantity, message.ItemValue);
if (order == null)
{
order = Order.OrderFactory.NewDraftOrder(message.ClientId);
order.AddItem(item);
_orderRepository.Add(order);
}
else
{
var existingItem = order.ItemExists(item);
order.AddItem(item);
if (existingItem)
{
_orderRepository.UpdateOrderItem(order.Items.FirstOrDefault(i => i.Id == item.Id));
}
else
{
_orderRepository.AddOrderItem(item);
}
_orderRepository.UpdateOrder(order);
}
order.AddEvent(new OrderItemAddedEvent(order.ClientId, order.Id, message.ItemId, message.ItemName, message.ItemQuantity, message.ItemValue));
return(await _orderRepository.UnitOfWork.Commit());
}
private void PersistOrderItemAdded(Order draftOrder, Guid productId)
{
_orderRepository.AddOrderItem(draftOrder.GetOrderItemByProductId(productId));
}
