/// <summary> /// Adds item to shopping cart and redirect to shopping cart page. /// </summary> protected void ButtonAddToCart_Click(object sender, EventArgs e) { Page.Validate(); if (!Page.IsValid) { return; } // Retrieve product via Product Facade. var repository = new ProductRepository(); ActionServiceReference.Product product = repository.GetProduct(ProductId); // Get product details and add information to cart. int productId = product.ProductId; string name = product.ProductName; double unitPrice = product.UnitPrice; int quantity; if (!int.TryParse(TextBoxQuantity.Text.Trim(), out quantity)) { quantity = 1; } var cartRepository = new CartRepository(); cartRepository.AddItem(productId, name, quantity, unitPrice); // Show shopping cart to user. Response.Redirect(UrlMaker.ToCart()); }
public void InsertCartItemTest() { CartRepository.AddToCart(cart); var cartFromList = CartRepository.GetCartItemById(cart.Id); Assert.AreEqual(cart, cartFromList); }
public CartController(IRepository repository, AddToCartViewModel.Factory viewModelFactory, CartSerializer cartSerializer, CartRepository cartRepository) { this.repository = repository; this.viewModelFactory = viewModelFactory; this.cartSerializer = cartSerializer; this.cartRepository = cartRepository; }
public ActionResult DeleteConfirmed(int id) { try { var cartInList = CartRepository.GetCartItemById(id); if (cartInList == null) { return(NotFound()); } if (cartInList.Quantity > 1) { cartInList.Quantity = --cartInList.Quantity; CartRepository.Update(cartInList); } else { CartRepository.RemoveCartItem(cartInList); } return(RedirectToAction(nameof(Index))); } catch { return(View()); } }
public void SetUp() { //Arrange _container = new AutoMocker(); _repository = _container.CreateInstance <CartRepository>(); var cacheProvider = _container.GetMock <ICacheProvider>(); cacheProvider .Setup(provider => provider.GetOrAddAsync( It.IsNotNull <CacheKey>(), It.IsNotNull <Func <Task <ProcessedCart> > >(), It.IsAny <Func <ProcessedCart, Task> >(), It.IsAny <CacheKey>())) .Returns <CacheKey, Func <Task <ProcessedCart> >, Func <ProcessedCart, Task>, CacheKey>( (key, func, arg3, arg4) => func()) .Verifiable(); var overtureClient = _container.GetMock <IOvertureClient>(); var dummyCart = new ProcessedCart(); overtureClient .Setup(client => client.SendAsync( It.IsNotNull <GetCartRequest>())) .ReturnsAsync(dummyCart) .Verifiable(); }
public ActionResult DeleteCartItem(int cartItemId) { var msgType = false; string msg; try { if (Application.LoggedRequestorId != null) { var userId = (int)Application.LoggedRequestorId; CartRepository.DeleteCartStuff(userId, cartItemId); msgType = true; msg = Requestor.Req_Cart_MaterialDelete; } else { msg = Common.ErrorMsgForSession; } } catch (Exception e) { msg = e.Message; Logger.LogError(e, "Error while deleting cart item from Requestor zone"); } return(Json(new { success = msgType, message = msg })); }
public virtual async Task <CompleteCheckoutViewModel> CompleteCheckoutAsync(CompleteCheckoutParam param) { if (param == null) { throw new ArgumentNullException(nameof(param), "param"); } if (param.CultureInfo == null) { throw new ArgumentException(ArgumentNullMessageFormatter.FormatErrorMessage("CultureInfo"), nameof(param)); } if (string.IsNullOrWhiteSpace(param.CartName)) { throw new ArgumentException(ArgumentNullMessageFormatter.FormatErrorMessage("CartName"), nameof(param)); } if (string.IsNullOrWhiteSpace(param.Scope)) { throw new ArgumentException(ArgumentNullMessageFormatter.FormatErrorMessage("Scope"), nameof(param)); } if (param.CustomerId == Guid.Empty) { throw new ArgumentException(ArgumentNullMessageFormatter.FormatErrorMessage("CustomerId"), nameof(param)); } var order = await CartRepository.CompleteCheckoutAsync(param).ConfigureAwait(false); return(MapOrderToCompleteCheckoutViewModel(order, param.CultureInfo)); }
public virtual async Task <CompleteCheckoutViewModel> CompleteCheckoutAsync(CompleteCheckoutParam param) { if (param == null) { throw new ArgumentNullException(nameof(param)); } if (param.CultureInfo == null) { throw new ArgumentException(GetMessageOfNull(nameof(param.CultureInfo)), nameof(param)); } if (string.IsNullOrWhiteSpace(param.CartName)) { throw new ArgumentException(GetMessageOfNullWhiteSpace(nameof(param.CartName)), nameof(param)); } if (string.IsNullOrWhiteSpace(param.Scope)) { throw new ArgumentException(GetMessageOfNullWhiteSpace(nameof(param.Scope)), nameof(param)); } if (param.CustomerId == Guid.Empty) { throw new ArgumentException(GetMessageOfEmpty(nameof(param.CustomerId)), nameof(param)); } var order = await CartRepository.CompleteCheckoutAsync(param).ConfigureAwait(false); return(await MapOrderToCompleteCheckoutViewModel(order, param).ConfigureAwait(false)); }
protected void UpdateCartBtn_Click(object sender, EventArgs e) { Products p = new Products(); p = CartController.getProductByID(id); int quantity = Int32.Parse(NewQuantityBox.Text); int stock = p.Stock; String Notvalid = CartController.updateValidation(quantity, stock, p.ID); if (!Notvalid.Equals("")) { ErrorMsg.Text = Notvalid; } else if (quantity == 0) { //delete int userId = Convert.ToInt32(Session["userId"].ToString()); CartRepository.deleteItem(userId, p.ID); Response.Redirect("ViewCart.aspx"); } else { int userId = Convert.ToInt32(Session["userId"].ToString()); CartRepository.updateCarts(userId, p.ID, quantity); Response.Redirect("ViewCart.aspx"); } }
public async Task GetAll_WhenCalled_ShouldEventually_FetchAllCartItems() { var data = new List <CartItem>(); data.Add(new CartItem(Guid.NewGuid().ToString(), "some-name-1", 45.99m, "some-manufacturer", DateTime.UtcNow)); var response = TryOptionAsync <List <CartItem> >(() => Task.Run(() => data)); var documentDbClient = new Mock <IDocumentDbClient <CartItem> >(); documentDbClient.Setup(mock => mock.GetDocumentsAsync(It.IsAny <int>(), It.IsAny <int>())) .Returns(response); var sut = new CartRepository(documentDbClient.Object); var expected = Some(new PagedResult <CartItem>( data, 1, 1, 1 )); await match <Exception, Option <PagedResult <CartItem> > >(sut.GetAll(0, 1), Right : result => Assert.Equal(expected, result), Left : _ => Assert.False(true, "Shouldn't get here!") ); documentDbClient.Verify( mock => mock.GetDocumentsAsync( It.Is <int>(number => number == 0), It.Is <int>(number => number == 1) ), Times.Once ); }
public async Task GetAll_WhenCalled_AndExceptionOccurs_ShouldEventually_ReturnException() { var expected = new Exception("Unknown error occurred!"); var response = TryOptionAsync <List <CartItem> >(() => throw expected); var documentDbClient = new Mock <IDocumentDbClient <CartItem> >(); documentDbClient.Setup(mock => mock.GetDocumentsAsync(It.IsAny <int>(), It.IsAny <int>())) .Returns(response); var sut = new CartRepository(documentDbClient.Object); await match <Exception, Option <PagedResult <CartItem> > >(sut.GetAll(0, 1), Right : _ => Assert.False(true, "Shouldn't get here!"), Left : ex => Assert.Equal(expected, ex) ); documentDbClient.Verify( mock => mock.GetDocumentsAsync( It.Is <int>(number => number == 0), It.Is <int>(number => number == 1) ), Times.Once ); }
public async Task Update_WhenCalled_AndExceptionOccurs_ShouldEventually_ReturnException() { var expectedId = Guid.NewGuid().ToString(); var updatedItem = new CartItem(expectedId, "some-name-1", 45.99m, "some-manufacturer", DateTime.UtcNow); var expected = new Exception("Unknown error occurred!"); var response = TryOptionAsync <CartItem>(() => throw expected); var documentDbClient = new Mock <IDocumentDbClient <CartItem> >(); documentDbClient.Setup(mock => mock.ReplaceDocumentAsync(It.IsAny <Func <CartItem, bool> >(), It.IsAny <CartItem>())) .Returns(response); var sut = new CartRepository(documentDbClient.Object); await match <Exception, Option <CartItem> >(sut.Update(updatedItem), Right : _ => Assert.False(true, "Shouldn't get here!"), Left : ex => Assert.Equal(expected, ex) ); documentDbClient.Verify( mock => mock.ReplaceDocumentAsync( It.IsAny <Func <CartItem, bool> >(), It.Is <CartItem>(item => item.Equals(updatedItem)) ), Times.Once ); }
public void CartRepository_WithNoNullArguments_ShouldReturnDocumentDbClient() { var dbClientMock = new Mock <IDocumentDbClient <CartItem> >(); var sut = new CartRepository(dbClientMock.Object); Assert.NotNull(sut); }
public static void updateQtyForExistingItem(int userId, int itemId, int qty) { vCart currentCartItem = CartRepository.findProduct(userId, itemId); qty = currentCartItem.Quantity + qty; CartRepository.update(userId, itemId, qty); }
// 2. Show total shelter count public ActionResult TotalShelter() { return(Json(new { TotalProducts = CartRepository.GetTotalStuffCount(Application.LoggedRequestorId) }, JsonRequestBehavior.AllowGet)); }
public static bool Checkout(int userId) { List <Cart> carts = GetThisUserCart(userId); if (carts.Count == 0) { return(false); } else { TransactionHeader transactionHeader = TransactionHeaderFactory.Create(userId); if (TransactionHeaderRepository.InsertTransactionHeader(transactionHeader)) { int headerId = transactionHeader.Id; for (int i = 0; i < carts.Count(); i++) { TransactionDetail transactionDetail = TransactionDetailFactory.Create(headerId, carts[i].ProductId, carts[i].Quantity); TransactionDetailRepository.InsertTransactionDetail(transactionDetail); } for (int i = 0; i < carts.Count(); i++) { CartRepository.RemoveCart(carts[i]); } return(true); } return(false); } }
public ActionResult SaveCartStuffs() { var msgType = false; string msg; try { if (Application.LoggedRequestorId != null) { var userId = (int)Application.LoggedRequestorId; CartRepository.SaveRequest(userId); msgType = true; msg = Requestor.Req_Cart_MaterialSaved; } else { msg = Common.ErrorMsgForSession; } } catch (Exception e) { msg = e.Message; BaseRepository.OimsDataContext.ClearChanges(); // Roll back all changes Logger.LogError(e, "Error while saving cart stuff from Requestor zone"); } return(Json(new { success = msgType, message = msg })); }
public CartRepositoryTests() { container = new PointOfScaleContainer(); cartRepository = new CartRepository(container); container.CartLines = new List <CartLine> { new CartLine { Product = new Product { Code = "A", RetailPrice = 1.25m, VolumePrice = 3m, VolumeQuantity = 3 }, Quantity = 1 }, new CartLine { Product = new Product { Code = "B", RetailPrice = 4.25m }, Quantity = 2 }, new CartLine { Product = new Product { Code = "C", RetailPrice = 1m, VolumePrice = 5m, VolumeQuantity = 6 }, Quantity = 3 }, new CartLine { Product = new Product { Code = "D", RetailPrice = 0.75m }, Quantity = 4 } }; }
protected void cartDetail_RowCommand(object sender, GridViewCommandEventArgs e) { int id = Int32.Parse(e.CommandArgument.ToString()); CartRepository.deleteProductFromCartByCartId(id); Response.Redirect("CartPage.aspx"); }
/// <summary> /// Adds a coupon to the Cart. /// </summary> /// <param name="param"></param> /// <returns>The lightweight CartViewModel</returns> public virtual async Task <CartViewModel> AddCouponAsync(CouponParam param) { var cart = await CartRepository.AddCouponAsync(param).ConfigureAwait(false); await CartRepository.RemoveCouponsAsync(new RemoveCouponsParam { CartName = param.CartName, CouponCodes = GetInvalidCouponsCode(cart.Coupons).ToList(), CustomerId = param.CustomerId, Scope = param.Scope }).ConfigureAwait(false); var vmParam = new CreateCartViewModelParam { Cart = cart, CultureInfo = param.CultureInfo, IncludeInvalidCouponsMessages = true, BaseUrl = param.BaseUrl }; var viewModel = await CreateCartViewModelAsync(vmParam).ConfigureAwait(false); AddSuccessMessageIfRequired(param, viewModel, param.CultureInfo); return(viewModel); }
public ActionResult IncreaseQuantity(int productId) { try { var cartInList = CartRepository.GetCartItemByProductId(productId); if (cartInList != null) { if (cartInList.StockControl.ProductAmount > cartInList.Quantity) { cartInList.Quantity = ++cartInList.Quantity; CartRepository.Update(cartInList); } else { var cartItems = CartRepository.GetCartItems(); ModelState.AddModelError(string.Empty, "Nuk ka produkt te mjaftueshem ne stok!"); return(View("~/Views/Carts/Index.cshtml", cartItems)); } } return(RedirectToAction(nameof(Index), "Carts")); } catch { return(View()); } }
public ProductController() { context = new ApplicationDbContext(); products = new ProductRepository(context); categories = new CategoryRepository(context); carts = new CartRepository(context); }
protected virtual async Task <Payment> PreparePaymentSwitch(UpdatePaymentMethodParam param, Payment activePayment) { //TODO: Remove for now, but we should void (Bug with Moneris when payment is PendingVerification). await PaymentRepository.RemovePaymentAsync(new VoidOrRemovePaymentParam { CartName = param.CartName, CultureInfo = param.CultureInfo, CustomerId = param.CustomerId, PaymentId = activePayment.Id, Scope = param.Scope }).ConfigureAwait(false); var cart = await CartRepository.AddPaymentAsync(new AddPaymentParam { BillingAddress = activePayment.BillingAddress.Clone(), CartName = param.CartName, CultureInfo = param.CultureInfo, CustomerId = param.CustomerId, Scope = param.Scope }); var newPayment = GetActivePayment(cart); return(newPayment); }
//TODO: Remove the InventoryLocationProvider and pass the FulfillmentLocationId by parameter public virtual async Task <ProcessedCart> SetFulfillmentLocationIfRequired(FixCartParam param) { var cart = param.Cart; if (!HasValidFulfillmentLocation(cart)) { var fulfillmentLocation = await InventoryLocationProvider.GetFulfillmentLocationAsync(new GetFulfillmentLocationParam { Scope = cart.ScopeId }).ConfigureAwait(false); var shipment = cart.Shipments.FirstOrDefault() ?? new Shipment(); cart = await CartRepository.UpdateShipmentAsync(new UpdateShipmentParam { CartName = cart.Name, CultureInfo = new CultureInfo(cart.CultureName), FulfillmentLocationId = fulfillmentLocation.Id, CustomerId = cart.CustomerId, FulfillmentMethodName = shipment.FulfillmentMethod?.Name, FulfillmentScheduleMode = shipment.FulfillmentScheduleMode, FulfillmentScheduledTimeBeginDate = shipment.FulfillmentScheduledTimeBeginDate, FulfillmentScheduledTimeEndDate = shipment.FulfillmentScheduledTimeEndDate, PropertyBag = shipment.PropertyBag, Id = shipment.Id, ScopeId = cart.ScopeId, ShippingAddress = shipment.Address, ShippingProviderId = shipment.FulfillmentMethod == null ? Guid.Empty : shipment.FulfillmentMethod.ShippingProviderId }).ConfigureAwait(false); } return(cart); }
public IActionResult Index() { CartRepository repositoryCart = new CartRepository(); Console.WriteLine(repositoryCart.GetAll()); return(View(repositoryCart.GetAll())); }
public virtual async Task <LightRecurringOrderCartsViewModel> GetLightRecurringOrderCartListViewModelAsync(GetLightRecurringOrderCartListViewModelParam param) { if (!RecurringOrdersSettings.Enabled) { return(new LightRecurringOrderCartsViewModel()); } var carts = await CartRepository.GetRecurringCartsAsync(new GetRecurringOrderCartsViewModelParam { Scope = param.Scope, CultureInfo = param.CultureInfo, BaseUrl = param.BaseUrl, CustomerId = param.CustomerId }).ConfigureAwait(false); var tasks = carts.Select(pc => CreateLightCartViewModelAsync(new CreateLightRecurringOrderCartViewModelParam { Cart = pc, CultureInfo = param.CultureInfo, BaseUrl = param.BaseUrl, })); var viewModels = await Task.WhenAll(tasks); return(new LightRecurringOrderCartsViewModel { RecurringOrderCarts = viewModels.OrderBy(v => v.NextOccurence).ToList(), }); }
public void InitializeTest() { _cartRepository = new CartRepository(); _cartRepository.Add(new CartItem(_products[0], 1)); _cartRepository.Add(new CartItem(_products[1], 2)); }
public virtual async Task <CartViewModel> GetRecurringOrderCartViewModelAsync(GetRecurringOrderCartViewModelParam param) { var emptyVm = GetEmptyRecurringOrderCartViewModel(); if (!RecurringOrdersSettings.Enabled) { return(emptyVm); } if (string.Equals(param.CartName, CartConfiguration.ShoppingCartName, StringComparison.OrdinalIgnoreCase)) { return(emptyVm); } var cart = await CartRepository.GetCartAsync(new GetCartParam { CartName = param.CartName, BaseUrl = param.BaseUrl, CultureInfo = param.CultureInfo, CustomerId = param.CustomerId, ExecuteWorkflow = true, Scope = param.Scope }).ConfigureAwait(false); var vm = await CreateCartViewModelAsync(new CreateRecurringOrderCartViewModelParam { Cart = cart, CultureInfo = param.CultureInfo, IncludeInvalidCouponsMessages = false, BaseUrl = param.BaseUrl, }); return(vm); }
/// <summary> /// Get the Shipping methods available for a shipment. Calls the GetCart to get the shipment Id. /// </summary> /// <param name="param"></param> /// <returns>The ShippingMethodsViewModel</returns> public async virtual Task <ShippingMethodsViewModel> GetRecurringCartShippingMethodsAsync(GetShippingMethodsParam param) { if (param == null) { throw new ArgumentNullException("param", "param is required"); } if (string.IsNullOrWhiteSpace(param.CartName)) { throw new ArgumentException("param.CartName is required", "param"); } if (string.IsNullOrWhiteSpace(param.Scope)) { throw new ArgumentException("param.Scope is required", "param"); } if (param.CustomerId == Guid.Empty) { throw new ArgumentException("param.CustomerId is required", "param"); } if (param.CultureInfo == null) { throw new ArgumentException("param.CultureInfo is required", "param"); } //misleading method name, creates a cart if it does not exist, not just a "get" call await CartRepository.GetCartAsync(new GetCartParam { BaseUrl = string.Empty, CartName = param.CartName, CultureInfo = param.CultureInfo, CustomerId = param.CustomerId, Scope = param.Scope }).ConfigureAwait(false); return(await GetShippingMethodsAsync(param)); }
public ProductController() { var context = new ApplicationDbContext(); ProductRepository = new ProductRepository(context); CartRepository = new CartRepository(context); }
public UnitOfWork(ProjectContext context) { _context = context; Products = new ProductRepository(_context); Categories = new CategoryRepository(_context); Users = new AuthRepository(_context); Carts = new CartRepository(_context); Orders = new OrderRepository(_context); }