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);
}
