public async Task CanGetPaymentAction()
{
PaymentRequest <CardSource> paymentRequest = TestHelper.CreateCardPaymentRequest();
PaymentResponse paymentResponse = await _api.Payments.RequestAsync(paymentRequest);
IEnumerable <PaymentAction> actionsResponse = await _api.Payments.GetActionsAsync(paymentResponse.Payment.Id);
actionsResponse.ShouldNotBeNull();
actionsResponse.ShouldHaveSingleItem();
PaymentProcessed payment = paymentResponse.Payment;
PaymentAction paymentAction = actionsResponse.SingleOrDefault();
paymentAction.ShouldNotBeNull();
paymentAction.Id.ShouldBe(payment.ActionId);
paymentAction.ProcessedOn.ShouldBeGreaterThanOrEqualTo(payment.ProcessedOn);
paymentAction.Approved.ShouldBeTrue();
paymentAction.Approved.ShouldBe(payment.Approved);
paymentAction.ResponseCode.ShouldBe(payment.ResponseCode);
paymentAction.ResponseSummary.ShouldBe(payment.ResponseSummary);
paymentAction.Reference.ShouldBe(payment.Reference);
paymentAction.AuthCode.ShouldBe(payment.AuthCode);
paymentAction.Type.ShouldBe(ActionType.Authorization);
paymentAction.Links.ShouldNotBeNull();
}
public async Task GetTracking()
{
//Arrange
var fakeRepo = new Mock <ITrackingRepository>();
List <EventBase> events = new List <EventBase>();
string bookingId = "1e4199f0-907f-4acc-b886-b12b0323c108";
PaymentProcessed paymentProc = new PaymentProcessed(bookingId, "Payment is Completed",
Guid.NewGuid(), "PaymentProcessed", DateTime.Now);
OrderPicked orderPicked = new OrderPicked(bookingId, "Order is picked from Origin", Guid.NewGuid(),
"OrderPicked", DateTime.Now);
events.Add(paymentProc);
events.Add(orderPicked);
Track tracking = new Track(events);
fakeRepo.Setup(m => m.GetTrackingAsync(It.IsAny <string>())).Returns(Task.FromResult(tracking));
var sut = new TrackingSerivceWithoutCache(fakeRepo.Object);
//Act
var result = await sut.FindByIdAsync(bookingId);
var jArray = JArray.Parse(result.TrackingHistory);
var item = JObject.FromObject(jArray[0]);
//Assert
result.BookingId.ShouldBe(bookingId);
result.ShouldBeOfType <TrackingDTO>();
item.GetValue("Description").ShouldBe("Payment is Completed");
item.GetValue("BookingOrderId").ShouldBe(bookingId);
}
private static PaymentProcessed BuildPaymentProcessed(ProcessPiggyPayment processPayment, PiggyPaymentStatus status)
{
var paymentProcessed = new PaymentProcessed();
processPayment.CopyPayment(paymentProcessed);
paymentProcessed.ProcessedAt = DateTime.UtcNow;
paymentProcessed.Status = status.Status.ToString();
paymentProcessed.AcquirerPaymentId = status.PaymentId;
return(paymentProcessed);
}
public async Task Handle(PaymentProcessedIntegrationEvent eventMsg)
{
List <EventBase> events = new List <EventBase>();
if (eventMsg.Id != Guid.Empty)
{
try
{
Track trackings = await _trackingContext.GetEventVersion(eventMsg.BookingOrderId);
if (trackings == null)
{
trackings = new Track();
}
string description = string.Empty;
if (eventMsg.PaymentStatus == PaymetStatus.Completed)
{
description = "Payment Done";
}
else if (eventMsg.PaymentStatus == PaymetStatus.Canceled)
{
description = "Payment Failed";
}
else if (eventMsg.PaymentStatus == PaymetStatus.Pending)
{
description = "Payment Pending";
}
var messageType = _assemblyTypes
.Where(t => t.Name.Contains("PaymentProcessed")).FirstOrDefault().
Name.ToString();
PaymentProcessed eventPaymentProcessed = new
PaymentProcessed(eventMsg.BookingOrderId, description, eventMsg.Id, messageType, eventMsg.CreationDate);
events.AddRange(trackings.PaymentProcessed(eventPaymentProcessed));
trackings.Version = trackings.OriginalVersion + 1;
await _trackingContext.SaveTrackingAsync(eventMsg.BookingOrderId, trackings.OriginalVersion,
trackings.Version, events);
}
catch (Exception e)
{
var ExceptionTelemetry = new ExceptionTelemetry(e);
ExceptionTelemetry.Properties.Add("PaymentProcessedIntegrationEvent", eventMsg.BookingOrderId);
ExceptionTelemetry.SeverityLevel = SeverityLevel.Critical;
telemetry.TrackException(ExceptionTelemetry);
throw; //Throw exception for service bus to abandon the message
}
}
}
public async Task Test_UserProfileSaved()
{
var config = IntegrationTestBase.InitConfiguration();
var context = new MongoContext(config);
var repo = new PaymentRepository(context);
var payment = new PaymentProcessed(config["User"], 0, "USD", "Permanent", 1000, Guid.NewGuid().ToString(), DateTime.UtcNow);
await repo.SavePaymentAsync(payment);
Assert.Pass();
}
public void CanConvertToCardSource()
{
var source = new CardSourceResponse();
var payment = new PaymentProcessed
{
Source = source
};
payment.Source.AsCard().ShouldBeOfType <CardSourceResponse>();
payment.Source.AsCard().ShouldBe(source);
}
public void CanConvertToAlternativePaymentSource()
{
var source = new AlternativePaymentSourceResponse();
var payment = new PaymentProcessed
{
Source = source
};
payment.Source.AsAlternativePayment().ShouldBeOfType <AlternativePaymentSourceResponse>();
payment.Source.AsAlternativePayment().ShouldBe(source);
}
private IEnumerable <EventBase> Handle(PaymentProcessed e)
{
OrderHistory paymentProcessed = new OrderHistory();
paymentProcessed.BookingOrderId = e.BookingId;
paymentProcessed.DateTime = e.Date.ToString();
paymentProcessed.Description = e.Description;
paymentProcessed.OrderState = typeof(PaymentProcessed).ToString();
orderHistory.Add(paymentProcessed);
return(new EventBase[] { e });
}
public async Task SaveAsync(PaymentProcessed @event)
{
var paymentHistory = new PaymentHistory();
paymentHistory.Id = Guid.NewGuid();
paymentHistory.AcquirerPaymentId = @event.AcquirerPaymentId;
paymentHistory.Processed = true;
paymentHistory.ProcessedAt = @event.ProcessedAt;
paymentHistory.Status = @event.Status;
@event.CopyPayment(paymentHistory);
await _historyRepository.AddAsync(paymentHistory);
}
private void paymentProcessedHandler(PaymentProcessed paymentProcessed)
{
var order = _orderRepository.Get(paymentProcessed.OrderId);
try
{
if (paymentProcessed.Success)
{
_notificationService.SendPaymentReceived(order);
}
else
{
_notificationService.SendPaymentReview(order);
}
}
catch (Exception ex)
{
Logger.Error("Failed to send email: {0}", ex);
}
}
public async Task SavePayment([ActivityTrigger] PaymentProcessed processed, ILogger log)
{
try
{
log.LogInformation("Started SavePayment");
var p = await Repository.PaymentExistsAsync(processed);
if (p)
{
log.LogInformation("Payment already exists");
}
else
{
await Repository.SavePaymentAsync(processed);
}
log.LogInformation("Exited SavePayment");
}
catch (Exception e)
{
log.LogInformation(e.Message);
}
}
private void StorePaymentInTempData(PaymentProcessed payment)
{
TempData[nameof(PaymentProcessed)] = _serializer.Serialize(payment);
}
public async Task UpdateBookingModelInCache(Message msg)
{
RedisCacheService rCache = new RedisCacheService();
List <EventBase> events = new List <EventBase>();
Track tracking = new Track();
var bookingId = string.Empty;
List <OrderHistory> trackingHistory = new List <OrderHistory>();
try
{
if (msg.Label == "BookingAdd")
{
BookingAddIntegrationEvent eventMsg = JsonConvert.DeserializeObject <BookingAddIntegrationEvent>(Encoding.UTF8.GetString(msg.Body));
string messageType = "BookingCreated";
BookingCreated bookingCreated = new
BookingCreated(eventMsg.BookingId, string.Empty, eventMsg.Id
, messageType, eventMsg.CreationDate, eventMsg.Origin, eventMsg.Destination);
bookingId = eventMsg.BookingId;
tracking.BookingAdd(bookingCreated);
}
else if (msg.Label == "OrderPicked")
{
OrderPickedIntegrationEvent eventMsg = JsonConvert.DeserializeObject <OrderPickedIntegrationEvent>(Encoding.UTF8.GetString(msg.Body));
string messageType = "OrderPicked";
OrderPicked orderPicked = new
OrderPicked(eventMsg.BookingId, eventMsg.Description, eventMsg.Id
, messageType, eventMsg.CreationDate);
bookingId = eventMsg.BookingId;
tracking.OrderPicked(orderPicked);
}
else if (msg.Label == "OrderTransit")
{
OrderTransitIntegrationEvent eventMsg = JsonConvert.DeserializeObject <OrderTransitIntegrationEvent>(Encoding.UTF8.GetString(msg.Body));
string messageType = "OrderInTransit";
OrderInTransit orderInTransit = new
OrderInTransit(eventMsg.BookingId, eventMsg.Description, eventMsg.Id
, messageType, eventMsg.CreationDate);
bookingId = eventMsg.BookingId;
tracking.OrderInTransit(orderInTransit);
}
else if (msg.Label == "OrderDelivered")
{
OrderDeliveredIntegrationEvent eventMsg = JsonConvert.DeserializeObject <OrderDeliveredIntegrationEvent>(Encoding.UTF8.GetString(msg.Body));
string messageType = "OrderDelivered";
OrderDelivered orderDelivered = new
OrderDelivered(eventMsg.BookingId, eventMsg.Description, eventMsg.Id
, messageType, eventMsg.CreationDate, eventMsg.SignedBy);
bookingId = eventMsg.BookingId;
tracking.OrderDelivered(orderDelivered);
}
else if (msg.Label == "PaymentProcessed")
{
PaymentProcessedIntegrationEvent eventMsg = JsonConvert.DeserializeObject <PaymentProcessedIntegrationEvent>(Encoding.UTF8.GetString(msg.Body));
string messageType = "PaymentProcessed";
string description = string.Empty;
if (eventMsg.PaymentStatus == PaymetStatus.Completed)
{
description = "Payment Done";
}
else if (eventMsg.PaymentStatus == PaymetStatus.Canceled)
{
description = "Payment Failed";
}
else if (eventMsg.PaymentStatus == PaymetStatus.Pending)
{
description = "Payment Pending";
}
PaymentProcessed eventPaymentProcessed = new
PaymentProcessed(eventMsg.BookingOrderId, description, eventMsg.Id, messageType, eventMsg.CreationDate);
bookingId = eventMsg.BookingOrderId;
tracking.PaymentProcessed(eventPaymentProcessed);
}
//If Booking ID Exists
if (!string.IsNullOrEmpty(bookingId))
{
if (!string.IsNullOrEmpty(rCache.Get(bookingId)))
{
trackingHistory = JsonConvert.DeserializeObject <List <OrderHistory> >(rCache.Get(bookingId));
}
//Append new event to old events
trackingHistory.AddRange(tracking.orderHistory);
//Serialze the result
var result = JsonConvert.SerializeObject(trackingHistory);
await rCache.Remove(bookingId);
//Update the Cache
if (!string.IsNullOrEmpty(result))
{
await rCache.Save(bookingId, result);
}
}
}
catch (Exception ex)
{
throw ex;
}
}
public IEnumerable <EventBase> PaymentProcessed(PaymentProcessed e)
{
return(HandleEvent(e));
}
