public IActionResult AddItemToBasket(AddItemRequest model)
 {
     _log.LogInformation($"Adding: {model.Name} to basket, quantity: {model.Quantity}.");
     return(Ok(_basketService.AddItemToBasket(new BasketItem {
         Id = model.Id, Name = model.Name, Price = model.Price, Quantity = model.Quantity
     })));
 }
Esempio n. 2
0
        public async Task <IActionResult> AddToCart(CatalogItem productDetails)
        {
            try
            {
                if (productDetails.Id != null)
                {
                    var user    = _appUserParser.Parse(HttpContext.User);
                    var product = new BasketItem()
                    {
                        Id          = Guid.NewGuid().ToString(),
                        Quantity    = 1,
                        ProductName = productDetails.Name,
                        PictureUrl  = productDetails.PictureUri,
                        UnitPrice   = productDetails.Price,
                        ProductId   = productDetails.Id
                    };
                    await _basketSvc.AddItemToBasket(user, product);
                }
                return(RedirectToAction("Index", "Catalog"));
            }
            catch (BrokenCircuitException)
            {
                // Catch error when Basket.api is in circuit-opened mode
                HandleBrokenCircuitException();
            }

            return(RedirectToAction("Index", "Catalog", new { errorMsg = ViewBag.BasketInoperativeMsg }));
        }
Esempio n. 3
0
        public async Task <IActionResult> OnPost(CatalogItemViewModel productDetails)
        {
            if (productDetails?.CatalogItemId == null)
            {
                return(RedirectToPage("/Index"));
            }
            await SetBasketModelAsync();

            var options = await _basketService.GetFirstOptionFromAttributeAsync(productDetails.CatalogItemId);

            await _basketService.AddItemToBasket(BasketModel.Id, productDetails.CatalogItemId, productDetails.Price, 1, options.Item1, options.Item2, options.Item3, addToExistingItem : true);

            await SetBasketModelAsync();

            return(new OkObjectResult(new { items = BasketModel.Items.Sum(x => x.Quantity), total = BasketModel.SubTotal() }));
        }
Esempio n. 4
0
        public async Task <IActionResult> OnPost(int wishListItemId)
        {
            var wishlist = await _wishlistViewModelService.GetOrCreateWishlistForUser(User.Identity.Name);

            if (wishlist == null)
            {
                //throw new Exception("Invalid Wishlist");
                return(BadRequest("Invalid Wishlist"));
            }
            var wishListItem = wishlist.Items.Where(x => x.Id == wishListItemId).FirstOrDefault();

            if (wishListItem == null)
            {
                //throw new Exception("Invalid Wishlist");
                return(BadRequest("Item already in Wishlist"));
            }

            var basket = await _basketViewModelService.GetOrCreateBasketForUser(User.Identity.Name);

            if (basket == null)
            {
                return(RedirectToPage("/Login"));
            }
            var catalogItem = await _catalogItemRepository.GetByIdAsync(wishListItem.CatalogItemId);

            await _basketService.AddItemToBasket(basket.Id, wishListItem.CatalogItemId, catalogItem.Price);

            return(RedirectToPage("/Basket/Index"));
        }
Esempio n. 5
0
        private async Task AddToBasket(IDialogContext context, JObject json, int quantity)
        {
            BotData userData = await identityService.GetBotDataAsync(context);

            AuthUser authUser = userData.GetUserAuthData();

            // TODO Check Expired
            if (authUser != null)
            {
                var reply      = context.MakeMessage();
                var producName = json.GetValue("ProductName").ToString();
                var product    = new BasketItem()
                {
                    Id          = Guid.NewGuid().ToString(),
                    Quantity    = quantity,
                    ProductName = producName,
                    PictureUrl  = UIHelper.ReplacePictureUri(json.GetValue("PictureUrl").ToString()),
                    UnitPrice   = json.GetValue("UnitPrice").ToObject <decimal>(),
                    ProductId   = json.GetValue("ProductId").ToString(),
                };
                await basketService.AddItemToBasket(authUser.UserId, product, authUser.AccessToken);

                reply.Text = string.Format(TextResources.You_have_added_to_your_basket, producName);
                context.Call(dialogFactory.CreateBasketDialog(), BasketAsync);
            }
        }
Esempio n. 6
0
        public IActionResult Privacy([FromServices] IBasketService basketService)
        {
            basketService.AddItemToBasket(1, "Kola", 3.5m, "", 3);
            ViewBag.items = basketService.BasketItems;
            string value = HttpContext.Session.GetString("basket");

            return(View());
        }
Esempio n. 7
0
        public async Task <IActionResult> AddtemToBasket(CatalogItemViewModel productDetails)
        {
            await _basketService.AddItemToBasket(BasketModel.Id, productDetails.Id, productDetails.Price, 1);

            var BasketModelS = await _basketViewModelService.GetOrCreateBasketForUser("alexis");

            return(Ok(BasketModelS));
        }
Esempio n. 8
0
        public async Task <IActionResult> AddToBasket(int productId, int quantity)
        {
            var basketId = await _basketViewModelService.GetOrCreateBasketIdAsync();

            await _basketService.AddItemToBasket(basketId, productId, quantity);

            return(Json(await _basketViewModelService.GetBasketItemsCountViewModel(basketId)));
        }
Esempio n. 9
0
        public async Task <IActionResult> AddItemToBasket(int basketid, [FromBody] BasketAddItemRequest request)
        {
            await _basketService.AddItemToBasket(basketid, request.ProductId, request.Price, request.Quantity);

            return(Ok(new BasketAddItemResponse()
            {
                Success = true
            }));
        }
Esempio n. 10
0
        public async Task <IActionResult> AddToCart(CatalogItem productDetails)
        {
            try
            {
                if (productDetails?.Id != null)
                {
                    var user = _appUserParser.Parse(HttpContext.User);
                    await _basketSvc.AddItemToBasket(user, productDetails.Id);
                }
                return(RedirectToAction("Index", "Catalog"));
            }
            catch (BrokenCircuitException)
            {
                // Catch error when Basket.api is in circuit-opened mode
                HandleBrokenCircuitException();
            }

            return(RedirectToAction("Index", "Catalog", new { errorMsg = ViewBag.BasketInoperativeMsg }));
        }
Esempio n. 11
0
        public async Task <IActionResult> AddToBasket(int productId, int quantity)
        {
            // application core projesinde BasketService : IBasketService
            // AddItemToBasket(int basketId, int catalogItemId, int quantity)
            var basketId = await _basketViewModelService.GetOrCreateBasketIdAsync();

            await _basketService.AddItemToBasket(basketId, productId, quantity);

            // sepetteki yeni öğe sayısını döndür.
            return(Json(await _basketViewModelService.GetBasketItemsCountViewModel(basketId)));
        }
        // GET: /Cart/AddToCart
        // TODO: This should be a POST.
        public async Task <IActionResult> AddToCart(CatalogItem productDetails)
        {
            if (productDetails?.Id == null)
            {
                return(RedirectToAction("Index", "Catalog"));
            }
            var basket = await GetBasketFromSessionAsync();

            await _basketService.AddItemToBasket(basket, productDetails.Id, 1);

            return(RedirectToAction("Index"));
        }
        public async Task <IActionResult> AddToBasket(CatalogItemViewModel productDetails)
        {
            if (productDetails?.Id == null)
            {
                return(RedirectToAction("Index", "Catalog"));
            }
            var basketViewModel = await GetBasketViewModelAsync();

            await _basketService.AddItemToBasket(basketViewModel.Id, productDetails.Id, productDetails.Price, 1);

            return(RedirectToAction("Index"));
        }
Esempio n. 14
0
        public async Task <IActionResult> AddItemToBasket([FromBody] BasketItemRequest basketItemRequest)
        {
            var apiUser = BuildApiUser();

            if (apiUser == null)
            {
                return(Unauthorized("Invalid or no X_API_SECRET"));
            }

            await _basketService.AddItemToBasket(apiUser.CustomerKey, BasketItemRequestMapper.MapToDto(basketItemRequest));

            return(Ok(basketItemRequest));
        }
        public void Execute(string[] args)
        {
            var basket   = _basketService.CreateBasket();
            var products = GetProductsByNames(args);

            foreach (var product in products)
            {
                basket = _basketService.AddItemToBasket(basket.Id, product.Id, product.Price, 1);
            }
            basket = _basketService.ApplyDiscounts(basket.Id);
            PrintBasket(basket);
            Console.ReadLine();
        }
Esempio n. 16
0
        public async Task <IActionResult> AddToBasket(int basketId, [FromBody] AddItem item)
        {
            var catalogueItem = await _catalogueService.GetCatalogueItem(item.CatalogueItemId.Value);

            if (catalogueItem == null)
            {
                return(NotFound("No CatalogueItem found"));
            }

            await _basketService.AddItemToBasket(basketId, catalogueItem.Id, catalogueItem.Price, item.Quantity.Value);

            return(Ok());
        }
Esempio n. 17
0
        public async Task <IActionResult> OnPost(CatalogItemViewModel productDetails)
        {
            if (productDetails?.Id == null)
            {
                return(RedirectToPage("/Index"));
            }
            await SetBasketModelAsync();

            await _basketService.AddItemToBasket(BasketModel.Id, productDetails.Id, productDetails.Price);

            await SetBasketModelAsync();

            return(RedirectToPage());
        }
Esempio n. 18
0
        public async Task <IActionResult> OnPost(CatalogItemViewModel productDetails, string catName = null, string typeName = null)
        {
            if (productDetails?.CatalogItemId == null)
            {
                return(RedirectToPage("/Index"));
            }
            await SetBasketModelAsync();

            await _basketService.AddItemToBasket(BasketModel.Id, productDetails.CatalogItemId, productDetails.Price, 1, addToExistingItem : true);

            await SetBasketModelAsync();

            StatusMessage = $"Adicionado {productDetails.CatalogItemName} ao carrinho!";
            if (!string.IsNullOrEmpty(catName) && string.IsNullOrEmpty(typeName))
            {
                return(RedirectToPage("/Category/Index", new { id = catName }));
            }
            else if (!string.IsNullOrEmpty(catName) && !string.IsNullOrEmpty(typeName))
            {
                return(RedirectToPage("/Category/Type/Index", new { cat = catName, type = typeName }));
            }
            return(RedirectToPage("/Index"));
        }
Esempio n. 19
0
        public async Task <IActionResult> OnPost(CatalogItemViewModel product)
        {
            if (product.id == 0)
            {
                return(Page());
            }
            await SetBasketModelAsync();

            await _basketService.AddItemToBasket(basketModel.Id, product.id, product.price);

            await SetBasketModelAsync();

            return(Page());
        }
Esempio n. 20
0
        public async Task TransferWishlistItemToBasket(int wishListItemId, int basketId, int catalogItemId, int quantity = 1)
        {
            var wishListItem = await _wishlistItemRepository.GetByIdAsync(wishListItemId);

            if (wishListItem == null)
            {
                throw new Exception("Wishlist item doen't exist");
            }
            var catalogItem = await _catalogItemRepository.GetByIdAsync(wishListItem.CatalogItemId);

            await _basketService.AddItemToBasket(basketId, wishListItem.CatalogItemId, catalogItem.Price, quantity);

            await _wishlistItemRepository.DeleteAsync(wishListItem);
        }
Esempio n. 21
0
        public async Task <IActionResult> AddToBasket(int productId, int quantity)
        {
            // application core projesinde BasketService:IBasketService
            //AddItemToBasket(int basketId, int catologId,int quantity)
            //sepette varsa adedini güncelle yoksa ekle
            //sepetteki öğe sayısını döndür

            var basketId = await _basketViewModelService.GetOrCreateBasketIdAsync();

            await _basketService.AddItemToBasket(basketId, productId, quantity);

            int basketItemsCount = await _basketService.BasketItemsCount(basketId);

            return(Json(await _basketViewModelService.GetBasketItemsCountViewModel(basketId)));
        }
Esempio n. 22
0
        public async Task <IActionResult> OnPost(StoreProductItemViewModel productDetails)
        {
            if (productDetails?.Id == null)
            {
                return(RedirectToPage("/Index"));
            }
            await SetBasketModelAsync();

            await _basketService.AddItemToBasket(BasketModel.Id, productDetails.StoreId, productDetails.SecondaryId, productDetails.ProductId, productDetails.OptionId, productDetails.Name, productDetails.PictureUri, productDetails.Price);

            await SetBasketModelAsync();


            return(RedirectToPage());
        }
Esempio n. 23
0
        public async Task <IActionResult> OnPost(CatalogItemViewModel productDetails)
        {
            if (productDetails?.Id == null)
            {
                return(RedirectToPage("/Index"));
            }
            await SetBasketModelAsync();

            await _basketService.AddItemToBasket(BasketModel.Id, productDetails.Id, productDetails.Price);

            await SetBasketModelAsync();

            StatusMessage = "Product was successfull added to your Basket. Continue buying the hapiness.";
            return(RedirectToPage("/Index"));
        }
Esempio n. 24
0
    public async Task <IActionResult> OnPost(CatalogItemViewModel productDetails)
    {
        if (productDetails?.Id == null)
        {
            return(RedirectToPage("/Index"));
        }

        var username = GetOrSetBasketCookieAndUserName();
        var basket   = await _basketService.AddItemToBasket(username,
                                                            productDetails.Id, productDetails.Price);

        BasketModel = await _basketViewModelService.Map(basket);

        return(RedirectToPage());
    }
Esempio n. 25
0
 public async Task <IActionResult> AddToCart(CatalogItem productDetails)
 {
     if (productDetails.Id != null)
     {
         var user    = _appUserParser.Parse(HttpContext.User);
         var product = new BasketItem()
         {
             Id          = Guid.NewGuid().ToString(),
             Quantity    = 1,
             ProductName = productDetails.Name,
             PictureUrl  = productDetails.PictureUri,
             UnitPrice   = productDetails.Price,
             ProductId   = productDetails.Id
         };
         await _basketSvc.AddItemToBasket(user, product);
     }
     return(RedirectToAction("Index", "Catalog"));
 }
Esempio n. 26
0
        public ActionResult <BasketItem> AddItemToBasket(string customerId, [FromBody] BasketItem item)
        {
            // Check if the basket cannot be found
            if (!_basketRepository.TryGetBasket(customerId, out ShoppingBasket shoppingBasket))
            {
                return(BasketNotFound(customerId));
            }

            // Check if item already exists in basket
            if (_basketRepository.TryGetItemInBasket(item.ProductId, customerId, out BasketItem existingItem))
            {
                return(ItemAlreadyFound(customerId, item.ProductId));
            }

            _basketService.AddItemToBasket(shoppingBasket, item);

            return(CreatedAtRoute("GetItemInBasket", new { customerId, itemId = item.ProductId }, item));
        }
Esempio n. 27
0
        public async Task <IActionResult> AddToCart(int itemId)
        {
            try
            {
                if (itemId > 0)
                {
                    var user = _appUserParser.Parse(HttpContext.User);
                    await _basketSvc.AddItemToBasket(user, itemId);
                }
                return(RedirectToAction("Index", "Cart"));
            }
            catch (Exception e)
            {
                _logger.LogError(e, "Add to cart failed");
            }

            return(RedirectToAction("Index", "Catalog", new { errorMsg = "Basket Service is inoperative, please try later on. (Business Msg Due to Circuit-Breaker)" }));
        }
Esempio n. 28
0
        public async Task <IActionResult> AddToCart(ScholarshipItem scholarshipItemDetails)
        {
            try
            {
                if (scholarshipItemDetails?.Id != null)
                {
                    var user = _appUserParser.Parse(HttpContext.User);
                    await _basketSvc.AddItemToBasket(user, scholarshipItemDetails.Id);
                }
                return(RedirectToAction("Index", "Scholarship"));
            }
            catch (Exception ex)
            {
                // Catch error when Basket.api is in circuit-opened mode
                HandleException(ex);
            }

            return(RedirectToAction("Index", "Scholarship", new { errorMsg = ViewBag.BasketInoperativeMsg }));
        }
Esempio n. 29
0
        public async Task <IActionResult> OnPostTransferBasket(Dictionary <string, int> items)
        {
            await SetBasketModelAsync();

            foreach (var kvp in items)
            {
                var wishListItemId = int.Parse(kvp.Key);
                var wishlistItem   = await _wishListItemsRepo.GetByIdAsync(wishListItemId);

                if (wishlistItem == null)
                {
                    _logger.LogInformation($"No item found in the catalog.");
                }
                // wishlistItem.CatalogItemId
                CatalogItem catalogItem = await _catalogItemsRepo.GetByIdAsync(wishlistItem.CatalogItemId);

                await _basketService.AddItemToBasket(BasketModel.Id, wishlistItem.CatalogItemId, catalogItem.Price, kvp.Value);
            }

            return(RedirectToPage("/Basket/Index"));
        }
Esempio n. 30
0
        private static void BasketHandler(ShelfItem[] shelfItems, IBasketService basketService)
        {
            while (true)
            {
                Write("\n ENTER ITEM NUMBER TO ADD IT TO THE BASKET (ENTER 'N' TO CHECKOUT): ");
                var userInput = ReadKey();

                if (!Helper.ValidUserInput(userInput, "PLEASE ENTER ONE OF THE NUMBERS FROM THE ABOVE LIST"))
                {
                    break;
                }

                var shelfItemId = int.Parse(userInput.KeyChar.ToString());

                if (shelfItems.All(s => s.Id != shelfItemId))
                {
                    WriteLine("\n PLEASE ENTER ONE OF THE NUMBERS FROM THE ABOVE LIST \n");
                    continue;
                }

                var selectedShelfItem = shelfItems.SingleOrDefault(s => s.Id == shelfItemId);

                if (selectedShelfItem == null)
                {
                    continue;
                }

                Write($"\n ENTER QTY OF {selectedShelfItem.Name.ToUpper()}: ");
                var qtyUserInput = ReadLine();

                if (!Helper.ValidUserInput(qtyUserInput, "QUANTITY MUST BE A WHOLE NUMBER"))
                {
                    continue;
                }

                int.TryParse(qtyUserInput, out var quantity);

                basketService.AddItemToBasket(selectedShelfItem, quantity);
            }
        }