public async Task <Order> CreateOrderAsync(string buyerEmail, int deliveryMethodId, string basketId, Address shippingAddress)
{
// get basket from the repo
var basket = await _basketRepo.GetBasketAsync(basketId);
// get items from the product repo
var items = new List <OrderItem>();
foreach (var item in basket.Items)
{
var productItem = await _unitOfWork.Repository <Product>().GetByIdAsync(item.Id);
var itemOrdered = new ProductItemOrdered(productItem.Id, productItem.Name, productItem.Image);
var orderItem = new OrderItem(itemOrdered, productItem.Price, item.Quantity);
items.Add(orderItem);
}
// get delivery method from repo
var deliveryMethod = await _unitOfWork.Repository <DeliveryMethod>().GetByIdAsync(deliveryMethodId);
// calc subtotal
var subtotal = items.Sum(item => item.Price * item.Quantity);
// check to see if order exists
var spec = new OrderByPaymentIntentIdSpecification(basket.PaymentIntentId);
var existingOrder = await _unitOfWork.Repository <Order>().GetEntityWithSpec(spec);
if (existingOrder != null)
{
_unitOfWork.Repository <Order>().Delete(existingOrder);
await _paymentService.CreateOrUpdatePaymentIntent(basket.PaymentIntentId);
}
// create order
var order = new Order(items, buyerEmail, shippingAddress, deliveryMethod, subtotal, basket.PaymentIntentId);
_unitOfWork.Repository <Order>().Add(order);
// save to db
var result = await _unitOfWork.Complete();
if (result <= 0)
{
return(null);
}
// return order
return(order);
}
public async Task <Order> UpdateOrderPaymentFailed(string paymentIntentId)
{
var spec = new OrderByPaymentIntentIdSpecification(paymentIntentId);
var order = await _unitOfWork.Repository <Order>().GetEntityWithSpec(spec);
if (order == null)
{
return(null);
}
order.Status = OrderStatus.PaymentFailed;
await _unitOfWork.Complete();
return(order);
}
public async Task <Order> UpdateOrderPaymentFailed(string paymentIntentId)
{
var spec = new OrderByPaymentIntentIdSpecification(paymentIntentId);
var order = await _unitOfWork.Repository <Order>().GetEntityWithSpec(spec.AsTracking());
if (order == null)
{
_logger.LogWarning($"UpdateOrderPaymentFailed: order == null for paymentIntentId:{paymentIntentId}");
return(null);
}
order.Status = OrderStatus.PaymentFailed;
await _unitOfWork.Complete();
return(order);
}
public async Task <Order> CreateOrderAsync(string buyerEmail, int deliveryMethodId, string basketId, Address shippingAddress)
{
var basket = await _basketRepo.GetBasketAsync(basketId);
if (basket is null)
{
return(null);
}
var items = new List <OrderItem>();
foreach (var item in basket.Items)
{
var productItem = await _unitOfWork.Repository <Product>().GetByIdAsync(item.Id);
var itemOrdered = new ProductItemOrdered(productItem.Id, productItem.Name, productItem.PictureUrl);
var orderItem = new OrderItem(itemOrdered, item.Quantity, productItem.Price);
items.Add(orderItem);
}
var deliveryMethod = await _unitOfWork.Repository <DeliveryMethod>().GetByIdAsync(deliveryMethodId);
var subTotal = items.Sum(item => item.Price * item.Quantity);
//check if order with paymentId exists
var spec = new OrderByPaymentIntentIdSpecification(basket.PaymentIntentId);
var existingOrder = await _unitOfWork.Repository <Order>().GetEntityWithSpec(spec);
if (existingOrder != null)
{
_unitOfWork.Repository <Order>().Delete(existingOrder);
await _paymentService.CreateOrUpdatePaymentIntent(basket.Id);
}
var order = new Order(items, deliveryMethod, buyerEmail, shippingAddress, subTotal, basket.PaymentIntentId);
_unitOfWork.Repository <Order>().Add(order);
//Save order to database
var result = await _unitOfWork.Complete();
if (result <= 0)
{
return(null);
}
return(order);
}
public async Task <Entities.OrderAggregate.Order> UpdateOrderPaymentSucceeded(string paymentIntentId)
{
var spec = new OrderByPaymentIntentIdSpecification(paymentIntentId);
var order = await _unitOfWork.Repository <Entities.OrderAggregate.Order>().GetEntityWithSpec(spec);
if (order == null)
{
return(null);
}
order.Status = OrderStatus.PaymentRecevied;
_unitOfWork.Repository <Entities.OrderAggregate.Order>().Update(order);
await _unitOfWork.Complete();
return(order);
}
public async Task <Order> UpdateOrderPaymentSucceeded(string paymentIntentId)
{
var spec = new OrderByPaymentIntentIdSpecification(paymentIntentId);
var order = await _unitOfWork.Repository <Order>().GetOneAsync(spec);
if (order == null)
{
return(null);
}
order.Status = OrderStatus.PaymentReceived;
_unitOfWork.Repository <Order>().Update(order);
await _unitOfWork.CompleteAsync();
return(order);
}
public async Task <Order> Handle(CreateOrderRequest req, CancellationToken cancellationToken)
{
Guard.Against.Null(req, nameof(req));
Guard.Against.Null(req.BasketId, nameof(req.BasketId));
Guard.Against.Null(req.BuyerEmail, nameof(req.BuyerEmail));
Guard.Against.Null(req.ShippingAddress, nameof(req.ShippingAddress));
Guard.Against.OutOfRange(req.DeliveryMethodId, nameof(req.DeliveryMethodId), 1, 4);
// get basket from the repo
var basket = await _basketRepo.GetBasketAsync(req.BasketId);
if (basket == null)
{
_logger.LogWarning($"basket == null for basketId:{req.BasketId}");
return(null);
}
// get items from the product repo
var items = new List <OrderItem>();
foreach (var item in basket.Items)
{
var productItem = await _unitOfWork.Repository <Product>().GetByIdAsync(item.Id);
var itemOrdered = new ProductItemOrdered(productItem.Id, productItem.Name, productItem.PictureUrl);
var orderItem = new OrderItem(itemOrdered, productItem.Price, item.Quantity);
items.Add(orderItem);
}
// get delivery method from repo
var deliveryMethod = await _unitOfWork.Repository <DeliveryMethod>().GetByIdAsync(req.DeliveryMethodId);
if (deliveryMethod == null)
{
_logger.LogWarning($"deliveryMethod == null for DeliveryMethodId:{req.DeliveryMethodId}");
return(null);
}
// calc subtotal
var subtotal = items.Sum(item => item.Price * item.Quantity);
// check to see if order exists
var spec = new OrderByPaymentIntentIdSpecification(basket.PaymentIntentId);
var existingOrder = await _unitOfWork.Repository <Order>().GetEntityWithSpec(spec.AsTracking());
if (existingOrder != null)
{
_logger.LogInformation($"existingOrder != null (orderId:{existingOrder.Id}) for PaymentIntentId:{basket.PaymentIntentId}");
_unitOfWork.Repository <Order>().Delete(existingOrder);
await _paymentService.CreateOrUpdatePaymentIntent(basket.PaymentIntentId);
}
var order = new Order(items, req.BuyerEmail, req.ShippingAddress, deliveryMethod, subtotal,
basket.PaymentIntentId);
_unitOfWork.Repository <Order>().Add(order);
// save to db
var result = await _unitOfWork.Complete();
if (result <= 0)
{
return(null);
}
//await _basketRepo.DeleteBasketAsync(req.BasketId);
return(order);
}
public async Task <Orders> CreateOrderAsync(string buyerEmail, int deliveryMethodId, string basketId, Address shippingAddress)
{
// get basket from basket repo
var basket = await _basketRepo.GetBasketAsync(basketId);
// get items from the product repo
var items = new List <OrderItem>();
foreach (var item in basket.Items)
{
var productItem = await _unitOfWork.Repository <Product>().GetByIdAsync(item.Id);
var itemOrdered = new ProductItemOrdered(productItem.Id, productItem.Name, productItem.PictureUrl);
//var OrderItem = new OrderItem(itemOrdered, productItem.Price, item.Quantity);
var OrderItem = new OrderItem
{
ItemOrderedProductItemId = productItem.Id,
ItemOrderedProductName = productItem.Name,
ItemOrderedPictureUrl = productItem.PictureUrl,
Price = productItem.Price,
Quantity = item.Quantity
};
items.Add(OrderItem);
}
// get delivery method from repo
var deliveryMethod = await _unitOfWork.Repository <DeliveryMethod>().GetByIdAsync(deliveryMethodId);
// calc subtotal
var subtotal = items.Sum(item => item.Price * item.Quantity);
//check to see if order exists
var spec = new OrderByPaymentIntentIdSpecification(basket.PaymentIntentId);
var existingOrder = await _unitOfWork.Repository <Orders>().GetEntityWithSpec(spec);
if (existingOrder != null)
{
_unitOfWork.Repository <Orders>().Delete(existingOrder);
await _paymentService.CreateOrUpdatePaymentIntent(basket.PaymentIntentId);
}
// create order
//var order = new Orders(items, buyerEmail, shippingAddress, deliveryMethod, subtotal);
var order = new Orders
{
BuyerEmail = buyerEmail,
ShipToAddressFirstName = shippingAddress.FirstName,
ShipToAddressLastName = shippingAddress.LastName,
ShipToAddressStreet = shippingAddress.Street,
ShipToAddressCity = shippingAddress.City,
ShipToAddressState = shippingAddress.State,
ShipToAddressZipcode = shippingAddress.Zipcode,
DeliveryMethod = deliveryMethod.Id,
Subtotal = subtotal,
PaymentIntenId = basket.PaymentIntentId
};
_unitOfWork.Repository <Orders>().Add(order);
// save to db
var result = await _unitOfWork.Complete();
int orderId = await _unitOfWork.Repository <Orders>().LastUpdatedIdAsync();
if (result <= 0)
{
return(null);
}
else
{
foreach (var item in items)
{
var OrderItem = new OrderItem
{
ItemOrderedProductItemId = item.ItemOrderedProductItemId,
ItemOrderedProductName = item.ItemOrderedProductName,
ItemOrderedPictureUrl = item.ItemOrderedPictureUrl,
Price = item.Price,
Quantity = item.Quantity,
OrderId = orderId
};
_unitOfWork.Repository <OrderItem>().Add(OrderItem);
}
}
var ResultFromOrderItem = await _unitOfWork.Complete();
if (ResultFromOrderItem <= 0)
{
return(null);
}
// return order
return(order);
}
