public async Task CallProcessTransactionAsyncWithNullTransactionOrNullBankUrlReturnsNull(
TransactionRepresenter transaction, string bankUrl)
{
var result = await this._testClass.ProcessTransactionAsync(transaction, bankUrl).ConfigureAwait(false);
Assert.IsNull(result);
}
/// <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 async Task <CardDetails> CreateCardDetailsAsync(TransactionRepresenter transactionRepresenter)
{
if (transactionRepresenter == null || transactionRepresenter.Card == null)
{
return(null);
}
var cardEntity = await this.GetCardDetailsByNumberAsync(transactionRepresenter.Card.CardNumber).ConfigureAwait(false);
if (cardEntity == null)
{
cardEntity = new CardDetails()
{
CardNumber = transactionRepresenter.Card.CardNumber,
Cvv = transactionRepresenter.Card.Cvv,
ExpiryMonth = transactionRepresenter.Card.ExpiryMonth,
ExpiryYear = transactionRepresenter.Card.ExpiryYear,
HolderName = transactionRepresenter.Card.HolderName,
};
await this.AddCardAsync(cardEntity).ConfigureAwait(false);
}
;
return(cardEntity);
}
/// <summary>
/// A method used to validate a card from a transaction request
/// </summary>
/// <param name="transactionDto">The transaction object</param>
/// <returns>Whether the provided card inside the transaction object is valid</returns>
public static bool IsCreditCardInfoValid(TransactionRepresenter transactionDto)
{
if (transactionDto == null)
{
return(false);
}
var expiryConcatenated = $"{transactionDto.Card.ExpiryMonth}/{transactionDto.Card.ExpiryYear}";
return(IsCreditCardInfoValid(transactionDto.Card.CardNumber, expiryConcatenated, transactionDto.Card.Cvv));
}
public async Task <bool> ValidateAsync(TransactionRepresenter data)
{
this.SetTransactionData(data);
this.CheckAmount();
await this.CheckMerchantData().ConfigureAwait(false);
await this.CheckCurrencyData().ConfigureAwait(false);
await this.CheckBankData().ConfigureAwait(false);
return(this.Errors.Any());
}
private BankTransaction GetBankTransaction(TransactionRepresenter transaction)
{
return(new BankTransaction
{
TransactionAmount = transaction.Amount,
CardNumber = transaction.Card.CardNumber,
CardCvv = transaction.Card.Cvv,
CardHolderName = transaction.Card.HolderName,
CardExpiryMonth = transaction.Card.ExpiryMonth,
CardExpiryYear = transaction.Card.ExpiryYear
});
}
public async Task <HttpResponseMessage> ProcessTransactionAsync(TransactionRepresenter transaction, string bankURL)
{
if (transaction == null || bankURL == null)
{
return(null);
}
var url = bankURL + ProcessTransactionControllerRoute;
BankTransaction bankTransaction = GetBankTransaction(transaction);
var contentString = JsonConvert.SerializeObject(bankTransaction);
return(await _webRequestService.MakeAsyncRequest(url, contentString).ConfigureAwait(false));
}
public Task <TransactionCreationRepresenter> ProcessTransaction(TransactionRepresenter transactionRepresenter, string bankURL)
{
var TransactionCreationRepresenter = new TransactionCreationRepresenter
{
BankResponseID = Guid.NewGuid(),
Status = "Successful",
SubStatus = "Succesfull"
};
var t = Task.FromResult(TransactionCreationRepresenter);
return(t);
}
public ActionResult <Transaction> ProcessTransaction(TransactionRepresenter transactionRepresenter)
{
var transaction = new Transaction();
transaction.MerchantId = transactionRepresenter.MerchantId;
transaction.BankId = transactionRepresenter.BankId;
transaction.Currency = transactionRepresenter.Currency;
transaction.CardType = transactionRepresenter.CardType;
transaction.CardNumber = transactionRepresenter.CardNumber;
transaction.NameOnCard = transactionRepresenter.NameOnCard;
transaction.ExpiryMonth = transactionRepresenter.ExpiryMonth;
transaction.ExpiryYear = transactionRepresenter.ExpiryYear;
transaction.CVV = transactionRepresenter.CVV;
transaction.Amount = transactionRepresenter.Amount;
var merchant = _context.Merchants.Find(transaction.MerchantId);
var bank = _context.Banks.Find(transaction.BankId);
if (merchant is null)
{
return(NotFound("Merchant not found!"));
}
if (bank is null)
{
return(NotFound("Bank not found!"));
}
var mockBank = new MockBank();
mockBank.CardType = transaction.CardType;
mockBank.CardNumber = transaction.CardNumber;
mockBank.NameOnCard = transaction.NameOnCard;
mockBank.ExpiryMonth = transaction.ExpiryMonth;
mockBank.ExpiryYear = transaction.ExpiryYear;
mockBank.CVV = transaction.CVV;
mockBank.Amount = transaction.Amount;
var bankresponse = new BankResponse();
bankresponse = MockBankController.ProcessTransaction(mockBank);
transaction.BankResponseId = bankresponse.Id;
transaction.BankResponse = bankresponse.Response;
transaction.Status = bankresponse.Status;
_context.Transactions.Add(transaction);
_context.SaveChanges();
return(transaction);
}
public void PostTransactionValidObjectPassedReturnsTransactionResponse()
{
var card = new CardDetails {
CardNumber = "4242 4242 4242 4242", Cvv = "100", HolderName = "CHADTBONTHUYS", ExpiryMonth = "11", ExpiryYear = "19"
};
var _transaction = new TransactionRepresenter {
Amount = 200, Currency = "GBP", Bank = "MockBank", Card = card, MerchantID = "1D620903-D485-4421-958F-8265C0B41844"
};
// Act
var createdResponse = _transactionsController.ProcessTransaction(_transaction).Result as OkObjectResult;
// Assert
Assert.IsType <TransactionCreationRepresenter>(createdResponse.Value);
}
public static async Task <HttpResponseMessage> ProcessTransactionAsync(TransactionRepresenter transaction, string bankURL)
{
var url = bankURL + "Transactions/transactions";
var content = new Dictionary <string, string>
{
["TransactionAmount"] = transaction.Amount.ToString(),
["cardNumber"] = transaction.Card.CardNumber,
["CardCvv"] = transaction.Card.Cvv,
["CardHolderName"] = transaction.Card.HolderName,
["CardExpiryMonth"] = transaction.Card.ExpiryMonth,
["CardExpiryYear"] = transaction.Card.ExpiryYear
};
return(await WebRequestHelper.MakeAsyncRequest(url, content));
}
public void PostTransactionInvalidCurrencyReturnsBadRequest()
{
// Arrange
var card = new CardDetails {
CardNumber = "4242 4242 4242 4242", Cvv = "100", HolderName = "CHADTBONTHUYS", ExpiryMonth = "11", ExpiryYear = "19"
};
var _transaction = new TransactionRepresenter {
Amount = 200, Currency = "AAA", Bank = "MockBank", Card = card, MerchantID = "1D620903-D485-4421-958F-8265C0B41844"
};
// Act
var createdResponse = _transactionsController.ProcessTransaction(_transaction).Result;
// Assert
Assert.IsType <BadRequestObjectResult>(createdResponse);
}
/// <summary>
/// Process a tranction through an acquirer
/// </summary>
/// <param name="transactionRepresenter"></param>
/// <param name="bankURL"></param>
/// <returns></returns>
public async Task <TransactionCreationRepresenter> ProcessTransaction(TransactionRepresenter transactionRepresenter, string bankURL)
{
//Process transaction through acquirer
var bankResponse = await APIHelper.ProcessTransactionAsync(transactionRepresenter, bankURL);
var bankResponseData = bankResponse.Content.ReadAsStringAsync().Result;
var json = JsonConvert.DeserializeObject <BankResponse>(bankResponseData);
var transactionCreationRepresenter = new TransactionCreationRepresenter
{
BankResponseID = json.BankResponseID,
Status = json.Status.ToString(),
SubStatus = json.SubStatus.ToString(),
};
return(transactionCreationRepresenter);
}
public async Task CanCallProcessTransactionAsync()
{
//Arrange
TransactionRepresenter transactionRepresenter = SetExpectedTransaction();
StringContent expectedResponse = SetExpectedResponse();
var bankURL = "test-bank.com";
_webRequestService
.Setup(x => x.MakeAsyncRequest(bankURL, It.IsAny <string>()))
.ReturnsAsync(new HttpResponseMessage {
Content = expectedResponse
});
//Act
var result = await _testClass.ProcessTransactionAsync(transactionRepresenter, bankURL);
//Assert
_webRequestService.Verify(
x => x.MakeAsyncRequest(bankURL, It.IsAny <string>()),
Times.AtMostOnce,
"Method not called or called more than once");
}
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
});
}
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));
}
private void SetTransactionData(TransactionRepresenter data)
{
this.TransactionRepresenter = data;
}
public async Task <IActionResult> ProcessTransaction(TransactionRepresenter transactionRepresenter)
{
#region Validation
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (transactionRepresenter.Amount <= 0)
{
return(BadRequest("Amount is invalid"));
}
bool isValid = Guid.TryParse(transactionRepresenter.MerchantID, out Guid merchantID);
if (!isValid)
{
return(BadRequest("Merchant is invalid"));
}
var merchant = new Merchant();
merchant = _merchantService.GetMerchant(Guid.Parse(transactionRepresenter.MerchantID));
if (merchant is null)
{
return(BadRequest("Merchant is invalid"));
}
var currency = new Currency();
currency = _currencyService.GetCurrencyByName(transactionRepresenter.Currency);
if (currency is null)
{
return(BadRequest("Currency not supported"));
}
var bank = new Bank();
bank = _bankService.GetBankByName(transactionRepresenter.Bank);
if (bank is null)
{
return(BadRequest("Bank not supported"));
}
#endregion
var cardEntity = new Data.Model.CardDetails();
cardEntity = _cardDetailsService.GetCardDetailsByNumber(transactionRepresenter.Card.CardNumber);
// Verify if the card exists and if it doesnt insert the card into the db
if (cardEntity is null)
{
//TODO Add automapper to handle model mappings
cardEntity = new CardDetails
{
CardNumber = transactionRepresenter.Card.CardNumber,
Cvv = transactionRepresenter.Card.Cvv,
ExpiryMonth = transactionRepresenter.Card.ExpiryMonth,
ExpiryYear = transactionRepresenter.Card.ExpiryYear,
HolderName = transactionRepresenter.Card.HolderName
};
_cardDetailsService.AddCard(cardEntity);
}
;
//var expiryConcatenated = $" {transaction.Card.ExpiryMonth}/{transaction.Card.ExpiryYear}";
//CreditCardHelper.IsCreditCardInfoValid(transaction.Card.CardNumber, expiryConcatenated, transaction.Card.Cvv);
//TODO Fix Bug Leading zeros on Amount
var transactionEntity = new Data.Model.Transaction
{
Amount = transactionRepresenter.Amount,
Card = cardEntity,
CardID = cardEntity.CardDetailsID,
Currency = currency,
CurrencyID = currency.CurrencyId,
Merchant = merchant,
MerchantID = merchant.MerchantID,
Status = TransactionStatus.Created.ToString(),
TransactionID = Guid.NewGuid(),
Bank = bank,
BankID = bank.BankID
};
_transactionService.CreateTransaction(transactionEntity);
var createdTransaction = _bankService.ProcessTransaction(transactionRepresenter, bank.BankURL).Result;
createdTransaction.TransactionID = transactionEntity.TransactionID;
//Update the transactioon with the bank response
transactionEntity.BankReferenceID = createdTransaction.BankResponseID;
transactionEntity.Status = createdTransaction.Status.ToString();
transactionEntity.SubStatus = createdTransaction.SubStatus.ToString();
_transactionService.UpdateTransaction(transactionEntity);
return(Ok(createdTransaction));
}
