/// <summary>
/// Process a tranction through an acquirer
/// </summary>
/// <param name="transactionRepresenter"></param>
/// <param name="bankURL"></param>
/// <returns></returns>
public async Task <BankResponseDto> ProcessTransactionAsync(TransactionRepresenter transactionRepresenter, string bankURL)
{
if (transactionRepresenter == null || bankURL == null)
{
return(null);
}
//Process transaction through acquirer
var bankResponse = await _apiService.ProcessTransactionAsync(transactionRepresenter, bankURL)
.ConfigureAwait(false);
var bankResponseData = await bankResponse.Content
.ReadAsStringAsync()
.ConfigureAwait(false);
var json = JsonConvert.DeserializeObject <BankResponse>(bankResponseData);
var transactionCreationRepresenter = new BankResponseDto
{
BankResponseID = json.BankResponseID,
Status = json.Status.ToString(),
SubStatus = json.SubStatus.ToString(),
};
return(transactionCreationRepresenter);
}
public void GivenIReceiveTheFollowingResponseFromTheBankService(BankResponseDto bankResponseDto)
{
var bankResponse = new BankResponse
{
PaymentId = bankResponseDto.PaymentId,
PaymentStatus = bankResponseDto.PaymentStatus,
ProcessedDate = bankResponseDto.ProcessedDate
};
bankService.SetBankResponse(bankResponse);
}
private static StringContent SetExpectedResponse()
{
var bankResponse = new BankResponseDto
{
BankResponseID = new Guid(),
Status = TransactionStatus.Successful.ToString(),
SubStatus = TransactionSubStatus.Successful.ToString(),
};
var expectedResponse = new StringContent(JsonConvert.SerializeObject(bankResponse));
return(expectedResponse);
}
public void GivenFalseAuthorizationFromBank_MakePayment_Returns401UnauthorizedResponse()
{
var bank = new Mock <IAcquiringBank>();
var testBankResponse = new BankResponseDto(testId, false);
bank.Setup(x => x.PaymentIsApproved(It.IsAny <PaymentRequestDto>())).Returns(testBankResponse);
var sut = new PaymentController(bank.Object, paymentStore.Object, paymentRequestValidator.Object);
var result = sut.MakePayment(testPaymentRequestDto);
Assert.IsInstanceOf <StatusCodeResult>(result.Result);
Assert.AreEqual(StatusCodes.Status401Unauthorized, (result.Result as StatusCodeResult).StatusCode);
}
public async Task <BankResponseDto> PostPayment(PaymentRequestDto paymentRequestDto, Merchant currentUser, string bankUrl)
{
BankResponseDto bankResponseDto = new BankResponseDto();
var response = CommunicationUtils.ConnectToBank($"{bankUrl}/payment", Method.POST, paymentRequestDto);
if (response.ResponseStatus == ResponseStatus.Completed && response.StatusCode == HttpStatusCode.OK)
{
bankResponseDto = JsonConvert.DeserializeObject <BankResponseDto>(response.Content);
await SavePaymentDetails(paymentRequestDto, bankResponseDto, currentUser);
}
return(bankResponseDto);
}
public void Setup()
{
bank = new Mock <IAcquiringBank>();
testBankResponse = new BankResponseDto(testId, testStatus);
bank.Setup(x => x.PaymentIsApproved(It.IsAny <PaymentRequestDto>())).Returns(testBankResponse);
paymentStore = new Mock <IPaymentStorage>();
paymentStore.Setup(x => x.Store(It.IsAny <int>(), It.IsAny <PaymentStorageObject>()));
paymentRequestValidator = new Mock <IPaymentRequestValidator>();
paymentRequestValidator.Setup(x => x.IsValid(It.IsAny <PaymentRequestDto>())).Returns(true);
sut = new PaymentController(bank.Object, paymentStore.Object, paymentRequestValidator.Object);
testExpiry = DateTime.Now.AddDays(1);
testPaymentRequestDto = new PaymentRequestDto(testCardNum, testExpiry, testCurrency, testAmount, testCvv);
testPaymentResponse = new PaymentResponseDto(testPaymentRequestDto, testBankResponse);
}
public Task <BankResponseDto> ProcessPaymentRequestAsync(Payment payment)
{
var bankResponse = new BankResponseDto();
bankResponse.BankProcessId = Guid.NewGuid();
payment.SetBankResponseId(bankResponse.BankProcessId);
switch (payment.Amount)
{
case double val when val > 3000:
bankResponse.Status = PaymentProcessingStatus.Rejected;
payment.Rejected();
break;
default:
bankResponse.Status = PaymentProcessingStatus.Success;
payment.Success();
break;
}
return(Task.FromResult(bankResponse));
}
private async Task SavePaymentDetails(PaymentRequestDto paymentRequestDto, BankResponseDto bankResponseDto, Merchant currentUser)
{
PaymentDetails paymentDetails = new PaymentDetails()
{
Identifier = bankResponseDto.Identifier,
Status = bankResponseDto.Status,
Amount = paymentRequestDto.Amount,
Card = new Card()
{
CardNumber = paymentRequestDto.Card.CardNumber,
Cvv = paymentRequestDto.Card.Cvv,
ExpiryMonth = paymentRequestDto.Card.ExpiryMonth,
ExpiryYear = paymentRequestDto.Card.ExpiryYear,
},
Currency = paymentRequestDto.Currency,
Merchant = currentUser,
Date = DateTime.Now
};
await repository.PostPaymentDetails(paymentDetails);
await unitOfWork.CompleteAsync();
}
private static Transaction GetTransactionEntity(
BankResponseDto bankResponse,
TransactionRepresenter transactionRepresenter,
TransactionDetails transactionDetails,
CardDetails cardEntity)
{
return(new Transaction
{
Amount = transactionRepresenter.Amount,
Card = cardEntity,
CardDetailsID = cardEntity.CardDetailsID,
Currency = transactionDetails.Currency,
CurrencyId = transactionDetails.Currency.CurrencyId,
Merchant = transactionDetails.Merchant,
MerchantID = transactionDetails.Merchant.MerchantID,
TransactionID = Guid.NewGuid(),
Bank = transactionDetails.Bank,
BankID = transactionDetails.Bank.BankID,
BankReferenceID = bankResponse.BankResponseID,
Status = bankResponse.Status,
SubStatus = bankResponse.SubStatus
});
}
//POST: /api/Payments/Post
public async Task <ActionResult <BankResponseDto> > Post([FromBody] PaymentRequestDto paymentRequestDto)
{
CardValidation cardValidation = new CardValidation(paymentRequestDto.Card);
if (!cardValidation.IsValid)
{
return(BadRequest(new { message = "Card data is incorrect." }));
}
ClaimsPrincipal currentUser = this.User;
var currentUserName = currentUser.FindFirst("login").Value;
var user = await _userManager.FindByNameAsync(currentUserName);
BankResponseDto bankResponseDto = await paymentService.PostPayment(paymentRequestDto, user, _options.Value.BankUrl);
if (bankResponseDto != null)
{
return(Ok(bankResponseDto));
}
else
{
return(NotFound(new { message = "Bank could not process the request" }));
}
}
public async Task <IActionResult> ProcessTransaction([FromBody] TransactionRepresenter transaction)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (transaction == null)
{
return(BadRequest("Transaction data not found"));
}
if (await _transactionDetailsValidatorService.ValidateAsync(transaction).ConfigureAwait(false))
{
return(BadRequest(_transactionDetailsValidatorService.GetErrors()));
}
var creditCardValidationResult = CreditCardHelper.IsCreditCardInfoValid(transaction);
if (!creditCardValidationResult)
{
return(BadRequest("Invalid Credit Card data"));
}
var transactionDetails = _transactionDetailsValidatorService.GetTransactionDetails();
var cardEntity = await _cardDetailsService.CreateCardDetailsAsync(transaction).ConfigureAwait(false);
BankResponseDto bankResponse = await _bankService.ProcessTransactionAsync(transaction, transactionDetails.Bank.BankURL).ConfigureAwait(false);
Transaction transactionEntity = GetTransactionEntity(bankResponse, transaction, transactionDetails, cardEntity);
await _transactionService.CreateTransactionAsync(transactionEntity).ConfigureAwait(false);
return(Ok(transactionEntity));
}
public PaymentResponseDto(PaymentRequestDto paymentRequest, BankResponseDto bankResponse)
{
this.paymentRequest = paymentRequest;
this.bankResponse = bankResponse;
}
