public static BasketCheckoutMessage From(BasketCheckout model, string userId)
{
return(new BasketCheckoutMessage
{
Id = Guid.NewGuid(),
CreatedAt = DateTimeOffset.Now,
// from model
Address = model.Address,
City = model.City,
Country = model.Country,
Email = model.Email,
BasketId = model.BasketId,
CardExpiration = model.CardExpiration,
CardName = model.CardName,
CardNumber = model.CardNumber,
CvvCode = model.CvvCode,
FirstName = model.FirstName,
LastName = model.LastName,
UserId = userId,
ZipCode = model.ZipCode,
// model 에 없는거...
BasketLines = new List <BasketLineMessage>(),
BasketTotal = 0,
});
}
public async Task <ActionResult> CheckoutAsync([FromBody] BasketCheckout basketCheckout, [FromHeader(Name = "x-requestid")] string requestId)
{
var userId = _identityService.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 = this.HttpContext.User.FindFirst(x => x.Type == ClaimTypes.Name).Value;
var eventMessage = new UserCheckoutAcceptedIntegrationEvent(userId, userName, basketCheckout.IDNumber, basketCheckout.Request,
basketCheckout.PaymentTypeId, basketCheckout.GenderId, basketCheckout.Student, basketCheckout.RequestId, basket);
// Once basket is checkout, it sends an integration event to
// applying.api to convert basket to application and proceeds with
// application creation process
try
{
_eventBus.Publish(eventMessage);
}
catch (Exception ex)
{
_logger.LogError(ex, "ERROR Publishing integration event: {IntegrationEventId} from {AppName}", eventMessage.Id, Program.AppName);
throw;
}
return(Accepted());
}
public async void CheckoutReturnOkResult()
{
// Arrange
var basketCheckout = new BasketCheckout
{
UserName = "******",
TotalPrice = 1000
};
var basketCheckoutEvent = new BasketCheckoutEvent
{
UserName = "******",
TotalPrice = 500
};
var userName = "******";
//
_mockPublishEndpoint.Setup(x => x.Publish(basketCheckoutEvent, default)).Returns(Task.CompletedTask);
_mockBasketRepository.Setup(x => x.GetBasket(userName)).ReturnsAsync(new ShoppingCart());
_mockBasketRepository.Setup(x => x.DeleteBasket(userName)).Returns(Task.CompletedTask);
this.IntialieBasketController();
// Act
var result = await _sut.Checkout(basketCheckout);
// Assert OkResult
Assert.NotNull(result);
var acceptedResult = Assert.IsType <AcceptedResult>(result);
Assert.Equal(202, acceptedResult.StatusCode);
}
public async Task <IActionResult> Checkout([FromBody] BasketCheckout basketCheckout)
{
//get total price of basket
//remove the basket
//send checkout event to rabbitmq
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.PublishBasketCheckout(EventBusConstants.BasketCheckoutQueue, eventMessage);
}
catch (Exception)
{
throw;
}
return(Accepted());
}
public async Task <IActionResult> Checkout(BasketCheckout basketCheckot)
{
var basket = await _repo.GetUserBasket(basketCheckot.UserName);
if (basket == null)
{
return(NotFound("Could Not Find User Basket"));
}
var basketDeleted = await _repo.DeleteUserBasket(basketCheckot.UserName);
if (!basketDeleted)
{
return(BadRequest("Coud not Delete User Basket"));
}
var basketEvent = _mapper.Map <BasketCheckoutEvent>(basketCheckot);
basketEvent.RequestId = Guid.NewGuid();
basketEvent.TotalPrice = basket.TotalPrice;
_eventBus.PublishBasketCheckout(EventBusConstants.BasketCheckoutQueue, basketEvent);
return(Accepted());
}
public async void CheckoutReturnInternalServerError()
{
// Arrange
var basketCheckout = new BasketCheckout
{
UserName = "******",
TotalPrice = 1000
};
var basketCheckoutEvent = new BasketCheckoutEvent
{
UserName = "******",
TotalPrice = 500
};
var userName = "******";
//
_mockPublishEndpoint.Setup(x => x.Publish(basketCheckoutEvent, default)).Returns(Task.CompletedTask);
_mockBasketRepository.Setup(x => x.GetBasket(userName)).ReturnsAsync(new ShoppingCart());
_mockBasketRepository.Setup(x => x.DeleteBasket(userName)).ThrowsAsync(new System.Exception());
this.IntialieBasketController();
// Act
var result = await _sut.Checkout(basketCheckout);
// Assert OkResult
Assert.NotNull(result);
var objResult = Assert.IsType <ObjectResult>(result);
Assert.Equal(500, objResult.StatusCode.Value);
}
[ProducesResponseType((int)HttpStatusCode.BadRequest)] //400
public async Task <IActionResult> Checkout([FromBody] BasketCheckout basketCheckout)
{
//get total price of basket
//remove the basket
//send checkout event to rabbitMQ
var basket = await _basketRepository.GetBasket(basketCheckout.UserName);
if (basket == null)
{
return(BadRequest());
}
var basketRemoved = await _basketRepository.DeleteBasket(basket.UserName);
if (!basketRemoved)
{
return(BadRequest());
}
var eventMessage = _mapper.Map <BasketCheckoutEvent>(basketCheckout);
eventMessage.TotalPrice = basket.TotalPrice();
//Publish To RabbitMQ
_eventBus.PublishBasketCheckout(queueName: EventBusConstants.BasketCheckoutQueue,
publishModel: eventMessage);
return(Accepted());
}
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);
var eventMessage = new UserCheckoutAcceptedIntegrationEvent(userId, 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
await _endpoint.Publish(eventMessage);
if (basket == null)
{
return(BadRequest());
}
return(Accepted());
}
public async Task <IActionResult> Checkout(BasketCheckout basketCheckout)
{
var basket = await _basket.GetBasket(basketCheckout.UserName);
if (basket == null)
{
return(BadRequest());
}
var removebasket = await _basket.DeleteBasket(basketCheckout.UserName);
if (!removebasket)
{
return(BadRequest());
}
var eventMessage = _mapper.Map <BasketCheckoutEvent>(basketCheckout);
try
{
_eventBus.PublishBasketCheckout(EventBusConstants.BasketCheckoutQueue, eventMessage);
}
catch (Exception)
{
throw;
}
return(Accepted());
}
public async Task <IActionResult> Checkout(BasketCheckout basketCheckout, [FromHeader(Name = "x-requestid")] string requestId)
{
basketCheckout.RequestId = (Guid.TryParse(requestId, out Guid guid) && guid != Guid.Empty) ? guid : basketCheckout.RequestId;
var basket = await _basketService.GetAsync(User.Identity.Name);
if (basket == null)
{
return(BadRequest());
}
//var userName = User.Identity.Name;
//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
//await _eventBus.PublishAsync(eventMessage);
var eventMsg = basketCheckout.MapTo <UserCheckoutAccepted>();
eventMsg.Basket = basket;
return(Accepted());
}
public async Task <IActionResult> Checkout([FromBody] BasketCheckout basketCheckout)
{
// get existing basket with total price
// Create basketCheckoutEvent -- 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(eventMessage);
// remove the basket
await _repository.DeleteBasket(basket.UserName);
return(Accepted());
}
public async Task CheckoutAsync(BasketCheckout basketCheckout)
{
var response = await _httpClient.PostAsJsonAsync(
"b/api/v1/basket/checkout",
basketCheckout);
response.EnsureSuccessStatusCode();
}
public async Task CheckoutAsync(BasketCheckout basketCheckout, string token)
{
var builder = new UriBuilder(GlobalSetting.Instance.BaseEndpoint)
{
Path = $"{ApiUrlBase}/checkout"
};
var uri = builder.ToString();
await _requestProvider.PostAsync(uri, basketCheckout, token);
}
public async Task <ActionResult> Checkout([FromBody] BasketCheckout basketCheckout)
{
var success = await _mediator.Send(new CheckoutCommand { BasketCheckout = basketCheckout });
if (!success)
{
return(BadRequest());
}
return(Accepted());
}
public async Task <IActionResult> Checkout([FromBody] BasketCheckout basketCheckout)
{
var checkoutSuccessfull = await _basketService.Checkout(basketCheckout);
if (checkoutSuccessfull)
{
return(Ok());
}
return(BadRequest());
}
public async Task <ActionResult> CheckoutAsync([FromBody] BasketCheckout coursePlannerCheckout, [FromHeader(Name = "x-requestid")] string requestId)
{
var userId = _identityService.GetUserIdentity();
coursePlannerCheckout.RequestId = (Guid.TryParse(requestId, out Guid guid) && guid != Guid.Empty) ?
guid : coursePlannerCheckout.RequestId;
var planner = await _repository.GetCoursePlannerAsync(userId);
if (planner == null)
{
return(BadRequest());
}
var userName = User.FindFirst(x => x.Type == "unique_name").Value;
var eventMessage = new StudentCoursePlannerCheckoutAcceptedIntegrationEvent(
userId,
userName,
//coursePlannerCheckout.City,
//coursePlannerCheckout.Street,
//coursePlannerCheckout.State,
//coursePlannerCheckout.Country,
//coursePlannerCheckout.ZipCode,
//coursePlannerCheckout.CardNumber,
//coursePlannerCheckout.CardHolderName,
//coursePlannerCheckout.CardExpiration,
//coursePlannerCheckout.CardSecurityNumber,
//coursePlannerCheckout.CardTypeId,
//coursePlannerCheckout.Buyer,
coursePlannerCheckout.RequestId,
planner);
// Once basket is checkout, sends an integration event to
// ordering.api to convert basket to order and proceeds with
// order creation process
try
{
_logger.LogInformation("----- Publishing integration event: {IntegrationEventId} from {AppName} - ({@IntegrationEvent})", eventMessage.Id, Program.AppName, eventMessage);
_eventBus.Publish(eventMessage);
}
catch (Exception ex)
{
_logger.LogError(ex, "ERROR Publishing integration event: {IntegrationEventId} from {AppName}", eventMessage.Id, Program.AppName);
throw;
}
return(Accepted());
}
public Task CheckoutAsync(BasketCheckout basketCheckout, string token)
{
if (string.IsNullOrEmpty(token))
{
return(Task.FromResult(0));
}
if (basketCheckout != null)
{
MockCustomBasket.Items.Clear();
}
return(Task.FromResult(0));
}
public async Task CheckoutBasket(BasketCheckout model)
{
var message = new HttpRequestBuilder(_settings.BaseAddress)
.SetPath(_settings.BasketPath)
.AddToPath("Checkout")
.HttpMethod(HttpMethod.Post)
.GetHttpMessage();
var json = JsonConvert.SerializeObject(model);
message.Content = new StringContent(json, Encoding.UTF8, "application/json");
await SendRequest <BasketCheckout>(message);
}
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.GetBasketAsync(basketCheckout.Buyer);
if (basket == null)
{
_logger.LogError("Basket not exist with this user : "******"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)
{
_logger.LogError("ERROR Publishing integration event: {eventMessage.RequestId} from {Basket}");
throw;
}
return(Accepted());
}
public async Task <bool> Checkout(BasketCheckout basketCheckout)
{
var basket = await GetBasketAsync(basketCheckout.UserName);
if (basket == default)
{
return(false);
}
var basketCheckoutEvent = _mapper.Map <BasketCheckoutEvent>(basketCheckout);
basketCheckoutEvent.TotalPrice = basket.TotalPrice;
await _publishEndpoint.Publish(basketCheckoutEvent);
await DeleteBasketAsync(basketCheckout.UserName);
return(true);
}
public async Task Checkout_BasketDoesNotExist_ReturnBadRequestResult(
[Frozen] Mock <IMediator> mockMediator,
[Greedy] BasketController sut,
BasketCheckout checkout,
string requestId
)
{
//Arrange
mockMediator.Setup(x => x.Send(It.IsAny <CheckoutCommand>(), It.IsAny <CancellationToken>()))
.ReturnsAsync((CustomerBasket)null);
//Act
var actionResult = await sut.CheckoutAsync(checkout, requestId);
//Assert
var okObjectResult = actionResult as BadRequestResult;
okObjectResult.Should().NotBeNull();
}
public async Task <ActionResult> CheckoutAsync([FromBody] BasketCheckout basketCheckout, [FromHeader(Name = "x-requestid")] string requestId)
{
var userId = _identityService.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;
// TODO: Basket is checkout, send and integration event to ordering.api using _eventbus
return(Accepted());
}
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 <IActionResult> Checkout(BasketCheckout basketCheckout)
{
var basket = await _repository.GetBasketAsync(basketCheckout.UserName);
if (basket == null)
{
return(BadRequest());
}
var isRemoved = await _repository.DeleteBasketAsync(basketCheckout.UserName);
if (!isRemoved)
{
return(BadRequest());
}
var eventMessage = _mapper.Map <BasketCheckoutEvent>(basketCheckout);
eventMessage.RequestId = Guid.NewGuid();
eventMessage.TotalPrice = basket.TotalPrice;
_eventBus.PublishBasketCheckout(EventBusConstants.BasketCheckoutQueue, eventMessage);
return(Ok());
}
public void Checkout_Fails_ThrowsHttpRequestException(
[Frozen] MockHttpMessageHandler handler,
[Frozen] HttpClient httpClient,
Uri uri,
BasketApiClient sut,
BasketCheckout basket
)
{
//Arrange
httpClient.BaseAddress = uri;
handler.When(HttpMethod.Post, $"{uri}*")
.Respond(HttpStatusCode.NotFound);
//Act
Func <Task> func = async() => await sut.Checkout(basket);
//Assert
func.Should().Throw <HttpRequestException>()
.WithMessage("Response status code does not indicate success: 404 (Not Found).");
}
public async void CheckoutReturnBadResult()
{
// Arrange
var userName = "******";
var validShoppingCart = new ShoppingCart();
validShoppingCart.Items = new List <ShoppingCartItem>
{
new ShoppingCartItem
{
Quantity = 1,
// Color = "Red",
Price = 950.00M,
ProductId = "602d2149e773f2a3990b47f5",
ProductName = "IPhone X"
}
};
_mockBasketRepository.Setup(x => x.GetBasket(userName)).ReturnsAsync(validShoppingCart);
var basketCheckout = new BasketCheckout
{
UserName = userName,
TotalPrice = 1000
};
//
_mockBasketRepository.Setup(x => x.GetBasket(userName)).ReturnsAsync((ShoppingCart)null);
this.IntialieBasketController();
// Act
var result = await _sut.Checkout(basketCheckout);
// Assert BadRequestResult
Assert.NotNull(result);
var badRequestResult = Assert.IsType <BadRequestResult>(result);
Assert.Equal(400, badRequestResult.StatusCode);
}
public async Task <ActionResult> Checkout([FromBody] BasketCheckout basketCheckout)
{
// get total price of the basket
var basket = await _repository.GetBasketAsync(basketCheckout.Buyer);
if (basket == null)
{
_logger.Error("Basket not exist with this user : " + basketCheckout.Buyer);
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.DeleteBasketAsync(basketCheckout.Buyer);
return(Accepted());
}
public void Checkout_ReturnsAccepted(
[Frozen] MockHttpMessageHandler handler,
[Frozen] HttpClient httpClient,
Uri uri,
BasketApiClient sut,
BasketCheckout basket
)
{
//Arrange
httpClient.BaseAddress = uri;
handler.When(HttpMethod.Post, $"{uri}*")
.Respond(HttpStatusCode.Accepted);
//Act
async Task func() => await sut.Checkout(basket);
//Assert
var task = func();
task.GetAwaiter().GetResult();
task.IsCompleted.Should().BeTrue();
}
public async Task <ActionResult> CheckoutAsync(
[FromBody] BasketCheckout basketCheckout,
[FromHeader(Name = "X-Request-Id")] string requestId)
{
var userId = _identityService.GetUserIdentity();
var basket = await _repository.GetBasketAsync(userId);
if (basket == null)
{
return(BadRequest());
}
var eventRequestId = Guid.TryParse(requestId, out Guid parsedRequestId)
? parsedRequestId : Guid.NewGuid();
var eventMessage = new UserCheckoutAcceptedIntegrationEvent(
userId,
basketCheckout.UserEmail,
basketCheckout.City,
basketCheckout.Street,
basketCheckout.State,
basketCheckout.Country,
basketCheckout.CardNumber,
basketCheckout.CardHolderName,
basketCheckout.CardExpiration,
basketCheckout.CardSecurityCode,
eventRequestId,
basket);
// Once basket is checkout, sends an integration event to
// ordering.api to convert basket to order and proceed with
// order creation process
await _eventBus.PublishAsync(eventMessage);
return(Accepted());
}
public async Task <ActionResult> Checkout([FromBody] BasketCheckout basketCheckout)
{
// Get shopping cart
var basket = await _basketRepository.GetBasket(basketCheckout.UserName);
var basketDto = _mapper.Map <ShoppingCartResponseDto>(basket);
if (basket == null)
{
return(NotFound());
}
// Create eventMessage and send it to RabbitMQ with MassTransit
var eventMessage = _mapper.Map <BasketCheckoutEvent>(basketCheckout);
eventMessage.TotalPrice = basketDto.TotalPrice;
await _publishEndpoint.Publish(eventMessage);
// Remove the users basket.
await _basketRepository.DeleteBasket(basketDto.UserName);
return(Accepted());
}
