예제 #1
0
        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);
        }
예제 #2
0
        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);
        }
예제 #4
0
        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);
        }
예제 #5
0
        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);
        }
예제 #6
0
        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);
        }
예제 #7
0
        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);
        }
예제 #8
0
        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);
        }