public async Task <IActionResult> Checkout([FromBody] BasketCheckout checkout)
{
//get total price
BasketCart basket = await repository.GetBasket(checkout.UserName);
if (basket == null)
{
return(BadRequest());
}
//remove basket
bool basketRemoved = await repository.DeleteBasket(checkout.UserName);
if (!basketRemoved)
{
return(BadRequest());
}
var eventMessage = mapper.Map <BasketCheckoutEvent>(checkout);
eventMessage.RequestId = Guid.NewGuid();
eventMessage.TotalPrice = checkout.TotalPrice;
try
{
//send checkout event to rabbit
eventBus.PublishBasketCheckout(EventBusConstants.BasketCheckoutQueue, eventMessage);
}
catch (Exception)
{
throw;
}
return(Accepted());
}
public async Task <IActionResult> Checkout([FromBody] BasketCheckout basketCheckout)
{
BasketCart basket = await _repository.GetBasket(basketCheckout.UserName);
if (basket == null)
{
return(BadRequest());
}
bool basketRemoved = await _repository.DeleteBasket(basket.UserName);
if (!basketRemoved)
{
return(BadRequest());
}
BasketCheckoutEvent eventMessage = _mapper.Map <BasketCheckoutEvent>(basketCheckout);
eventMessage.RequestId = Guid.NewGuid();
eventMessage.TotalPrice = basket.TotalPrice;
try
{
_eventBus.PublishBasketCheckout(EventBusConstants.BasketCheckoutQueue, eventMessage);
}
catch (Exception)
{
throw;
}
return(Accepted());
}
public async Task <IActionResult> Checkout([FromBody] BasketCheckout basketCheckout)
{
BasketCart basketCart = await _repository.GetBasket(basketCheckout.UserName);
if (basketCart == null)
{
return(BadRequest());
}
bool deleteWasSuccessful = await _repository.DeleteBasket(basketCart.UserName);
if (deleteWasSuccessful == false)
{
return(BadRequest());
}
BasketCheckoutEvent basketCheckoutEvent = _mapper.Map <BasketCheckoutEvent>(basketCheckout);
basketCheckoutEvent.RequestId = Guid.NewGuid();
basketCheckoutEvent.TotalPrice = basketCart.TotalPrice;
try
{
_eventBusProducer.PublishBasketCheckout(EventBusConstants.BasketCheckoutQueue, basketCheckoutEvent);
}
catch (Exception)
{
throw;
}
return(Accepted());
}
public async Task <BasketCart> UpdateBasket(BasketCart basket)
{
var updated = await _context
.Redis
.StringSetAsync(basket.UserName, JsonConvert.SerializeObject(basket));
return(!updated ? null : await GetBasket(basket.UserName));
}
public async Task <BasketCart> UpdateAsync(string userName, BasketCart entryObject)
{
if (string.IsNullOrEmpty(userName))
{
throw new ApplicationValidationException("UserName is empty in UpdateAsync");
}
return(await this.uow.BasketRepository.Update(userName, entryObject));
}
public async Task <IActionResult> Post([FromBody] BasketCart basket)
{
if (basket is null)
{
return(BadRequest("The Basket to hold should not be null "));
}
return(Ok(await _repository.Update(basket)));
}
/// <summary>
/// Clear in memory objects and PERSISTED ones
/// </summary>
public void Clear()
{
sellingStatistic = null;
currentProducts = null;
basketCart = null;
PersistenceManager.DeleteFile(PersistenceManager.PERSISTENT_DATA_FILE);
PersistenceManager.DeleteFile(PersistenceManager.PERSISTENT_ITEMS_FILE);
PersistenceManager.DeleteFile(PersistenceManager.PERSISTENT_USERS_FILE);
}
public async Task <ActionResult <BasketCart> > GetBasketAsync(string userName)
{
var basket = await _repository.GetBasket(userName);
//if user first acces, should see an empty basket.
BasketCart response = basket ?? new BasketCart(userName);
//cover response with Http Verbs
return(base.Ok(response));
}
public async Task <BasketCart> UpdateBasket(BasketCart basketCart)
{
var update = await _contest.AddAsync(basketCart.UserName, JsonConvert.SerializeObject(basketCart));
if (!update)
{
return(null);
}
return(await GetBasketCart(basketCart.UserName));
}
public async Task <IActionResult> UpdateUserBasket([FromBody] BasketCart basket)
{
var result = await _repo.UpdateUserBasket(basket);
if (result == null)
{
return(BadRequest("Could Not Update User Basket"));
}
return(NoContent());
}
public async Task <BasketCart> UpdateBasket(BasketCart basket)
{
var updated = await _context.Redis.StringSetAsync(basket.UserName, JsonConvert.SerializeObject(basket));
if (updated == false)
{
return(null);
}
return(await this.GetBasket(basket.UserName));
}
public async Task <BasketCart> UpdateBasket(BasketCart basketCart)
{
var updatedBasketCart = await _context.Redis.StringSetAsync(basketCart.Username, JsonConvert.SerializeObject(basketCart));
if (!updatedBasketCart)
{
return(null);
}
return(await GetBasket(basketCart.Username));
}
public async Task <BasketCart> UpdateBasket(BasketCart basket)
{
var updated = await this._basketContext.Add <BasketCart>(basket.UserName, basket);
if (!updated)
{
return(null);
}
return(await GetBasket(basket.UserName));
}
public async Task <BasketCart> CreateBasket(BasketCart basket)
{
bool result = await _context.Redis.StringSetAsync(
basket.UserName, JsonConvert.SerializeObject(basket));
if (!result)
{
return(null);
}
return(await GetBasket(basket.UserName));
}
public async Task <BasketCart> UpdateBasket(BasketCart basket)
{
var updated = await _context
.Redis
.StringSetAsync(basket.UserName, JsonSerializer.Serialize(basket));
if (!updated)
{
return(null);
}
return(await GetBasket(basket.UserName));
}
public async Task <BasketCart> update(BasketCart basket)
{
var updated = await context.Redis
.StringSetAsync(basket.userName, JsonConvert.SerializeObject(basket));
if (!updated)
{
return(null);
}
return(await get(basket.userName));
}
public async Task <BasketCart> UpdateBasket(BasketCart basketCart)
{
string jsonBasketCart = JsonConvert.SerializeObject(basketCart);
var isUpdated = await _context.Redis.StringSetAsync(basketCart.UserName, jsonBasketCart);
if (!isUpdated)
{
return(null);
}
return(await GetBasket(basketCart.UserName));
}
public async Task <BasketCart> UpdateBasket(BasketCart basket)
{
string serializedBasket = JsonConvert.SerializeObject(basket);
bool updated = await _context.Redis.StringSetAsync(basket.UserName, serializedBasket);
if (!updated)
{
return(null);
}
else
{
return(await GetBasket(basket.UserName));
}
}
public async Task <ActionResult <BasketCart> > GetBasket(string userName)
{
var basket = await _repository.GetBasket(userName);
if (basket != null)
{
return(Ok(basket));
}
var bskt = new BasketCart();
bskt.UserName = userName;
return(Ok(bskt));
}
public async Task <IActionResult> Checkout(BasketCheckout checkout)
{
BasketCart basket = await _basketRepository.GetBasket(checkout.userName);
if (basket == null)
{
return(BadRequest());
}
var basketRemoved = await _basketRepository.DeleteBasket(basket.UserName);
if (!basketRemoved)
{
return(BadRequest());
}
//var eventMessage = _mapper.Map <BasketCheckoutEvent>(basket);
var eventMessage = new BasketCheckoutEvent {
AddressLine = checkout.AddressLine,
CardName = checkout.CardName,
CardNumber = checkout.CardNumber,
Country = checkout.Country,
CVV = checkout.CVV,
EmailAddress = checkout.EmailAddress,
Expiration = checkout.Expiration,
FirstName = checkout.FirstName,
LastName = checkout.LastName,
PaymentMethod = checkout.PaymentMethod,
State = checkout.State,
TotalPrice = checkout.TotalPrice,
userName = checkout.userName,
ZipCode = checkout.ZipCode
};
eventMessage.RequestId = Guid.NewGuid();
eventMessage.TotalPrice = basket.TotalPrice;
try
{
_eventBus.PublishBasketCheckout(EventBusConstants.BasketCheckoutQueue, eventMessage);
}
catch (Exception ex)
{
return(BadRequest());
}
return(Accepted(basket));
}
public async Task <BasketCart> UpdateBasketCart(BasketCart basketCart)
{
if (basketCart == null && string.IsNullOrEmpty(basketCart.UserName))
{
return(null);
}
var isUpdated = await _context.Redis.StringSetAsync(basketCart.UserName,
JsonConvert.SerializeObject(basketCart));
if (!isUpdated)
{
return(null);
}
return(await GetBasketCart(basketCart.UserName));
}
public async Task <IActionResult> UpdateBasket([FromBody] BasketCart cart)
{
try
{
var basket = await _basketRepository.UpdateBasket(cart);
if (basket != null)
{
return(Ok(basket));
}
return(NotFound());
}
catch (Exception ex)
{
_logger.LogError(ex.Message, ex);
return(StatusCode((int)HttpStatusCode.InternalServerError));
}
}
public async Task <ActionResult <BasketCart> > Checkout([FromBody] BasketCheckout basketCheckout)
{
try
{
// get basket
BasketCart basketCart = await _basketRepository.GetBasket(basketCheckout.UserName);
if (basketCart == null)
{
return(BadRequest());
}
// remove basket
// bool result = await _basketRepository.DeleteBasket(basketCheckout.UserName);
//
// if (result == false)
// {
// return BadRequest();
// }
BasketCheckoutEvent basketCheckoutEvent = basketCheckout.Adapt <BasketCheckoutEvent>();
basketCheckoutEvent.RequestId = Guid.NewGuid();
basketCheckoutEvent.TotalPrice = basketCart.TotalPrice.ToString(CultureInfo.InvariantCulture);
try
{
_eventBus.PublishBasketCheckout(EventBusConstant.BasketCheckoutQueue, basketCheckoutEvent);
}
catch (Exception)
{
throw;
}
return(Accepted());
}
catch (Exception)
{
return(BadRequest());
}
}
public async Task <ActionResult <BasketCart> > UpdateBasket([FromBody] BasketCart basket)
{
return(Ok(await _repository.UpdateBasket(basket)));
}
public async Task <ActionResult <BasketCart> > UpdateBasket([FromBody] BasketCart basket)
{
var updatedBasket = await _repository.UpdateBasketAsync(basket);
return(Ok(updatedBasket));
}
public async Task <ActionResult <BasketCart> > UpdateBasket([FromBody] BasketCart basketcart)
{
var basket = await _repo.UpdateBasket(basketcart);
return(Ok(basket));
}
public async Task <ActionResult <BasketCart> > UpdateBasket([FromBody] BasketCart basketCart)
{
return(Ok(await _basketBusiness.UpdateBasket(basketCart)));
}
public async Task OnGet(BasketCart basketCart)
{
basketCart.Username = "******";
var updatedBasketCart = await _context.Redis.StringSetAsync(basketCart.Username, JsonConvert.SerializeObject(basketCart));
}
public async Task <IActionResult> UpdateBasket([FromBody] BasketCart basketCart)
{
BasketCart basket = await _basketRepository.UpdateBasket(basketCart);
return(Ok(basket));
}
public async Task <ActionResult <BasketCart> > UpdateItem(BasketCart item)
{
var updatedGroup = await _repository.UpdateBasket(item);
return(Ok(updatedGroup));
}
