public IActionResult Add([FromBody] BasketRequest model)
{
BasketResponse response = new BasketResponse();
response.Error = BasketError.ModelIsNotValid;
response.Success = false;
if (ModelState.IsValid)
{
var validationResult = model.Validate();
if (validationResult == BasketError.NoError)
{
response.Error = new BasketOperations(_context).AddOrUpdateBasketItem(model);
if (response.Error == BasketError.NoError)
{
return(Ok());
}
else
{
return(BadRequest(response));
}
}
}
return(BadRequest(response));
}
public ActionResult Get(int basketId)
{
var response = new BasketResponse
{
Error = false,
Message = "",
Data = _basketBusiness.GetById(basketId)
};
return(Ok(response));
}
/// <summary>
/// Get some display text for a BASKET RESPONSE MISSED PROMOTIONS to be shown in the console.
/// </summary>
/// <param name="basketResponse"></param>
/// <returns></returns>
public static string GetMissedPromotionsDisplayText(this BasketResponse basketResponse)
{
var textOut = new StringBuilder();
textOut.AppendLine();
textOut.AppendLine("Missed Promotions");
if (basketResponse.MissedPromotions.Count > 0)
{
basketResponse.MissedPromotions.ForEach(missedPromotion =>
{
textOut.AppendLine(string.Format(" - Missed Promotion [{0}, {1}, {2}]", missedPromotion.Category, missedPromotion.PromotionTypeDisplay, missedPromotion.PromotionName));
if (missedPromotion.Criteria.BasketAdditionalSpend > 0)
{
textOut.AppendLine(string.Format(" -> Basket Additional Spend: {0}", missedPromotion.Criteria.BasketAdditionalSpend.ToString()));
}
if (missedPromotion.Criteria.TotalAdditionalSpend > 0)
{
textOut.AppendLine(string.Format(" -> Total Additional Spend: {0}", missedPromotion.Criteria.TotalAdditionalSpend.ToString()));
}
missedPromotion.Criteria.CriteriaItems.ForEach(criteriaGroup =>
{
textOut.AppendLine(string.Format(" -> {0}, {1}{2}, Only Matched Items: {3}", criteriaGroup.Source.ToString(),
criteriaGroup.AdditionalQuantity > 0 ? string.Concat("Additional Qty: ", criteriaGroup.AdditionalQuantity.ToString()) : string.Empty,
criteriaGroup.AdditionalSpend > 0 ? string.Concat("Additional Spend: ", criteriaGroup.AdditionalSpend.ToString()) : string.Empty,
criteriaGroup.OnlyMatchedItems.ToString()));
criteriaGroup.Items.ForEach(criteriaItem =>
{
textOut.AppendLine(string.Format(" -- {0} : {1} {2} {3}", criteriaItem.ItemType.ToString(),
criteriaItem.ItemType == MissedPromotionDetailItemType.Product ? criteriaItem.ProductCode : criteriaItem.AttributeToken,
criteriaItem.ItemType == MissedPromotionDetailItemType.Product ? criteriaItem.VariantCode : criteriaItem.AttributeValue,
criteriaItem.IsMatched ? string.Format(" Matched Lines: {0}", string.Concat(criteriaItem.MatchedLineIds.Select(matchedLine => matchedLine.ToString()))) : string.Empty));
});
});
textOut.AppendLine(string.Format(" -> Apply to: {0}, Action: {1}, Save From: {2}", missedPromotion.Action.AppliesTo.ToString(),
string.Concat(missedPromotion.Action.Details.ToString(),
missedPromotion.Action.Details == MissedPromotionActionDetailsDetail.PercentageDiscount ? string.Format(" [{0}%]", missedPromotion.Action.Percentage.ToString()) : string.Empty),
missedPromotion.Action.SaveFrom.ToString()));
});
}
else
{
textOut.AppendLine("There are no missed promotions for the submitted basket.");
}
return(textOut.ToString());
}
/// <summary>
/// Get some display text for a BASKET RESPONSE to be shown in the console.
/// </summary>
/// <param name="basketResponse"></param>
/// <returns></returns>
public static string GetDisplayText(this BasketResponse basketResponse)
{
var textOut = new StringBuilder();
textOut.AppendLine("Basket Response Received.");
basketResponse.Items.ForEach(responseItem =>
{
textOut.AppendLine(string.Format(" - Line [{0}] Promotions Applied: {1}", responseItem.Id, responseItem.AppliedPromotions.Count.ToString()));
responseItem.AppliedPromotions.ForEach(appliedPromo =>
{
// Get the promotion name from the summary, as this is not repeated beneath each line...
string promoName = basketResponse.Summary.AppliedPromotions.Where(summaryAppliedPromo => summaryAppliedPromo.PromotionId == appliedPromo.PromotionId).FirstOrDefault().PromotionName;
textOut.AppendLine(string.Format(" -> {0} ({1}) - {2}", promoName, appliedPromo.InstanceId.ToString(), appliedPromo.DiscountAmount.ToString("0.00")));
});
});
textOut.AppendLine(string.Format(" - Basket total discount: {0}", basketResponse.TotalDiscount.ToString("0.00")));
textOut.AppendLine(string.Format(" - Basket total points: {0}", basketResponse.TotalIssuedPoints.ToString("0.00")));
textOut.AppendLine(string.Format(" - Basket coupons issued: {0}", basketResponse.Coupons.Where(coupon => coupon.Issued).Count().ToString()));
textOut.AppendLine(string.Format(" - Total promotions applied: {0}", basketResponse.Summary.AppliedPromotions.Count.ToString()));
textOut.AppendLine();
if (basketResponse.Summary.AppliedPromotions.Count == 0)
{
textOut.AppendLine(" -> No promotions were applied,");
textOut.AppendLine(" please check that the sample promotions have been published.");
}
else
{
textOut.AppendLine(" - Promotions Summary");
basketResponse.Summary.AppliedPromotions.ForEach(appliedPromo =>
{
textOut.Append(" -> ");
textOut.Append(appliedPromo.PromotionName);
textOut.Append(" ");
textOut.Append(appliedPromo.InstanceId.ToString());
textOut.Append(" - ");
textOut.AppendLine(appliedPromo.DiscountAmount.ToString("0.00"));
textOut.Append(" -> promotion type display: ");
textOut.AppendLine(appliedPromo.PromotionTypeDisplay);
});
}
return(textOut.ToString());
}
public IActionResult EmptyBasket([FromBody] string clientId)
{
if (!string.IsNullOrEmpty(clientId))
{
new BasketOperations(_context).EmptyBasket(clientId);
return(Ok());
}
else
{
BasketResponse response = new BasketResponse();
response.Error = BasketError.ClientIdCantBeNull;
response.Success = false;
return(BadRequest(response));
}
}
public async Task <BasketItemResponse> AddBasket(BasketResponse basket)
{
try
{
var response = await _httpClient.PostAsync(BasketUrl, new StringContent(JsonConvert.SerializeObject(basket), Encoding.UTF8, "application/json"));
if (response.StatusCode == HttpStatusCode.BadRequest)
{
throw new InvalidOperationException(response.ReasonPhrase);
}
return(JsonConvert.DeserializeObject <BasketItemResponse>(await response.Content.ReadAsStringAsync()));
}
catch (HttpRequestException)
{
return(null);
}
}
public override async Task <BasketResponse> GetByUser(UserBasketRequest request, ServerCallContext context)
{
_logger.LogInformation(">>> Begin BasketService.GetByUser gRPC method.");
var user = request.User;
var basket = await _svc.GetUserBasketByUser(user);
if (basket == null)
{
throw new Exception($"User {user} do not have any basket");
}
var response = new BasketResponse();
response.User = basket.UserName;
response.Beers.AddRange(basket.BeerIds);
_logger.LogInformation("<<< Ended BasketService.GetByUser gRPC method.");
return(response);
}
public IActionResult DeleteItem([FromBody] DeleteItemRequest request)
{
BasketResponse response = new BasketResponse();
response.Error = BasketError.ModelIsNotValid;
response.Success = false;
if (ModelState.IsValid)
{
var validationResult = request.Validate();
if (validationResult == BasketError.NoError)
{
new BasketOperations(_context).DeleteItem(request);
return(Ok());
}
}
return(BadRequest(response));
}
public void TryAddProductToABasket()
{
using (var context = GetContextWithData())
using (var controller = new BasketController(context))
{
BasketRequest model = new BasketRequest();
model.ClientId = "A111";
model.Quantity = 1;
model.SKU = "P116";
IActionResult result = controller.Add(model);
Assert.IsType <BadRequestObjectResult>(result);
BasketResponse value = (BasketResponse)((Microsoft.AspNetCore.Mvc.ObjectResult)result).Value;
Assert.Equal(BasketError.ProductNotAvailable, value.Error);
Assert.False(value.Success);
Assert.Equal(0, (int)value.SuccessResult);
}
}
public async Task <ActionResult> Put(int id, BasketResponse basket)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (basket == null || id != basket.Id)
{
return(BadRequest());
}
if (!await _storage.AddOrReplaceBasketAsync(_mapper.Map <Basket>(basket)))
{
return(BadRequest("One of items does not exist or is incorrect."));
}
return(NoContent());
}
public async Task <BasketResponse> GetBasket(int customerId)
{
var currentBasket = _basket.GetBasket(customerId);
BasketResponse basketResponse = new BasketResponse();
var customerInfo = await _customerDetailsRepository.GetCustomer(customerId);
List <Task <Product> > products = new List <Task <Product> >();
foreach (var productId in currentBasket.ProductIds)
{
var productDetails = _productDetailsRepository.GetProduct(productId);
products.Add(productDetails);
}
await Task.WhenAll(products);
basketResponse.Product = products.Select(p => p.Result).ToList();
basketResponse.Customer = customerInfo;
return(basketResponse);
}
public static BasketResponse ToBasketResponse(this BasketReadModel basketReadModel)
{
var response = new BasketResponse
{
BasketId = basketReadModel.BasketId,
CustomerId = basketReadModel.CustomerId,
TotalPrice = basketReadModel.BasketItems.Sum(b => b.Price * b.Quantity),
TotalItems = basketReadModel.BasketItems.Sum(b => b.Quantity)
};
foreach (var item in basketReadModel.BasketItems)
{
response.Items.Add(new BasketItemResponse
{
ProductName = item.ProductName,
Price = item.Price,
Quantity = item.Quantity
});
}
return(response);
}
public async Task <ActionResult <BasketResponse> > Post([FromBody] BasketResponse basket)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (basket == null)
{
return(BadRequest());
}
if (await _storage.BasketExistsAsync(basket.Id))
{
return(BadRequest("Basket already exists"));
}
if (!await _storage.AddOrReplaceBasketAsync(_mapper.Map <Basket>(basket)))
{
return(BadRequest("One of items does not exist or is incorrect."));
}
return(Ok(basket));
}
private static bool BasketResponseIsValid(BasketResponse basketResponse)
{
if (basketResponse == null || basketResponse.Items == null || basketResponse.Summary == null)
return false;
if (!basketResponse.Summary.ProcessingResult)
return false;
if (basketResponse.Items.Count == 0)
return false;
return true;
}
private void ConvertResponseFromCurrency(BasketResponse response, string requestCurrencyCode)
{
var fromCurrency = _currencyService.GetCurrencyByCode(requestCurrencyCode);
if (fromCurrency == null || fromCurrency.Rate == 1)
return;
// Only bother doing this if the response is valid.
if (response == null || response.Summary == null || !response.Summary.ProcessingResult)
return;
// The basket was submitted in the currency selected by the customer. This is so that if there are promotions that are dependant on value (i.e. buy one get one for a pound!),
// these promotions can be configured per currency.
// To avoid converting on the fly (which was first attempted!) - we'll convert all values back to the base currency before the response is captured, then
// it is done in one place and all will be fine.
// Firstly deal with header values
response.BasketDiscount = _currencyService.ConvertToPrimaryExchangeRateCurrency(response.BasketDiscount, fromCurrency);
response.BasketTotal = _currencyService.ConvertToPrimaryExchangeRateCurrency(response.BasketTotal, fromCurrency);
response.DeliveryOriginalPrice = _currencyService.ConvertToPrimaryExchangeRateCurrency(response.DeliveryOriginalPrice, fromCurrency);
response.DeliveryPrice = _currencyService.ConvertToPrimaryExchangeRateCurrency(response.DeliveryPrice, fromCurrency);
response.DeliveryPromotionDiscount = _currencyService.ConvertToPrimaryExchangeRateCurrency(response.DeliveryPromotionDiscount, fromCurrency);
response.DeliveryTotalDiscount = _currencyService.ConvertToPrimaryExchangeRateCurrency(response.DeliveryTotalDiscount, fromCurrency);
response.LinesDiscount = _currencyService.ConvertToPrimaryExchangeRateCurrency(response.LinesDiscount, fromCurrency);
response.OriginalBasketTotal = _currencyService.ConvertToPrimaryExchangeRateCurrency(response.OriginalBasketTotal, fromCurrency);
response.TotalDiscount = _currencyService.ConvertToPrimaryExchangeRateCurrency(response.TotalDiscount, fromCurrency);
//response.DeliveryManualDiscount
//response.ManualDiscount
// Loop through response items BUT don't include any items added (which have not been split), as these will be 'Free products' - and the prices will already
// be in base currency.
response.Items.Where(ri => !(ri.Generated && ri.SplitFromLineId == 0))
.ToList()
.ForEach(ri =>
{
ri.LineAmount = _currencyService.ConvertToPrimaryExchangeRateCurrency(ri.LineAmount, fromCurrency);
ri.LinePromotionDiscount = _currencyService.ConvertToPrimaryExchangeRateCurrency(ri.LinePromotionDiscount, fromCurrency);
ri.OriginalAmount = _currencyService.ConvertToPrimaryExchangeRateCurrency(ri.OriginalAmount, fromCurrency);
ri.OriginalPrice = _currencyService.ConvertToPrimaryExchangeRateCurrency(ri.OriginalPrice, fromCurrency);
ri.Price = _currencyService.ConvertToPrimaryExchangeRateCurrency(ri.Price, fromCurrency);
ri.TotalDiscount = _currencyService.ConvertToPrimaryExchangeRateCurrency(ri.TotalDiscount, fromCurrency);
//ri.ManualDiscount
if (ri.AppliedPromotions != null)
{
ri.AppliedPromotions.ForEach(ap =>
{
ap.DiscountAmount = _currencyService.ConvertToPrimaryExchangeRateCurrency(ap.DiscountAmount, fromCurrency);
});
}
});
if (response.Summary.AppliedPromotions != null)
{
response.Summary.AppliedPromotions.ForEach(ap =>
{
ap.DiscountAmount = _currencyService.ConvertToPrimaryExchangeRateCurrency(ap.DiscountAmount, fromCurrency);
});
}
}
