Esempio n. 1
0
        public async Task <BasketDTO> Delete(BasketItemsDTO item, long userId)
        {
            var basket = await GetBasketByUserId(userId);///??

            if (basket == null)
            {
                return(null);
            }

            if (!basket.BasketItems.Any())
            {
                return(basket);
            }

            basket.BasketItems.Remove(item);
            var result = unitOfWork.Repository <BasketItems>().Delete(BasketItemsConverter.Convert(item));

            if (!result)
            {
                return(null);
            }
            await unitOfWork.SaveChangesAsync();

            return(basket);
        }
Esempio n. 2
0
        public async Task <IActionResult> DeleteItem(BasketItemsDTO entity, long userId)
        {
            var dto = await service.Delete(entity, userId);

            if (dto != null)
            {
                return(Ok(dto));
            }
            else
            {
                return(BadRequest());
            }
        }
        public static OrderItemsDTO ConvertD(BasketItemsDTO basketItems)
        {
            if (basketItems == null)
            {
                throw new ArgumentNullException(nameof(basketItems));
            }

            return(new OrderItemsDTO
            {
                //Product = basketItems.Product,
                Quantity = basketItems.Quantity,
                //OrderId = // set some value
            });
        }
Esempio n. 4
0
        //public static BasketViewModel Convert(BasketDTO basket)
        //{
        //    if (basket == null) throw new ArgumentNullException(nameof(basket));

        //    return new BasketViewModel
        //    {
        //        Id=basket.Id,
        //        items=b
        //    };
        //}

        //public static List<ProductViewModel> Convert(IEnumerable<ProductDTO> products)
        //{
        //    if (products == null) throw new ArgumentNullException(nameof(products));

        //    var model = products.Select(p => Convert(p)).ToList();
        //    return model;
        //}

        public static BasketItemViewModel Convert(BasketItemsDTO items)
        {
            if (items == null)
            {
                throw new ArgumentNullException(nameof(items));
            }

            return(new BasketItemViewModel
            {
                Id = items.Id,
                BasketId = items.BasketId,
                ProductId = items.ProductId,
                Quantity = items.Quantity
            });
        }
Esempio n. 5
0
        public static BasketItems Convert(BasketItemsDTO basketItems)
        {
            if (basketItems == null)
            {
                throw new ArgumentNullException(nameof(basketItems));
            }

            return(new BasketItems
            {
                Id = basketItems.Id,
                ProductId = basketItems.ProductId,
                Quantity = basketItems.Quantity,
                BasketId = basketItems.BasketId
            });
        }
Esempio n. 6
0
        public static BasketItemsDTO GetRandomProduct()
        {
            lock (getrandom) // synchronize
            {
                ProductDTO     randomProduct = Prodcuts[getrandom.Next(0, Prodcuts.Count - 1)];
                BasketItemsDTO item          = new BasketItemsDTO();
                item.id     = randomProduct.id;
                item.image  = "";
                item.name   = randomProduct.name;
                item.price  = randomProduct.price;
                item.amount = getrandom.Next(1, 3);

                return(item);
            }
        }
Esempio n. 7
0
        public BasketItemsDTO GetRandomProduct()
        {
            //List<BasketDTO> RandomBasket = this.GenerateRandomBasket(1, 1, 1);
            //return RandomBasket.FirstOrDefault().basketItems.FirstOrDefault();
            int            nProductIndex = this.GetRandomNumber(0, this.ProductsKeys.Count - 1);
            ProductDTO     randomProduct = this.Products[this.ProductsKeys[nProductIndex]];
            BasketItemsDTO item          = new BasketItemsDTO();

            item.id     = randomProduct.id;
            item.image  = "";
            item.name   = randomProduct.name;
            item.price  = randomProduct.price;
            item.amount = this.GetRandomNumber(1, 3);

            return(item);
        }
Esempio n. 8
0
        public List <BasketDTO> GenerateRandomBasket(int p_nNumberOfBasket, int p_nFromNumberOfProduct, int p_nToNumberOfProducts)
        {
            List <BasketDTO> basketList  = new List <BasketDTO>();
            float            fTotalPrice = 0;

            for (int nIndex = 0; nIndex < p_nNumberOfBasket; nIndex++)
            {
                fTotalPrice = 0;
                BasketDTO basket = new BasketDTO();
                basket.basketItems = new List <BasketItemsDTO>();
                basket.id          = 0;

                int nCountOfProducts = this.GetRandomNumber(p_nFromNumberOfProduct, p_nToNumberOfProducts);

                for (int jIndex = 0; jIndex < nCountOfProducts; jIndex++)
                {
                    int            nProductIndex = this.GetRandomNumber(0, this.ProductsKeys.Count - 1);
                    ProductDTO     currProduct   = this.Products[this.ProductsKeys[nProductIndex]];
                    BasketItemsDTO item          = new BasketItemsDTO();
                    item.id     = currProduct.id;
                    item.image  = "";
                    item.name   = currProduct.name;
                    item.price  = currProduct.price;
                    item.amount = this.GetRandomNumber(1, 3);
                    fTotalPrice = fTotalPrice + (item.price * item.amount);
                    basket.basketItems.Add(item);
                }

                basket.totalPrice = fTotalPrice;
                StoreDTO store = this.Stores[this.GetRandomNumber(0, this.Stores.Count - 1)];
                basket.streetName = store.Address + " " + store.City;

                basketList.Add(basket);
            }

            return(basketList);
        }