public async Task <CustomerBasket> UpdateBasketAsync(CustomerBasket basket) { var created = await _database.StringSetAsync(basket.BuyerId, JsonConvert.SerializeObject(basket)); if (!created) { _logger.LogInformation("Can't update the item."); return(null); } _logger.LogInformation("Basket was updated successfully"); return(await GetBasketAsync(basket.BuyerId)); }
public async Task <CustomerBasket> UpdateBasketAsync(CustomerBasket basket) { var created = await _database.StringSetAsync(basket.Id, JsonSerializer .Serialize(basket) , TimeSpan.FromDays(30) ); if (!created) { return(null); } return(await GetBasketAsync(basket.Id)); }
string BuildBasket() { var order = new CustomerBasket(AutoAuthorizeMiddleware.IDENTITY_ID); order.Items.Add(new BasketItem { ProductId = 1, ProductName = ".NET Bot Black Hoodie", UnitPrice = 10, Quantity = 1 }); return(JsonSerializer.Serialize(order)); }
// this method is used for Create or Update basket public async Task <CustomerBasket> UpdateBasketAsync(CustomerBasket basket) { // keep basket from someone user 30days in database -> ( TimeSpan.FromDays(30) ) var created = await _database.StringSetAsync(basket.Id, JsonSerializer.Serialize(basket), TimeSpan.FromDays(30)); // if basket is not already created if (!created) { return(null); } return(await GetBasketAsync(basket.Id)); }
public async Task <CustomerBasket> UpdateBasketAsync(CustomerBasket basket) { var created = await _database.StringSetAsync(basket.BuyerId, JsonConvert.SerializeObject(basket)); if (!created) { //todo log return(null); } //todo success log return(await this.GetBasketAsync(basket.BuyerId)); }
public async Task <CustomerBasket> UpdateBasketAsync(CustomerBasket customerBasket) { var created = await _database.StringSetAsync(customerBasket.BuyerId, JsonConvert.SerializeObject(customerBasket)); if (!created) { _logger.LogError("redis set 문제"); return(null); } _logger.LogInformation("redis set 성공"); return(await GetBasketAsync(customerBasket.BuyerId)); }
private async Task VerifyBasketItemPrices(CustomerBasket basket) { foreach (var item in basket.Items) { var productionItem = await _unitOfWork .Repository <Product>() .GetByIdAsync(item.Id); if (item.Price != productionItem.Price) { item.Price = productionItem.Price; } } }
string BuildBasket() { var order = new CustomerBasket("1234"); order.Items.Add(new BasketItem { ProductId = "1", ProductName = ".NET Bot Black Hoodie", UnitPrice = 10, Quantity = 1 }); return(JsonConvert.SerializeObject(order)); }
/// <summary> /// The merge. /// </summary> /// <returns> /// The <see cref="IBasket"/>. /// </returns> public override IBasket Merge() { if (AnonymousBasket.IsEmpty) { return(CustomerBasket); } CustomerBasket.Empty(); CustomerBasket.Items.Add(AnonymousBasket.Items.Select(x => x.AsLineItemOf <ItemCacheLineItem>())); CustomerBasket.Save(); return(CustomerBasket); }
public async Task <CustomerBasket> UpdateBasketAsync(CustomerBasket basket) { var created = await _database.StringSetAsync(basket.UserId, JsonConvert.SerializeObject(basket)); if (!created) { _logger.LogInformation("Problem occur persisting the item."); return(null); } _logger.LogInformation("Basket item persisted succesfully."); return(await GetBasketAsync(basket.UserId)); }
//there is not "CreateBasketAsync" method, becuase creation will be be done as well by the Update method public async Task <CustomerBasket> UpdateBasketAsync(CustomerBasket basket) { //we are going to pass to it an object of CustomerBasket entity, //and since redis stores data as strings and jsons, we need to srialize the object we passed, //then add it using the StringSetAsync, //we passed to it the Id, since the Id is stored in the CustomerBasket entity object, and created by the client angular side, not by redis ! //and we gave it a lifetime of 30 days, so the user basket wil be deleted after 30 days ! var created = await _redisDatabase.StringSetAsync(basket.Id, JsonSerializer.Serialize(basket), TimeSpan.FromDays(30)); //the StringSetAsync overwrites the existed data of a basket with a specific Id if that basket is existed, and return true //otherwise (basket of a basket Id is not existed), creates the baskt, and returns false ! //in the second case, returns null, and in the first one, returns the updated basket using the above identified GetBasketAsync method ! return(!created ? null : await GetBasketAsync(basket.Id)); }
public async Task <CustomerBasket> UpdateBasketAsync(CustomerBasket basket) { var serialised = JsonConvert.SerializeObject(basket); var expiry = TimeSpan.FromDays(30); var created = await _database.StringSetAsync(basket.Id, serialised, expiry); if (!created) { return(null); } var updatedBasket = await GetBasketAsync(basket.Id); return(updatedBasket); }
public async Task <CustomerBasket> GetBasketAsync(string guidUser, string token) { var builder = new UriBuilder(GlobalSetting.Instance.BasketEndpoint) { Path = $"{ApiUrlBase}/{guidUser}" }; var uri = builder.ToString(); CustomerBasket basket = await _requestProvider.GetAsync <CustomerBasket>(uri, token); _fixUriService.FixBasketItemPictureUri(basket?.Items); return(basket); }
public async Task <CustomerBasket> GetBasketAsync(string guidUser, string token) { UriBuilder builder = new UriBuilder(GlobalSetting.Instance.BasketEndpoint); builder.Path = guidUser; string uri = builder.ToString(); CustomerBasket basket = await _requestProvider.GetAsync <CustomerBasket>(uri, token); ServicesHelper.FixBasketItemPictureUri(basket?.Items); return(basket); }
public async Task <CustomerBasket> UpdateBasketAsync(CustomerBasket basket) { var serialised = JsonSerializer.Serialize(basket); var timeToLive = TimeSpan.FromDays(30); var created = await _database.StringSetAsync(basket.Id, serialised, timeToLive); if (!created) { return(null); } var result = await GetBasketAsync(basket.Id); return(result); }
public async Task <CustomerBasket> UpdateBasketAsync(CustomerBasket basket) { //when updating, we will simply replace existing string with the new one //timespan is matter of business decision, we will keep the basket for 30 days //trebaš uvijek voditi računa tu koliko memorije imaš var created = await _database.StringSetAsync(basket.Id, JsonSerializer.Serialize(basket), TimeSpan.FromDays(30)); if (!created) { return(null); } //ovdje deserijaliziraš return(await GetBasketAsync(basket.Id)); }
public void NewProductCountIncreasesWhenSecondProductAdded() { CustomerBasket basket = new CustomerBasket(); int productsToAdd = 5; for (int i = 0; i < productsToAdd; i++) { basket.AddProduct(bread); } basket.AddProduct(butter); int butterCount = basket.Products[butter]; Assert.AreEqual(butterCount, 1); }
public async Task <ActionResult <CustomerBasket> > CreateBasket() { var basketToAdd = new CustomerBasket() { Guid = Guid.NewGuid() }; _unitOfWork.Repository <CustomerBasket>().Add(basketToAdd); if (await _unitOfWork.Complete() > 0) { return(Ok(await _context.CustomerBaskets.Include(x => x.Items).FirstOrDefaultAsync(x => x.Guid.ToString() == basketToAdd.Guid.ToString()))); } return(BadRequest("Error on basket creation")); }
public ActionResult FinalApproval() { if (SessionParameters.Customer == null) { return(Redirect("/Customers/Signin")); } CustomerBasket list = new CustomerBasket() { Customer = SessionParameters.Customer, Baskets = db.Basket.Where(c => c.CustomerId == SessionParameters.Customer.CustomerId && c.IsArchive == false).ToList() }; ViewBag.TotalAmount = list.Baskets.Sum(c => c.Product.PriceWithOff); return(View(list)); }
public ActionResult Post([FromBody] CustomerBasket customerBasket) { if (customerBasket == null) { return(StatusCode((int)HttpStatusCode.NotModified)); } bool isModified = _cache.SetBasketToCache(customerBasket); if (!isModified) { return(StatusCode((int)HttpStatusCode.NotModified)); } return(Ok(true)); }
public void Invoke_Without_Items_Should_Display_Empty_View() { //arrange var items = new List <BasketItem>(); CustomerBasket customerBasket = new CustomerBasket { Items = items }; var vc = new BasketListViewComponent(); //act var result = vc.Invoke(customerBasket, false); //assert ViewViewComponentResult vvcResult = Assert.IsAssignableFrom <ViewViewComponentResult>(result); Assert.Equal("Empty", vvcResult.ViewName); }
public async Task <ActionResult <CustomerBasket> > UpdateBasket(CustomerBasketDto basketDto) { var basketItem = new BasketItem() { Id = basketDto.Items[0].Id, Type = basketDto.Items[0].Type, Brand = basketDto.Items[0].Brand, ProductName = basketDto.Items[0].ProductName, Price = basketDto.Items[0].Price, PictureUrl = basketDto.Items[0].PictureUrl, Quantity = basketDto.Items[0].Quantity }; var item = new List <BasketItem>(); item.Add(basketItem); var basket = new CustomerBasket() { Id = basketDto.Id, Items = item }; //_mapper.Map<CustomerBasket>(basketDto); var updatedBasket = await _basketRepository.UpdateBasketAsync(basket); return(Ok(updatedBasket)); }
public async Task <CustomerBasket> FetchBasket() { CustomerBasket basketProducts = new CustomerBasket(); basketID = _httpContextAccessor.HttpContext.Session.GetString("basketId"); using (var httpClient = new HttpClient()) { using (var response = await httpClient.GetAsync($"https://localhost:5001/api/basket/getbasket/{basketID}")) { string apiResponse = await response.Content.ReadAsStringAsync(); basketProducts = JsonConvert.DeserializeObject <CustomerBasket>(apiResponse); } } return(basketProducts); }
string BuildBasket() { var order = new CustomerBasket("9e3163b9-1ae6-4652-9dc6-7898ab7b7a00"); order.Items = new List <Microsoft.eShopOnContainers.Services.Basket.API.Model.BasketItem>() { new Microsoft.eShopOnContainers.Services.Basket.API.Model.BasketItem() { Id = "1", ProductName = "ProductName", ProductId = 1, UnitPrice = 10, Quantity = 1 } }; return(JsonConvert.SerializeObject(order)); }
public async Task Submit(string userId, string userName, string street, string city, string zipCode, string state, string country, CustomerBasket basket) { var order = new Order { OrderDate = DateTime.UtcNow, OrderStatus = OrderStatus.Submitted, UserId = userId, UserName = userName, Address = new OrderAddress { Street = street, City = city, ZipCode = zipCode, State = state, Country = country }, OrderItems = basket.Items .Select(item => new OrderItem { ProductId = item.ProductId, ProductName = item.ProductName, UnitPrice = item.UnitPrice, Units = item.Quantity, PictureUrl = item.PictureUrl }) .ToList() }; await StateManager.SetStateAsync(OrderDetailsStateName, order); await StateManager.SetStateAsync(OrderStatusStateName, OrderStatus.Submitted); await RegisterReminderAsync( GracePeriodElapsedReminder, null, TimeSpan.FromSeconds(_settings.Value.GracePeriodTime), TimeSpan.FromMilliseconds(-1)); await _eventBus.PublishAsync(new OrderStatusChangedToSubmittedIntegrationEvent( OrderId, OrderStatus.Submitted.Name, userId, userName)); }
public async Task <(string message, int status)> AddItemAsync(int customerId, BasketItem basketItem) { string message = null; int status = 0; await Task.Run(() => { var customerRecord = _cacheManager.Baskets.Where(c => c.CustomerId == customerId).FirstOrDefault(); if (customerRecord != null) { var basketItemRecord = customerRecord.Items.Where(p => p.ProductId == basketItem.ProductId).FirstOrDefault(); if (basketItemRecord != null) { message = String.Format("Product Item:{0} already exists in Customer's:{1} basket ", basketItem.ProductId, customerId); status = 500; } else { customerRecord.Items.Add(basketItem); customerRecord.TotalItems += (basketItem.Quantity); customerRecord.Subtotal += (basketItem.UnitPrice *basketItem.Quantity); message = String.Format("Product Item:{0} was added successfully! for Customer:{1}", basketItem.ProductId, customerId); status = 200; } } else { var customerBasketRecord = new CustomerBasket(); customerBasketRecord.Id = Guid.NewGuid(); customerBasketRecord.CustomerId = customerId; customerBasketRecord.Items.Add(basketItem); customerBasketRecord.TotalItems = basketItem.Quantity; customerBasketRecord.Subtotal = (basketItem.Quantity *basketItem.UnitPrice); message = String.Format("New Customer:{0} with Product Item:{1} was added successfully!", customerId, basketItem.ProductId); status = 200; _cacheManager.Baskets.Add(customerBasketRecord); } }); return(message, status); }
public async Task <CustomerBasket> UpdateBasketAsync(CustomerBasket basket) { /* * Now what we can also do inside redis, we can give things a time to live. And this is a business decision * and we need to think about how many customers we're likely to have. How many baskets are going to live * in memory. How much memory we have on our server. What makes sense from a business point of view of how long * you should store the information for in your server . */ var created = await _database.StringSetAsync(basket.Id, JsonSerializer.Serialize(basket), TimeSpan.FromDays(30)); if (!created) { return(null); } return(await GetBasketAsync(basket.Id)); }
private async Task ProcessNewPaymentIntent(CustomerBasket basket, decimal shippingPrice) { var service = new PaymentIntentService(); PaymentIntent intent; var options = new PaymentIntentCreateOptions { Amount = GetLongBasketAmount(basket, shippingPrice), Currency = "usd", PaymentMethodTypes = new List <string> { "card" } }; intent = await service.CreateAsync(options); basket.PaymentIntentId = intent.Id; basket.ClientSecret = intent.ClientSecret; }
public async Task HandleAsync(AddProductToBasket command, ICorrelationContext context) { CustomerBasket basket = await _basketRepo.GetAsync(command.BasketId); if (basket is null) { throw new MedParkException("basket_does_not_exist", $"The basket {command.BasketId} does not exist."); } BasketItem bItem = await _itemRepo.GetAsync(x => x.BasketId == basket.Id && x.ProductId == command.Item.ProductId); if (bItem != null) { throw new MedParkException("basket_already_exists", $"The product {command.Item.ProductId} has already been added to the basket."); } await _itemRepo.AddAsync(command.Item); }
public async Task <CustomerBasket> UpdateAsync(CustomerBasket basket) { var cache = await GetAsync(basket.BuyerId); //basket.Items.ForEach(p => //{ // var tmp = cache.Items.FirstOrDefault(x => x.ProductId == p.ProductId && x.Quantity != p.Quantity); // if (tmp != null) // { // tmp.Quantity = p.Quantity; // } //}); await _cache.SetStringAsync(basket.BuyerId, basket.ToJsonString()); _logger.LogInformation("Basket item persisted succesfully."); return(cache); }