public static async Task AddPaymentsAsync(this IPaymentRepository paymentRepository, params Payment[] payments)
{
foreach (var payment in payments)
{
await paymentRepository.AddPaymentAsync(payment);
}
}
public async Task ShouldPassAddPayment()
{
_paymentRepository = new MockPaymentRepository();
var payment = new Payment
{
MerchantId = "bd2347d5-98b3-4d4e-8773-4eb4b33ca0d6",
MerchantTransactionReference = "TestReference2",
PaymentMethod = 0,
Amount = 22.99M,
Currency = Currency.GBP,
PaymentDetails = new PaymentDetails
{
CardNumber = "1234567812345678",
Name = "Test Name",
ExpiryMonth = "12",
ExpiryYear = "2030",
CVV = "123",
Scheme = CardScheme.Mastercard,
Type = CardType.Credit,
Address = new Address
{
Number = 1,
Street = "Test Road",
City = "Test City",
County = "Test County",
PostCode = "TE5 7PC"
}
}
};
var result = await _paymentRepository.AddPaymentAsync(payment);
Assert.IsTrue(result.PaymentDetails.Name == "Test Name");
}
public async Task <IActionResult> Post([FromBody] Payment payment)
{
try
{
_logger.LogInformation($"Post Payment Request - Merchant ID: {payment.MerchantId} + Payment Ref: {payment.MerchantTransactionReference}");
Merchant merchant = await _merchantRepository.GetMerchantAsync(payment.MerchantId);
if (merchant == null)
{
_logger.LogWarning($"Merchant ({payment.MerchantId}) not found");
return(new BadRequestObjectResult("No Such Merchant Found"));
}
payment.MerchantId = merchant.Id;
_logger.LogInformation("Attempting to connect to bank");
var bankResponse = await _bankProcessor.ProcessPaymentAsync(payment);
_logger.LogInformation("Bank process complete");
Payment storedPayment = await _paymentRepository.AddPaymentAsync(bankResponse);
_logger.LogInformation("Payment Processed");
return(new OkObjectResult(payment));
}
catch (Exception e)
{
_logger.LogError(e.ToString());
return(new StatusCodeResult(500));
}
}
public async Task Add_ShouldDelegateCallToRepository()
{
var payment = PaymentBuilder.Valid.Build();
await _sut.AddAsync(payment);
A.CallTo(() => _paymentRepository.AddPaymentAsync(payment)).MustHaveHappened(1, Times.Exactly);
}
public async Task GetUserBalanceList_WithPaymentFromUser_ShouldReturnPositiveBalance()
{
var payment = new PaymentBuilder("Eric").WithPaymentLine("Eric", 10).Build();
await _paymentRepository.AddPaymentAsync(payment);
var result = (await _sut.GetUserBalanceList()).ToArray();
result.Should().HaveCount(5);
result.Select(e => e.Balance).Should().AllBeEquivalentTo(0);
}
public async Task <ActionResult <PaymentDto> > AddPayment([FromBody] Payment payment)
{
var query = await _repository.AddPaymentAsync(payment);
if (query != null)
{
await _repository.CommitAsync();
}
return(query.Entity.Adapt <PaymentDto>());
}
private async Task <PaymentEntity> SavePaymentAsync(PaymentWriteModel paymentModel)
{
var payment = PreparePaymentEntityToSave(paymentModel);
await ChargeUserAccountBalanceAsync(paymentModel);
var paymentEntity = await _paymentRepository.AddPaymentAsync(payment);
await _paymentRepository.SaveChangesAsync();
return(paymentEntity);
}
public async Task <IActionResult> InsertPaymentAsync([FromBody] Payment payment)
{
try
{
return(StatusCode(StatusCodes.Status200OK, await _payment.AddPaymentAsync(payment)));
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
_logger.LogError(ex.StackTrace);
return(StatusCode(StatusCodes.Status500InternalServerError, ex.Message));
}
}
public async Task AddPayment_ShouldAddPayment()
{
var payment = new PaymentBuilder("TestUser")
.WithDescription("TestExpense")
.WithPaymentLine("TestUser", 10.5m)
.Build();
await _paymentRepository.AddPaymentAsync(payment);
var fetchedPayment = (await _paymentRepository.FindPaymentsPayedBy("TestUser")).Single();
fetchedPayment.Should().BeEquivalentTo(payment);
}
public async Task <Payment> CreateCardPaymentAsync(Guid merchantId, CardPaymentRequestDto requestDto)
{
//Depending on the card payment we may want to route to different acquirers
//in this example we only have bankOfIreland but in future we can add more here
var acquirerBankToUse = _acquirerBankSelectionService.GetAcquirerBankToUse(requestDto);
var payment = await _paymentRepository.AddPaymentAsync(acquirerBankToUse, merchantId, requestDto);
switch (acquirerBankToUse)
{
case AcquirerBank.BankOfIreland:
return(await _bankOfIrelandAcquiringBankService.CreatePaymentAsync(merchantId : merchantId, paymentId : payment.PaymentId, requestDto));
default:
throw new ArgumentException($"Unable able to support AcquirerBank {acquirerBankToUse}");
}
}
public async Task <IActionResult> Post([FromBody] PostPaymentRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var paymentId = Guid.NewGuid();
try
{
var payment = _mapper.Map <Payment>(request);
payment.Id = paymentId;
payment.CardNumber = _encryptionService.Encrypt(request.CardNumber);
var bankRequest = _mapper.Map <BankRequest>(request);
await _paymentRepository.AddPaymentAsync(payment);
_logger.LogInformation($"POST - Starting request to bank for payment {payment.Id}");
var bankResponse = await _bankRequestService.PostBankRequestAsync(bankRequest);
payment.BankResponseId = bankResponse.Id;
payment.PaymentStatus = bankResponse.PaymentStatus;
await _paymentRepository.UpdatePaymentAsync(payment);
var postPaymentResponse = new PostPaymentResponse {
PaymentId = payment.Id
};
return(Ok(postPaymentResponse));
}
catch (Exception ex)
{
_logger.LogError($"POST - Failed due to exception ${ex.GetType()} with error ${ex.Message} for request ${paymentId}");
return(StatusCode(500));
}
}
public async Task <ActionResult <OrderModel> > PayForOrderAsync(int orderId, UserDetailsModel userDetails)
{
try
{
_logger.LogInformation("{Username} has started payment for the order with OrderId {OrderId}.",
userDetails.Username, orderId);
if (userDetails.CardAuthorizationInfo.ToLower() != "authorized" &&
userDetails.CardAuthorizationInfo.ToLower() != "unauthorized")
{
throw new ArgumentException("CardAuthorizationInfo is not valid.");
}
var orderRequestDto = new OrderRequestDto {
OrderId = orderId
};
_rpcClient.Open();
var order = _rpcClient.Call(orderRequestDto);
_rpcClient.Close();
if (order.OrderId == 0)
{
throw new ArgumentException("No order with such id.");
}
if (userDetails.Username != order.Username)
{
throw new ArgumentException("Usernames in order and user details should be equal.");
}
if (order.Status.ToLower() != "collecting")
{
throw new InvalidOperationException("Order status should be \"Collecting\".");
}
switch (userDetails.CardAuthorizationInfo.ToLower())
{
case "authorized":
order.PaymentId = DateTime.Now.Ticks;
order.Status = "Paid";
break;
case "unauthorized":
order.PaymentId = DateTime.Now.Ticks;
order.Status = "Failed";
break;
}
var payment = new Payment
{
PaymentId = order.PaymentId.Value,
OrderId = order.OrderId,
Username = order.Username,
TotalCost = order.TotalCost,
IsPassed = order.Status == "Paid" ? true : false
};
await _paymentRepository.AddPaymentAsync(payment);
var payForOrderDto = _mapper.Map <PayForOrderDto>(order);
_rabbitManager.Publish(payForOrderDto, "PaymentService_OrderExchange", ExchangeType.Direct, "PayForOrder");
_logger.LogInformation("{Username} has finished payment for the order with OrderId {OrderId} with status {Status}.",
order.Username, order.OrderId, order.Status);
return(order);
}
catch (TimeoutException e)
{
_logger.LogInformation("{Username} has failed to perform payment for the order with OrderId {OrderId}.",
userDetails.Username, orderId);
return(StatusCode(408, e.Message));
}
catch (Exception e)
{
_logger.LogInformation("{Username} has failed to perform payment for the order with OrderId {OrderId}.",
userDetails.Username, orderId);
return(BadRequest(e.Message));
}
}
public async Task AddAsync(Payment payment)
{
(await CreateValidator.ValidateAsync(payment)).ThrowIfInvalid();
await _paymentRepository.AddPaymentAsync(payment);
}
