public async Task <ActionResult <BankPaymentResponse> > ProcessPayment(BankPaymentRequest request)
{
if (request.PaymentAmount == 1111)
{
return(BadRequest(new BankPaymentResponse()
{
PaymentIdentifier = Guid.NewGuid().ToString(),
PaymentErrorCode = "ValidationErrorA"
}));
}
if (request.PaymentAmount == 2222)
{
return(StatusCode(500, new BankPaymentResponse()
{
PaymentIdentifier = Guid.NewGuid().ToString(),
PaymentErrorCode = "InternalErrorA"
}));
}
return(new BankPaymentResponse()
{
PaymentIdentifier = Guid.NewGuid().ToString(),
});
}
public async Task <BankPaymentResponse> Process(BankPaymentRequest paymentRequest)
{
var serialisedRequest = JsonConvert.SerializeObject(paymentRequest);
var httpResponse = await _httpClient.PostAsync("api/stub", new StringContent(serialisedRequest, Encoding.UTF8, "application/json"));
var bankResponse = await httpResponse.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <BankPaymentResponse>(bankResponse));
}
private void AssertThatBankPaymentRequetIsCorrect(BankPaymentRequest actual, ProcessPaymentRequest expected)
{
Assert.That(actual, Is.Not.Null);
Assert.That(actual.PaymentAmount, Is.EqualTo(expected.Amount));
Assert.That(actual.PaymentCurrency, Is.EqualTo(expected.Currency));
Assert.That(actual.PaymentCardNumber, Is.EqualTo(expected.CardNumber));
Assert.That(actual.PaymentExpiryMonthAndDate, Is.EqualTo(expected.ExpiryMonthAndDate));
Assert.That(actual.PaymentCvv, Is.EqualTo(expected.Cvv));
}
public async Task <IActionResult> Post(BankPaymentRequest bankPaymentRequest)
{
await Task.Delay(100);
var status = bankPaymentRequest.Amount < 50 ? "Accepted" : "Declined";
var bankResponse = new BankPaymentResponse(Guid.NewGuid(), status);
return(Ok(bankResponse));
}
public BankPaymentResponse ProcessPayment(BankPaymentRequest bankPaymentRequest)
{
_logger.LogInformation($"Sending Payment Request with correlationId {bankPaymentRequest.CorrelationId} to bank ");
var vendorBank = _bankFactory.Create(bankPaymentRequest.MerchantDetails.MerchantId);
var bankPaymentResponse = vendorBank.ProcessPayment(bankPaymentRequest);
_paymentRepository.CreatePayment(GenerateRepositoryPayment(bankPaymentRequest, bankPaymentResponse), bankPaymentRequest.CorrelationId);
return(bankPaymentResponse);
}
private PaymentInformation GenerateRepositoryPayment(BankPaymentRequest bankPaymentRequest, BankPaymentResponse bankPaymentResponse)
{
var payment = new PaymentInformation
{
Amount = bankPaymentRequest.Amount,
Id = bankPaymentResponse.PaymentId,
CardDetails = new CardDetails(bankPaymentRequest.CardDetails.CardNumber.ToString(), bankPaymentRequest.CardDetails.ExpiryDate,
bankPaymentRequest.CardDetails.Currency, bankPaymentRequest.CardDetails.CVV.ToString()),
MerchantDetails = new MerchantDetails(bankPaymentRequest.MerchantDetails.MerchantId),
PaymentStatus = bankPaymentResponse.BankPaymentResponseStatus == BankPaymentResponseStatus.Unsuccessful ? "Unsuccessful" : "Successful"
};
payment.CardDetails.Obfuscate(_dataObfuscator);
return(payment);
}
public void SaveOrUpdateBankPaymentRequest()
{
BankPaymentRequest BankPaymentRequest = CurrentBankPaymentRequest;
BankPaymentRequest.RequestNo = View.GetRequestNo;
BankPaymentRequest.ProcessDate = Convert.ToDateTime(DateTime.Today.ToShortDateString());
BankPaymentRequest.ProgressStatus = ProgressStatus.InProgress.ToString();
BankPaymentRequest.AppUser = _adminController.GetUser(CurrentUser().Id);
BankPaymentRequest.PaymentMethod = View.GetPaymentMethod;
if (CurrentBankPaymentRequest.BankPaymentRequestStatuses.Count == 0)
{
SaveBankPaymentRequestStatus();
}
GetCurrentApprover();
_controller.SaveOrUpdateEntity(BankPaymentRequest);
}
public async Task <BankPaymentResponseWithStatus> ProcessPayment(BankPaymentRequest request)
{
var url = _configuration["Dependencies:AcquiringBank:ProcessPaymentEndpointUrl"];
var content = JsonConvert.SerializeObject(request);
var httpResponse = await _client.PostAsync(url, new StringContent(content, System.Text.Encoding.Default, "application/json"));
// This class should also support non-json responses (eg an exception)
var response = JsonConvert.DeserializeObject <BankPaymentResponse>(await httpResponse.Content.ReadAsStringAsync());
return(new BankPaymentResponseWithStatus()
{
ResponseBody = response,
StatusCode = httpResponse.StatusCode
});
}
public async Task Given_valid_request_when_ProcessPayment_then_passes_correct_request_to_bank()
{
BankPaymentRequest requestSentToBank = null;
_paymentRepositoryMock.Setup(x => x.Save(It.IsAny <PaymentEntity>()))
.Returns(Task.CompletedTask);
_paymentRepositoryMock.Setup(x => x.Update(It.IsAny <PaymentEntity>()))
.Returns(Task.CompletedTask);
_bankClientMock.Setup(x => x.ProcessPayment(It.IsAny <BankPaymentRequest>()))
.Callback((BankPaymentRequest request) => requestSentToBank = request)
.ReturnsAsync(GetSuccessfulResponseFromBank());
var request = PaymentRequestBuilder.BuildValidPaymentRequest();
var response = await _client.Post <ProcessPaymentRequest, ProcessPaymentResponse>("/payments", request);
AssertThatBankPaymentRequetIsCorrect(requestSentToBank, request);
// Alternative solution is to use Verify command which compares properties of the bank request passed as an argument with the expected values
}
public PaymentGatewayServiceShould()
{
paymentReference = Guid.NewGuid();
paymentRequest = CreatePaymentRequest();
bankPaymentRequest = new BankPaymentRequest("4485063526474709", "01/20", 20.00m, "GBP", 123);
bankApiMock = new Mock <IBankApiClient>();
var bankPaymentDetail = new BankPaymentDetail(paymentReference, "Accepted", "4485063526474709", "01/20", 20.00m, "GBP", 123);
var bankPaymentResponse = new BankPaymentResponse(paymentReference, "Accepted");
var paymentResponse = new PaymentResponse(paymentReference, "Accepted");
var paymentDetail = new PaymentDetail(paymentReference, "Accepted", "4***********4709", "01/20", 20.00m, "GBP", 123);
bankApiMock.Setup(service => service.Process(It.IsAny <BankPaymentRequest>()))
.Returns(Task.FromResult(bankPaymentResponse));
bankApiMock.Setup(service => service.GetPaymentDetail(paymentReference)).Returns(Task.FromResult(bankPaymentDetail));
bankPaymentMapperMock = new Mock <IBankPaymentMapper>();
bankPaymentMapperMock.Setup(mapper => mapper.MapRequest(It.IsAny <PaymentRequest>())).Returns(bankPaymentRequest);
bankPaymentMapperMock.Setup(mapper => mapper.MapResponse(It.IsAny <BankPaymentResponse>()))
.Returns(paymentResponse);
bankPaymentMapperMock.Setup(mapper => mapper.MapDetail(It.IsAny <BankPaymentDetail>()))
.Returns(paymentDetail);
applicationLoggerMock = new Mock <IApplicationLogger>();
paymentGatewayService = new PaymentGatewayService(bankApiMock.Object, bankPaymentMapperMock.Object, applicationLoggerMock.Object);
}
public BankPaymentResponse ProcessPayment(BankPaymentRequest bankPaymentRequest)
{
if (bankPaymentRequest.Amount <= 0)
{
return new BankPaymentResponse
{
BankPaymentResponseStatus = BankPaymentResponseStatus.Unsuccessful,
PaymentId = Guid.NewGuid(),
Message = "Unsuccessful Payment - Random reason"
}
}
;
else
{
return new BankPaymentResponse
{
BankPaymentResponseStatus = BankPaymentResponseStatus.Successful,
PaymentId = Guid.NewGuid(),
Message = "Successful Payment"
}
};
}
}
public Task <BankPaymentResponse> ProcessPaymentAsync(BankPaymentRequest request)
{
if (!request.Currency.Equals("GBP"))
{
return(Task.FromResult(new BankPaymentResponse
{
Identifier = Guid.NewGuid().ToString(),
Success = false,
Error = "Unsupported currency",
}));
}
if (request.Amount > AmountLimit)
{
return(Task.FromResult(new BankPaymentResponse
{
Identifier = Guid.NewGuid().ToString(),
Success = false,
Error = "Insufficient funds",
}));
}
else if (request.Amount >= 0)
{
return(Task.FromResult(new BankPaymentResponse
{
Identifier = Guid.NewGuid().ToString(),
Success = true,
}));
}
return(Task.FromResult(new BankPaymentResponse
{
Identifier = Guid.NewGuid().ToString(),
Success = false,
Error = "Invalid amount",
}));
}
public async Task <BankPaymentResponse> RequestPayment(BankPaymentRequest payment)
{
var json = await Task.Factory.StartNew(() => JsonConvert.SerializeObject(payment));
var request = new HttpRequestMessage
{
RequestUri = BuildUri("Payment"),
Method = HttpMethod.Post,
Content = new StringContent(json, Encoding.UTF8, "application/json")
};
HttpResponseMessage response;
try
{
response = await GetClient().SendAsync(request);
}
catch (Exception e)
{
throw new BankClientException(e.Message);
}
if (!response.IsSuccessStatusCode)
{
throw new BankClientException(response);
}
var result = await response.Content.ReadAsStringAsync();
var bankResponse = JsonConvert.DeserializeObject <PaymentResponse>(result);
var clientResponse = _mapper.Map <PaymentResponse, BankPaymentResponse>(bankResponse);
clientResponse.Approved = bankResponse.StatusCode == "10000";
return(clientResponse);
}
public async Task <BankPaymentResponse> ProcessPayment(BankPaymentRequest requestModel)
{
using var request = new HttpRequestMessage
{
RequestUri = new Uri($"{_acquiringBankSettings.ApiUrl}/api/payment"),
Method = HttpMethod.Post,
Content = requestModel.ToStringContent()
};
var response = await _httpClient.SendAsync(request);
if (!response.IsSuccessStatusCode)
{
return(new BankPaymentResponse
{
PaymentIdentifier = Guid.NewGuid().ToString(),
PaymentStatus = PaymentStatus.Failed
});
}
var responseContent = await response.Content.ReadAsStringAsync();
return(responseContent.FromJson <BankPaymentResponse>());
}
public async Task <BankPaymentResponse> ProcessPayment(BankPaymentRequest requestModel)
{
using var request = new HttpRequestMessage
{
RequestUri = new Uri($"{_acquiringBankSettings.ApiUrl}/api/payment"),
Method = HttpMethod.Post,
Content = requestModel.ToStringContent()
};
var response = await _httpClient.SendAsync(request);
if (!response.IsSuccessStatusCode)
{
_logger.Error($"acquring bank payment failed. error: {response.ReasonPhrase}");
return(new BankPaymentResponse
{
PaymentStatus = PaymentStatus.Failed
});
}
var responseContent = await response.Content.ReadAsStringAsync();
return(responseContent.FromJson <BankPaymentResponse>());
}
public async Task <BankPaymentResponse> ProcessCardPost(BankPaymentRequest paymentRequest)
{
var retval = await _client.PostAsync <BankPaymentResponse>(paymentRequest, "/process-card");
return(retval);
}
public async Task <PaymentResult> ProceedPaymentAsync(BankPaymentRequest request)
{
return(await Task.Factory.StartNew <PaymentResult>(() =>
new PaymentResult { PaymentId = Guid.NewGuid().ToString(), StatusCode = PaymentStatusCode.Success }));
}
public void SaveOrUpdateBankPaymentRequest(BankPaymentRequest BankPaymentRequest)
{
_controller.SaveOrUpdateEntity(BankPaymentRequest);
}
public void DeleteBankPaymentRequest(BankPaymentRequest BankPaymentRequest)
{
_controller.DeleteEntity(BankPaymentRequest);
}
