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 Handle_get_request_Id_Test()
{
////Arrange
IdentifiedCommand <CreateOrderCommand, bool> reqCreateOrder = null;
_mediatorMock
.Setup(x => x.Send(
It.IsAny <IdentifiedCommand <CreateOrderCommand, bool> >(),
It.IsAny <CancellationToken>()))
.Callback <IRequest <bool>, CancellationToken>(
(req, token) => reqCreateOrder = (IdentifiedCommand <CreateOrderCommand, bool>)req)
.Returns(Task.FromResult(true));
UserCheckoutAcceptedIntegrationEvent @event = new UserCheckoutAcceptedIntegrationEvent(
"user123", null, null, null, null, null, null, null, null,
DateTime.Now, null,
333, null,
Guid.NewGuid(),
new CustomerBasket("user123")
);
// action
var handler = new UserCheckoutAcceptedIntegrationEventHandler(_mediatorMock.Object, _logger.Object);
await handler.Handle(@event);
// assert
Assert.Equal("user123", reqCreateOrder.Command.UserId);
}
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 PublishEventsThroughEventBusAsync_PendingEvents_EventsArePublished(
[Frozen] Mock <IIntegrationEventLogService> mockEventLogService,
[Frozen] Mock <IEventBus> mockEventBus,
SalesOrderIntegrationEventService sut,
Guid transactionId,
UserCheckoutAcceptedIntegrationEvent integrationEvent
)
{
//Arrange
var eventLogs = Enumerable.Repeat(
new IntegrationEventLogEntry(integrationEvent, transactionId), 3
)
.ToList();
mockEventLogService.Setup(_ => _.RetrieveEventLogsPendingToPublishAsync(
It.IsAny <Guid>()
))
.ReturnsAsync(eventLogs);
//Act
await sut.PublishEventsThroughEventBusAsync(transactionId);
//Assert
mockEventLogService.Verify(_ => _.MarkEventAsInProgressAsync(It.IsAny <Guid>()),
Times.Exactly(eventLogs.Count)
);
mockEventBus.Verify(_ => _.Publish(It.IsAny <IntegrationEvent>()),
Times.Exactly(eventLogs.Count)
);
mockEventLogService.Verify(_ => _.MarkEventAsPublishedAsync(It.IsAny <Guid>()),
Times.Exactly(eventLogs.Count)
);
}
public async Task <IActionResult> checkout()
{
Guid userId = Guid.Empty;//AddCookie();
try
{
var cart = await _cartService.GetCart(userId);
if (cart == null)
{
return(BadRequest());
}
var eventMessage = new UserCheckoutAcceptedIntegrationEvent(userId, cart);
//orderService.CreateOrder(cartDto);
//_eventBus.Publish(eventMessage);
return(Ok(cart));
}
catch (Exception e)
{
throw;
}
}
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 Task <IActionResult> Checkout([FromBody] BasketCheckout basketCheckout)
{
var userId = _identitySvc.GetUserIdentity();
var userName = User.FindFirst(x => x.Type == "unique_name").Value;
basketCheckout.RequestId = Guid.NewGuid();
var basket = await _repository.GetBasketAsync(userId);
if (basket == null)
{
return(BadRequest());
}
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 Handle(UserCheckoutAcceptedIntegrationEvent integrationEvent)
{
if (integrationEvent.RequestId != Guid.Empty)
{
var orderingProcess = GetOrderingProcessActor(integrationEvent.RequestId);
await orderingProcess.Submit(integrationEvent.UserId, integrationEvent.UserName,
integrationEvent.Street, integrationEvent.City, integrationEvent.ZipCode,
integrationEvent.State, integrationEvent.Country, integrationEvent.Basket);
}
else
{
_logger.LogWarning("Invalid IntegrationEvent - RequestId is missing - {@IntegrationEvent}", integrationEvent);
}
}
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;
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
{
_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 async Task AddAndSaveEventAsync_SaveEventAsyncIsCalled(
[Frozen] Mock <IIntegrationEventLogService> mockEventLogService,
SalesOrderIntegrationEventService sut,
UserCheckoutAcceptedIntegrationEvent integrationEvent
)
{
//Arrange
//Act
await sut.AddAndSaveEventAsync(integrationEvent);
//Assert
mockEventLogService.Verify(_ => _.SaveEventAsync(
It.IsAny <IntegrationEvent>(),
It.IsAny <Guid>()
));
}
public async Task Handle_GuidNotEmpty_CommandIsSent(
[Frozen] Mock <IMediator> mockMediator,
UserCheckoutAcceptedIntegrationEventHandler sut,
UserCheckoutAcceptedIntegrationEvent integrationEvent
)
{
//Arrange
//Act
await sut.Handle(integrationEvent);
//Assert
mockMediator.Verify(_ => _.Send(
It.IsAny <IRequest <bool> >(),
It.IsAny <CancellationToken>()
));
}
public async Task Handle_mediator_sent_once_Test()
{
////Arrange
UserCheckoutAcceptedIntegrationEvent @event = new UserCheckoutAcceptedIntegrationEvent(
"user123", null, null, null, null, null, null, null, null,
DateTime.Now, null,
333, null,
Guid.NewGuid(),
new CustomerBasket("user123")
);
// action
var handler = new UserCheckoutAcceptedIntegrationEventHandler(_mediatorMock.Object, _logger.Object);
await handler.Handle(@event);
// assert
_mediatorMock.Verify(
h => h.Send(
It.IsAny <IdentifiedCommand <CreateOrderCommand, bool> >(),
It.IsAny <CancellationToken>()),
Times.Once());
}
public async Task <IActionResult> Checkout([FromBody] CartCheckout CartCheckout,
[FromHeader(Name = "x-requestid")] string requestId)
{
var borrowerId = _service.GetUserIdentity();
CartCheckout.RequestId = (Guid.TryParse(requestId, out Guid guid) && guid != Guid.Empty) ?
guid : CartCheckout.RequestId;
var Cart = await _repository.GetCartAsync(borrowerId);
if (Cart is null)
{
return(BadRequest());
}
var eventMessage = new UserCheckoutAcceptedIntegrationEvent();
_eventBus.Publish(eventMessage);
return(Accepted());
}
public async Task <ActionResult> CheckoutAsync([FromBody] BasketCheckout basketCheckout, [FromHeader(Name = "x-requestid")] string requestId)
{
var userId = basketCheckout.Buyer;
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 = userId;
var checkoutEventMessage = new UserCheckoutAcceptedIntegrationEvent(userId: userId,
userName: userName, city: basketCheckout.City, street: basketCheckout.Street,
state: basketCheckout.State, country: basketCheckout.Country,
zipCode: basketCheckout.ZipCode, cardNumber: basketCheckout.CardNumber, cardHolderName: basketCheckout.CardHolderName,
cardExpiration: basketCheckout.CardExpiration, cardSecurityNumber: basketCheckout.CardSecurityNumber,
cardTypeId: basketCheckout.CardTypeId, buyer: userName, requestId: basketCheckout.RequestId,
basket: 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(checkoutEventMessage);
}
catch (Exception ex)
{
_logger.LogError(ex, "ERROR Publishing integration event: {IntegrationEventId} from Basket", checkoutEventMessage.Id);
throw;
}
return(Accepted());
}
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 OrderStarted(UserCheckoutAcceptedIntegrationEvent @event)
{
var handler = _serviceProvider.GetRequiredService <UserCheckoutAcceptedIntegrationEventHandler>();
await handler.Handle(@event);
}
