Esempio n. 1
0
 public LoggedInConsumerTest()
 {
     basketRedisService = new Mock <IBasketRedisService>();
     logger             = new Mock <ILogger <LoggedInConsumer> >();
     consumer           = new LoggedInConsumer(basketRedisService.Object, logger.Object);
     basketDto          = new UserBasketDto();
 }
Esempio n. 2
0
        public async Task <ActionResult <UserBasket> > UpdateBasket(UserBasketDto basket)
        {
            var customerBasket = _mapper.Map <UserBasketDto, UserBasket>(basket);

            var updatedBasket = await _basketRepository.UpdateBasketAsync(customerBasket);

            return(Ok(updatedBasket));
        }
Esempio n. 3
0
 public AddProductCommandHandlerTest()
 {
     basketRedisService = new Mock <IBasketRedisService>();
     command            = new AddProductCommand {
         UserId = It.IsAny <string>(), Product = new BasketProduct()
     };
     commandHandler = new AddProductCommandHandler(basketRedisService.Object);
     basketDto      = new UserBasketDto();
 }
Esempio n. 4
0
 public GetBasketQueryHandlerTest()
 {
     basketRedisService = new Mock <IBasketRedisService>();
     query        = new GetBasketQuery(userId);
     queryHandler = new GetBasketQueryHandler(basketRedisService.Object);
     basketDto    = new UserBasketDto {
         Products = new List <BasketProduct> {
             new BasketProduct()
         }
     };
 }
Esempio n. 5
0
        public async Task SaveBasket(string userId, UserBasketDto basket)
        {
            await RemoveBasket(userId);

            string serializeObject = JsonConvert.SerializeObject(basket);

            await distributedCache.SetStringAsync(userId, serializeObject, new DistributedCacheEntryOptions()
            {
                AbsoluteExpiration = DateTimeOffset.Now.AddDays(1)
            });
        }
        private async Task RemoveProductAndDecreaseBasketTotalPrice(UserBasketDto basket, RemoveProductCommand request)
        {
            var productToRemove = basket.Products.Where(x => x.Id == request.ProductId).FirstOrDefault();

            if (productToRemove == null)
            {
                return;
            }

            basket.Products.Remove(productToRemove);
            basket.TotalPrice -= (productToRemove.Price * productToRemove.Quantity);

            await basketRedisService.SaveBasket(request.UserId, basket);
        }
Esempio n. 7
0
        private async Task AddProductToBasketAndIncreaseBasketTotalPrice(BasketProduct basketProduct,
                                                                         UserBasketDto basket, AddProductCommand request)
        {
            if (basketProduct != null)
            {
                basketProduct.Quantity += request.Product.Quantity;
            }
            else
            {
                basket.Products.Add(request.Product);
            }

            basket.TotalPrice += (request.Product.Price * request.Product.Quantity);

            await basketRedisService.SaveBasket(request.UserId, basket);
        }
        public RemoveProductCommandHandlerTest()
        {
            basketRedisService = new Mock <IBasketRedisService>();
            command            = new RemoveProductCommand(userId, productId);
            commandHandler     = new RemoveProductCommandHandler(basketRedisService.Object);

            basketDto = new UserBasketDto
            {
                Products = new List <BasketProduct>()
                {
                    new BasketProduct {
                        Id = productId
                    }
                }
            };
        }
        public ChangeProductQuantityCommandHandlerTest()
        {
            basketRedisService = new Mock <IBasketRedisService>();
            command            = new ChangeProductQuantityCommand {
                UserId = userId, ProductId = productId, ChangeQuantityAction = action
            };
            commandHandler = new ChangeProductQuantityCommandHandler(basketRedisService.Object);

            basketDto = new UserBasketDto
            {
                Products = new List <BasketProduct> {
                    new BasketProduct {
                        Id = productId
                    }
                }
            };
        }
        public async Task GetBasketQuantityQueryHandler_Success()
        {
            //Arrange
            var userBasketDto = new UserBasketDto
            {
                Products = new List <BasketProduct> {
                    new BasketProduct(), new BasketProduct()
                }
            };

            basketRedisService.Setup(x => x.GetBasket(userId)).Returns(Task.FromResult(userBasketDto));

            //Act
            var action = await queryHandler.Handle(query, It.IsAny <CancellationToken>());

            //Assert
            Assert.Equal(userBasketDto.Products.Count, action);
        }
Esempio n. 11
0
        private void MergeProducts(UserBasketDto sessionBasket, UserBasketDto userBasket)
        {
            foreach (var sessionProduct in sessionBasket.Products)
            {
                var userProduct = userBasket.Products.Where(x => x.Id == sessionProduct.Id).FirstOrDefault();

                if (userProduct == null)
                {
                    userBasket.Products.Add(sessionProduct);
                }
                else
                {
                    userProduct.Quantity += sessionProduct.Quantity;
                    userProduct.Price    += sessionProduct.Price;
                }

                userBasket.TotalPrice += sessionProduct.Price;
            }
        }
 private void RemoveProductIfQuantityIsLessOrEqualZero(BasketProduct basketProduct, UserBasketDto basket)
 {
     if (basketProduct.Quantity <= 0)
     {
         basket.Products.Remove(basketProduct);
     }
 }
        private async Task ChangeProductQuantityAndBasketTotalPrice(BasketProduct basketProduct, UserBasketDto basket,
                                                                    ChangeProductQuantityCommand request)
        {
            switch (request.ChangeQuantityAction)
            {
            case ChangeQuantityAction.Plus:
                basketProduct.Quantity++;
                basket.TotalPrice += basketProduct.Price;
                break;

            case ChangeQuantityAction.Minus:
                basketProduct.Quantity--;
                basket.TotalPrice -= basketProduct.Price;
                break;

            default:
                break;
            }

            RemoveProductIfQuantityIsLessOrEqualZero(basketProduct, basket);

            await basketRedisService.SaveBasket(request.UserId, basket);
        }
Esempio n. 14
0
        public async Task <ActionResult <ProductToReturnDto> > AddProductIngredient(int id, [FromForm] UserBasketDto itemDto)
        {
            var spec    = new ProductsWithTypesAndBrandsSpecification(id);
            var product = await _unitOfWork.Repository <Product>().GetEntityWithSpec(spec);

            var order = await _recipeService.CreateOrderAsync(id, itemDto.Id);

            if (order == null)
            {
                return(BadRequest(new ApiResponse(400, "Problem creating order")));
            }

            return(Ok(order));
        }