public async Task <IActionResult> Checkout([FromBody] BasketCheckout basketCheckout, [FromHeader(Name = "x-requestid")] string requestId)
{
var userId = _identitySvc.GetUserIdentity();
basketCheckout.RequestId = (Guid.TryParse(requestId, out Guid guid) && guid != Guid.Empty) ?
guid : basketCheckout.RequestId;
var basket = await _repository.GetBasketAsync(userId);
if (basket == null)
{
return(BadRequest());
}
var userName = User.FindFirst(x => x.Type == "unique_name").Value;
//var eventMessage = new UserCheckoutAcceptedIntegrationEvent(userId, userName, basketCheckout.City, basketCheckout.Street,
// basketCheckout.State, basketCheckout.Country, basketCheckout.ZipCode, basketCheckout.CardNumber, basketCheckout.CardHolderName,
// basketCheckout.CardExpiration, basketCheckout.CardSecurityNumber, basketCheckout.CardTypeId, basketCheckout.Buyer, basketCheckout.RequestId, basket);
// Once basket is checkout, sends an integration event to
// ordering.api to convert basket to order and proceeds with
// order creation process
//_eventBus.Publish(eventMessage);
return(Accepted());
}
public async Task <IActionResult> Checkout([FromBody] BasketCheckout basketCheckout)
{
if (ModelState.IsValid)
{
try
{
var basket = await _basketRepository.GetBasket(basketCheckout.UserName);
if (basket == null)
{
_logger.LogInformation($"Basket with username: {basketCheckout.UserName}, not found");
return(NotFound($"Basket with username: {basketCheckout.UserName}, not found"));
}
var eventMessage = _mapper.Map <BasketCheckoutEvent>(basketCheckout);
eventMessage.EmailAddress = "*****@*****.**";
eventMessage.TotalPrice = basket.TotalPrice;
await _publishEndpoint.Publish(eventMessage);
await _basketRepository.DeleteBasket(basketCheckout.UserName);
return(Accepted());
}
catch (Exception ex)
{
_logger.LogError($"Error getting basket", ex);
throw new Exception($"Error getting basket", ex);
}
}
return(BadRequest());
}
public async Task <IActionResult> Checkout([FromBody] BasketCheckout basketCheckout)
{
try
{
//get the existing basket with total price
var basket = await _basketRepository.GetBasket(basketCheckout.UserName);
if (basket == null)
{
return(BadRequest());
}
//Create basket checkout event
var basketCheckoutEvent = _mapper.Map <BasketCheckoutEvent>(basketCheckout);
//Set the total price on checkout event
basketCheckoutEvent.TotalPrice = basket.TotalPrice;
// Send the event to the Rabbit MQ
await _publishEndpoint.Publish <BasketCheckoutEvent>(basketCheckoutEvent);
// remove the basket from redis cache
await _basketRepository.DeleteBasket(basketCheckout.UserName);
return(Accepted());
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
return(StatusCode(StatusCodes.Status500InternalServerError, "Error updating data in the database"));
}
}
public async Task <ActionResult> Checkout([FromBody] BasketCheckout basketCheckout)
{
var basket = _basketRepository.GetBasketCart(basketCheckout.UserName);
if (basket == null)
{
return(BadRequest());
}
var eventBasketCheckout = _mapper.Map <BasketCheckoutEvent>(basketCheckout);
eventBasketCheckout.RequestId = Guid.NewGuid();
eventBasketCheckout.TotalPrice = basketCheckout.TotalPrice;
try
{
_eventBus.PublishBaskCheckout(EventBusConstants.BasketCheckoutQueueName, eventBasketCheckout);
}
catch (Exception ex)
{
throw;
}
return(Accepted());
}
public async Task <ActionResult> CheckoutAsync([FromBody] BasketCheckout basketCheckout)
{
//Publish UserCheckoutIntegrationEvent and dispatch it throught eventbus
//var userIdentity = User.FindFirstValue(ClaimTypes.NameIdentifier); // will give the user's userId
//basketCheckout.UserId is the key generated on client side and is the key to customer basket
// basketCheckout.UserIdentity is the identity ID
CustomerBasket basket = await repository.GetBasketAsync(basketCheckout.UserId);
if (basket == null)
{
return(BadRequest());
}
var message = new UserCheckoutIntegrationEvent(basketCheckout.UserIdentity,
basketCheckout.UserId,
basketCheckout.UserName,
basketCheckout.Street, basketCheckout.Country,
basketCheckout.City, basketCheckout.State, basketCheckout.ZipCode,
basket);
message.Id = new Guid();
eventBus.Publish(message);
//Here I am assuming everything goes fine and the order will be created inside Ordering service, so I empty the basket
//But it might not be true, so probably I should handle the real scenario later.
//await repository.DeleteBasketAsync(basketCheckout.UserId);
//Response.Headers.Add("lookupUrl", "LatestOrder/BuyerId/{buyerId}");
return(Accepted());
}
public async Task <IActionResult> Checkout([FromBody] BasketCheckout basketCheckout)
{
// get existing basket with total price
// Set TotalPrice on basketCheckout eventMessage
// send checkout event to rabbitmq
// remove the basket
// get existing basket with total price
var basket = await _repository.GetBasket(basketCheckout.UserName);
if (basket == null)
{
return(BadRequest());
}
// send checkout event to rabbitmq
var eventMessage = _mapper.Map <BasketCheckoutEvent>(basketCheckout);
eventMessage.TotalPrice = basket.TotalPrice;
await _publishEndpoint.Publish <BasketCheckoutEvent>(eventMessage);
// remove the basket
await _repository.DeleteBasket(basket.UserName);
return(Accepted());
}
public async Task <IActionResult> CheckoutBasket([FromBody] BasketCheckout basketCheckout)
{
try
{
var basket = await _basketRepository.GetBasket(basketCheckout.UserName);
if (basket == null)
{
return(BadRequest());
}
var isDeleted = await _basketRepository.DeleteBasket(basketCheckout.UserName);
if (!isDeleted)
{
return(BadRequest());
}
var eventMessage = _mapper.Map <BasketCheckoutEvent>(basketCheckout);
eventMessage.RequestId = Guid.NewGuid();
eventMessage.TotalPrice = basket.TotalPrice;
_eventBus.PublishBasketCheckout(EventBusConstants.BasketCheckoutQueue, eventMessage);
return(Accepted());
}
catch (Exception ex)
{
_logger.LogError(ex.Message, ex);
return(StatusCode((int)HttpStatusCode.InternalServerError));
}
}
public async Task <ActionResult <BasketCart> > Checkout([FromBody] BasketCheckout basketCheckout)
{
var basket = await _repository.GetBasketAsync(basketCheckout.UserName);
if (basket == null)
{
return(NotFound());
}
var basketRemoved = await _repository.DeleteBasketAsync(basketCheckout.UserName);
if (!basketRemoved)
{
return(NotFound());
}
var eventMessage = _mapper.Map <BasketCheckoutEvent>(basketCheckout);
try
{
_eventBus.PublishBasketCheckout(EventBusConstants.BasketCheckoutQueue, eventMessage);
}
catch (Exception e)
{
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 <ActionResult <BasketCart> > Checkout([FromBody] BasketCheckout basketCheckout)
{
//get total price of basket
//remove basket
//send checkout event to rabbit mq
var basket = await _repository.GetBasket(basketCheckout.UserName);
if (basket == null)
{
return(BadRequest());
}
var basketRemoved = await _repository.DeleteBasket(basketCheckout.UserName);
if (!basketRemoved)
{
return(BadRequest());
}
var eventMessage = _mapper.Map <BasketCheckoutEvent>(basketCheckout);
eventMessage.RequestId = Guid.NewGuid();
eventMessage.TotalPrice = basket.Totalprice;
try
{
_eventBus.PubliishBasketCheckout(EventBusConstants.BasketCheckoutQueue, eventMessage);
}
catch (Exception ex)
{
throw ex;
}
return(Accepted());
}
public async Task <IActionResult> Checkout([FromBody] BasketCheckout basketCheckout)
{
var basket = await _repository.GetBasketAsync(basketCheckout.UserName);
if (basket == null)
{
return(BadRequest());
}
var basketToRemove = await _repository.DeleteBasketAsync(basket.UserName);
if (!basketToRemove)
{
return(BadRequest());
}
var 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 checkout)
{
var basket = await _repos.GetCart(checkout.Username);
if (basket == null)
{
_logger.LogError("Basket is not found for username: "******"Basket can't be removed for username: "******"Message can't be published for user " + checkout.Username + ": " + e.Message);
throw;
}
return(Accepted());
}
public async Task <ActionResult> Checkout([FromBody] BasketCheckout checkout)
{
var findBasket = await _repository.GetBasketCart(checkout.UserName);
if (findBasket == null)
{
return(BadRequest());
}
var removeBasket = await _repository.DeleteBasket(checkout.UserName);
if (!removeBasket)
{
return(BadRequest());
}
var eventMessage = _mapper.Map <BasketCheckoutEvent>(checkout);
eventMessage.RequestId = Guid.NewGuid();
eventMessage.TotalPrice = findBasket.TotalPrice;
try
{
_rabbitMQProducer.PublishBasketCheckout(EventBusConstants.BasketCheckoutQueue, eventMessage);
}
catch (Exception ex)
{
throw;
}
return(Accepted());
}
public async Task <IActionResult> Update(Guid id, BasketCheckout checkout)
{
if (id != checkout.BuyerId)
{
return(BadRequest());
}
try
{
var payload = await _context.BasketCheckouts
.FirstOrDefaultAsync(x => x.BuyerId == id);
if (payload == null)
{
return(NotFound("Item not found."));
}
_context.BasketCheckouts.Update(checkout);
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
return(NoContent());
}
public async Task <IActionResult> Checkout([FromBody] BasketCheckout basketCheckout)
{
// get total price
var basket = await _basketRepository.GetBasket(basketCheckout.UserName);
if (basket == null)
{
return(BadRequest());
}
// remove basket
var basketRemoved = await _basketRepository.DeleteBasket(basketCheckout.UserName);
if (!basketRemoved)
{
return(BadRequest());
}
// send message to RabbitMQ
var eventMessage = _mapper.Map <BasketCheckoutEvent>(basketCheckout);
eventMessage.RequestId = Guid.NewGuid();
eventMessage.TotalPrice = basket.TotalPrice;
try
{
_producer.PublishBasketCheckout(EventBusConstants.BasketCheckoutQueue, eventMessage);
}
catch (Exception)
{
throw;
}
return(Accepted());
}
public async Task <ActionResult> Checkout([FromBody] BasketCheckout basketCheckout)
{
var basket = await _repo.GetBasket(basketCheckout.UserName);
if (basket == null)
{
return(BadRequest());
}
var basketRemoved = await _repo.DeleteBasket(basket.UserName);
if (!basketRemoved)
{
return(BadRequest());
}
var eventMessage = _mapper.Map <BasketCheckoutEvent>(basketCheckout);
eventMessage.RequestId = Guid.NewGuid();
eventMessage.TotalPrice = basket.TotalPrice;
try
{
_eventBus.PublishBasketCheckout(EventBusConstants.BasketCheckoutQueue, eventMessage);
}
catch (Exception)
{
_logger.LogError($"eventMessage couldnt send");
throw;
}
return(Accepted());
}
public async Task <ActionResult> CheckoutBasket([FromBody] BasketCheckout basketCheckout)
{
var basket = await _basketRepository.GetBasket(basketCheckout.UserName);
if (basket == null)
{
return(BadRequest());
}
var basketRemoved = await _basketRepository.DeleteBasket(basketCheckout.UserName);
if (!basketRemoved)
{
return(BadRequest());
}
var eventMessage = _mapper.Map <BasketCheckoutEvent>(basketCheckout);
eventMessage.RequestId = Guid.NewGuid();
eventMessage.TotalPrice = basket.TotalPrice;
try
{
_eventBusRabbitMqProducer.PublishBasketCheckout(EventBusConstants.BasketCheckoutQueue, eventMessage);
}
catch (Exception e)
{
Console.WriteLine($"error sending eventbus message message: {e.Message}");
throw;
}
return(Accepted());
}
public async Task <IActionResult> Checkout([FromBody] BasketCheckout basketCheckout)
{
var basket = await _repository.Get(basketCheckout.UserName);
if (basket is null)
{
return(BadRequest("The basket was not found"));
}
var basketRemoved = await _repository.Delete(basket.UserName);
if (!basketRemoved)
{
return(BadRequest("It was not possible to checkot the basket"));
}
try
{
var eventMessage = _mapper.Map <BasketCheckoutEvent>(basketCheckout);
eventMessage.RequestId = Guid.NewGuid();
eventMessage.TotalPrice = basket.TotalPrice;
_basketCheckoutPublisher.Publish(eventMessage);
}
catch (Exception ex)
{
Console.WriteLine(ex);
await _repository.Update(basket);
}
return(Accepted(basketCheckout));
}
public async Task <IActionResult> Checkout([FromBody] BasketCheckout basketCheckout)
{
var basket = await _repository.GetBasket(basketCheckout.Username);
if (basket == null)
{
_logger.LogError("Basket could not be found for user: "******"Basket could not be removed for user: "******"Error: Message cannot be published for user: "******", " + e.Message);
throw;
}
return(Accepted());
}
public async Task <ActionResult> CheckoutAsync(
[FromBody] BasketCheckout basketCheckout)
{
var basket = await _basketRespository.GetBasketAsync(basketCheckout.Buyer);
if (basket == null)
{
return(BadRequest());
}
var eventMessage = new UserCheckoutAcceptedIntegrationEvent(
basketCheckout.Buyer, "", basketCheckout.City, basketCheckout.Street,
basketCheckout.State, basketCheckout.Country, basketCheckout.ZipCode,
basketCheckout.CardNumber, basketCheckout.CardHolderName,
basketCheckout.CardExpiration, basketCheckout.CardSecurityNumber,
basketCheckout.CardTypeId, basketCheckout.Buyer, basketCheckout.RequestId, basket);
// Once basket is checkout, sends an integration event to
// ordering.api to convert basket to order and proceeds with
// order creation process
try
{
_eventBus.Publish(eventMessage);
}
catch (Exception ex)
{
Log.Error(ex, "ERROR Publishing integration event: {IntegrationEventId} from {AppName}",
eventMessage.Id, Program.AppName);
throw;
}
return(Accepted());
}
public async Task <IActionResult> Checkout([FromBody] BasketCheckout basketCheckout)
{
var basket = await _repository.GetBasket(basketCheckout.Username);
if (basket == null)
{
}
return(await Accepted());
}
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 <IActionResult> Create(BasketCheckout checkout)
{
try
{
await _context.BasketCheckouts.AddAsync(checkout);
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
return(Ok(checkout.BuyerId));
}
public async Task <IActionResult> Checkout([FromBody] BasketCheckout basketCheckout)
{
var basket = await _repo.GetBasket(basketCheckout.UserName);
if (basket == null)
{
return(BadRequest());
}
var eventMessage = _mapper.Map <BasketCheckoutEvent>(basketCheckout);
await _publishEndpoint.Publish(eventMessage);
await _repo.DeleteBasket(basketCheckout.UserName);
return(Accepted());
}
public async Task <IActionResult> Checkout([FromBody] BasketCheckout basketCheckout)
{
var basket = await _repository.GetBasket(basketCheckout.Username);
if (basket == null)
{
return(BadRequest());
}
var eventMessage = _mapper.Map <BasketCheckoutEvent>(basketCheckout);
eventMessage.TotalPrice = basket.TotalPrice;
await _eventBus.Publish(eventMessage);
await _repository.DeleteBasket(basketCheckout.Username);
return(Accepted());
}
public async Task <ActionResult> CheckoutAsync([FromBody] BasketCheckout basketCheckout)
{
// remove the basket
// send checkout event to rabbitMq
var userId = "swn"; // _identityService.GetUserIdentity();
var basketRemoved = await _repository.DeleteBasketAsync(userId);
if (!basketRemoved)
{
return(BadRequest());
}
basketCheckout.RequestId = Guid.NewGuid();
basketCheckout.Buyer = userId;
basketCheckout.City = "asd";
basketCheckout.Country = "asd";
_eventBus.PublishBasketCheckout("basketCheckoutQueue", basketCheckout);
// TODO : burayı alttaki gibi yapılacak -- rabbitMQ kısmı ayrı bir class library yapılıp BasketCheckoutAcceptedIntegrationEvent class ı yapılıp 2 tarafta onu kullanacak
//var userName = this.HttpContext.User.FindFirst(x => x.Type == ClaimTypes.Name).Value;
//var eventMessage = new UserCheckoutAcceptedIntegrationEvent(userId, userName, basketCheckout.City, basketCheckout.Street,
// basketCheckout.State, basketCheckout.Country, basketCheckout.ZipCode, basketCheckout.CardNumber, basketCheckout.CardHolderName,
// basketCheckout.CardExpiration, basketCheckout.CardSecurityNumber, basketCheckout.CardTypeId, basketCheckout.Buyer, basketCheckout.RequestId, basket);
//// Once basket is checkout, sends an integration event to
//// ordering.api to convert basket to order and proceeds with
//// order creation process
//try
//{
// _eventBus.Publish(eventMessage);
//}
//catch (Exception ex)
//{
// _logger.LogError(ex, "ERROR Publishing integration event: {IntegrationEventId} from {AppName}", eventMessage.Id, "asd");
// throw;
//}
return(Accepted());
}
public async Task <ActionResult> Checkout([FromBody] BasketCheckout basketCheckout)
{
// get total price of the basket
// remove the basket
// send checkout event to rabbitMq
var basket = await _repository.GetBasket(basketCheckout.UserName);
if (basket == null)
{
_logger.LogError("Basket not exist with this user : {EventId}", basketCheckout.UserName);
return(BadRequest());
}
var basketRemoved = await _repository.DeleteBasket(basketCheckout.UserName);
if (!basketRemoved)
{
_logger.LogError("Basket can not deleted");
return(BadRequest());
}
// Once basket is checkout, sends an integration event to
// ordering.api to convert basket to order and proceeds with
// order creation process
var eventMessage = _mapper.Map <BasketCheckoutEvent>(basketCheckout);
eventMessage.RequestId = Guid.NewGuid();
eventMessage.TotalPrice = basket.TotalPrice;
try
{
_eventBus.PublishBasketCheckout(EventBusConstants.BasketCheckoutQueue, eventMessage);
}
catch (Exception ex)
{
_logger.LogError(ex, "ERROR Publishing integration event: {EventId} from {AppName}", eventMessage.RequestId, "Basket");
throw;
}
return(Accepted());
}
public async Task <ActionResult> CheckoutAsync([FromBody] BasketCheckout basketCheckout, [FromHeader(Name = "x-requestid")] string requestId)
{
// var userId = _identityService.GetUserIdentity();
var userId = "5d87b0b19281994590e08551";
basketCheckout.RequestId = (Guid.TryParse(requestId, out Guid guid) && guid != Guid.Empty) ?
guid : basketCheckout.RequestId;
var basket = await _repository.GetBasketAsync(userId);
if (basket == null)
{
return(BadRequest());
}
var userName = User.FindFirst(x => x.Type == "unique_name").Value;
return(Accepted());
}
public async Task <ActionResult> Checkout([FromBody] BasketCheckout basketCheckout)
{
// get total price of basket
// remove basket, because the queue properties include NONautodelete
// send checkout event to rabbitmq
var basket = await _repository.GetBasket(basketCheckout.UserName);
if (basket == null)
{
_logger.LogError($"Basket does not exist with the user: {basketCheckout.UserName}");
return(BadRequest());
}
// Remove the json string from redis
bool basketRemoved = await _repository.DeleteBasket(basketCheckout.UserName);
if (!basketRemoved)
{
_logger.LogError($"Basket cannot be deleted!");
return(BadRequest());
}
// Once basket is checked out, send an integration event to
// ordering.api to convert basket to order and proceeds with
// order creation process
var eventMessage = _mapper.Map <BasketCheckoutEvent>(basketCheckout);
eventMessage.RequestId = Guid.NewGuid();
eventMessage.TotalPrice = basket.TotalPrice;
try
{
_eventBus.PublishBasketCheckout(EventBusConstants.BasketCheckoutQueue, eventMessage);
return(Accepted());
}
catch (Exception ex)
{
_logger.LogError(ex, "ERROR Publishing integration event: {EventId} from {AppName}", eventMessage.RequestId, "Basket.API");
throw;
}
}
public async Task <ActionResult <BasketCheckout> > Checkout(BasketCheckout b)
{
var en = await _repository.GetBasketAsync(b.UserName);
if (en is null)
{
return(NotFound("There is no such basket for this user."));
}
var isDeleted = await _repository.DeleteAsync(b.UserName);
if (!isDeleted)
{
return(BadRequest("Deletion is unsuccessful."));
}
var p = _mapper.Map <BasketCheckoutEvent>(b);
p.RequestId = Guid.NewGuid();
p.TotalPrice = b.TotalPrice;
_eventBus.PublishBasketCheckout(EventBusEnum.BASKET_CHECKOUT_QUEUE, p);
return(Accepted());
}