public async Task ProcessPayment(PaymentDto input)
{
var payment = _mapper.Map <PaymentDto, Payment>(input);
var cheapPaymentGateway = new CheapPaymentGateway();
var expensivePaymentGateway = new ExpensivePaymentGateway();
var premiumPaymentGateway = new PremiumPaymentGateway();
cheapPaymentGateway.SetNext(expensivePaymentGateway).SetNext(premiumPaymentGateway);
var response = (bool?)cheapPaymentGateway.Handle(payment);
await _paymentRepository.InsertAsync(payment);
await _paymentRepository.SaveAsync();
var paymentState = new PaymentState
{
PaymentId = payment.PaymentId,
State = response switch
{
true => EPaymentState.Processed,
false => EPaymentState.Pending,
null => EPaymentState.Failed
}
};
await _paymentStateRepository.InsertAsync(paymentState);
await _paymentRepository.SaveAsync();
}
public void ValidateFailedCheapPaymentGatewayPayment()
{
var paymentDetail = new PaymentDetail();
var cheapPaymentGateway = new CheapPaymentGateway();
var expected = ResponseCodes.ERROR;
var result = cheapPaymentGateway.ProcessPayment(paymentDetail, 1);
var actual = result.Code;
Assert.Equal(expected, actual);
}
public void ValidateSuccessfulCheapPaymentGatewayPayment()
{
var paymentDetail = new PaymentDetail();
var cheapPaymentGateway = new CheapPaymentGateway();
var expected = ResponseCodes.OK;
//odd numbers fail, even(2,4,6) numbers succeed. I used 2 below
var result = cheapPaymentGateway.ProcessPayment(paymentDetail, 2);
var actual = result.Code;
Assert.Equal(expected, actual);
}
public void ShouldReturnBooleanIfNotMoreThan20()
{
var paymentDto = new PaymentDto()
{
Amount = 19
};
var cheapGateway = new CheapPaymentGateway();
var result = cheapGateway.ProcessPaymentAsync(paymentDto).Result;
result.GetType().Should().Equals(typeof(bool));
}
public void ShouldThrowExceptionIfAmountAbove20()
{
var paymentDto = new PaymentDto()
{
Amount = 500
};
var cheapGateway = new CheapPaymentGateway();
Action act = () => cheapGateway.ProcessPaymentAsync(paymentDto);
act.Should().Throw <ArgumentOutOfRangeException>();
}
public async Task PaymentStatusReturnsValidPaymentStatus()
{
//Arrange
// CheapPaymentGateway
var mockGateway = new Mock <ICheapPaymentGateway>();
var ode = mockGateway.Setup(p => p.ProcessPayment());
CheapPaymentGateway process = new CheapPaymentGateway();
var respose = process.ProcessPayment();
//Asert
Assert.True(respose is PaymentState);
}
public PaymentServiceFixture()
{
var paymentGatewayManager = new PaymentGatewayManager();
var cheapPaymentGateway = new CheapPaymentGateway(paymentGatewayManager);
var expensivePaymentGateway = new ExpensivePaymentGateway(paymentGatewayManager);
var premiumPaymentGateway = new PremiumPaymentGateway(paymentGatewayManager);
var unitOfWork = new Mock <IUnitOfWork>();
unitOfWork.Setup(uow => uow.Payments.Add(It.IsAny <Payment>()));
PaymentService = new Services.Business.PaymentService(cheapPaymentGateway, expensivePaymentGateway, premiumPaymentGateway, unitOfWork.Object);
}
public bool ProcessPayment(Card card)
{
decimal amount = card.Amount;
if (amount < 20)
{
IExternalService externalService = new CheapPaymentGateway();
isPaymentProcessed = externalService.ProcessPayment();
}
else if (amount > 20 && amount <= 500)
{
IExternalService externalService = new ExpensivePaymentGateway();
if (externalService.IsAvailable)
{
isPaymentProcessed = externalService.ProcessPayment();
}
else
{
externalService = new CheapPaymentGateway();
while (externalService.RetryCount < 1)
{
isPaymentProcessed = externalService.ProcessPayment();
}
}
}
else if (amount > 500)
{
IExternalService externalService = new PremiumPaymentGateway();
while (externalService.RetryCount < 3)
{
isPaymentProcessed = externalService.ProcessPayment();
if (isPaymentProcessed)
{
break;
}
}
}
return(isPaymentProcessed);
}
/// <summary>
/// Make payment by choosing appropriate payment gateway
/// </summary>
/// <param name="paymentRequest"></param>
/// <returns></returns>
public PaymentResponse ProcessPayment(PaymentRequest paymentRequest)
{
IPaymentGateway paymentGateway;
PaymentResponse paymentResponse;
try
{
if (paymentRequest.Amount <= 20)
{
paymentGateway = new CheapPaymentGateway(_configuration, _logger);
}
else if (paymentRequest.Amount > 20 && paymentRequest.Amount <= 500)
{
paymentGateway = new ExpensivePaymentGateway();
if (!paymentGateway.IsAvailable())
{
paymentGateway = new CheapPaymentGateway(_configuration, _logger);
}
}
else
{
paymentGateway = new PremiumPaymentGateway();
}
do
{
paymentResponse = paymentGateway.MakePayment(paymentRequest);
paymentGateway.RetryCount--;
}while (paymentGateway.RetryCount > 0 && !(paymentResponse.Status == "Success"));
return(paymentResponse);
}
catch (Exception ex)
{
ExceptionHelper.AddErrorLogs(ex, _logger, "PaymentRequest : " + JsonConvert.SerializeObject(paymentRequest));
throw;
}
}
public PaymentGatewayFactory()
{
CheapPayments = new CheapPaymentGateway();
ExpensivePayments = new ExpensivePaymentGateway();
PremiumPayments = new PremiumPaymentGateway();
}
public async Task <ActionResult <Payment> > PostPayment(Payment payment)
{
if (this.ModelState.IsValid)
{
_context.Payment.Add(payment);
PaymentState paymentState = new PaymentState {
Payment = payment, PaymentStatus = PaymentStatus.Pending
};
_context.PaymentState.Add(paymentState);
await _context.SaveChangesAsync();
if (payment.Amount <= 20)
{
ICheapPaymentGateway cheapPaymentGateway = new CheapPaymentGateway();
bool paymentProcessStatus = cheapPaymentGateway.ProcessPayment(payment);
if (paymentProcessStatus)
{
paymentState.PaymentStatus = PaymentStatus.Processed;
_context.Entry(paymentState).State = EntityState.Modified;
await _context.SaveChangesAsync();
}
else
{
paymentState.PaymentStatus = PaymentStatus.Failed;
_context.Entry(paymentState).State = EntityState.Modified;
await _context.SaveChangesAsync();
}
}
else if (payment.Amount > 20 && payment.Amount <= 500)
{
IExpensivePaymentGateway expensivePaymentGateway = new ExpensivePaymentGateway();
if (expensivePaymentGateway.isAvailable)
{
bool paymentProcessStatus = expensivePaymentGateway.ProcessPayment(payment);
if (paymentProcessStatus)
{
paymentState.PaymentStatus = PaymentStatus.Processed;
_context.Entry(paymentState).State = EntityState.Modified;
await _context.SaveChangesAsync();
}
else
{
paymentState.PaymentStatus = PaymentStatus.Failed;
_context.Entry(paymentState).State = EntityState.Modified;
await _context.SaveChangesAsync();
}
}
else
{
ICheapPaymentGateway cheapPaymentGateway = new CheapPaymentGateway();
bool paymentProcessStatus = cheapPaymentGateway.ProcessPayment(payment);
if (paymentProcessStatus)
{
paymentState.PaymentStatus = PaymentStatus.Processed;
_context.Entry(paymentState).State = EntityState.Modified;
await _context.SaveChangesAsync();
}
else
{
paymentState.PaymentStatus = PaymentStatus.Failed;
_context.Entry(paymentState).State = EntityState.Modified;
await _context.SaveChangesAsync();
}
}
}
else if (payment.Amount > 500)
{
IPremiumPaymentGateway premiumPaymentGateway = new PremiumPaymentGateway();
bool paymentProcessStatus = false;
for (int i = 0; i < 3; i++)
{
paymentProcessStatus = premiumPaymentGateway.ProcessPayment(payment);
if (paymentProcessStatus)
{
break;
}
}
if (paymentProcessStatus)
{
paymentState.PaymentStatus = PaymentStatus.Processed;
_context.Entry(paymentState).State = EntityState.Modified;
await _context.SaveChangesAsync();
}
else
{
paymentState.PaymentStatus = PaymentStatus.Failed;
_context.Entry(paymentState).State = EntityState.Modified;
await _context.SaveChangesAsync();
}
}
return(CreatedAtAction("GetPayment", new { id = payment.Id }, payment));
}
return(BadRequest(this.ModelState));
}
public void TestProcessPayment()
{
var result = new CheapPaymentGateway().ProcessPayment(new Contract.DTO.PaymentDTO());
result.Should().BeTrue();
}
public void TestCheckHealthStatus()
{
var result = new CheapPaymentGateway().CheckHealthStatus();
result.Should().BeTrue();
}
