public PaymentServiceShould()
{
_acquiringBankClientMock = new Mock <IAcquiringBankClient>();
_paymentRepositoryMock = new Mock <IPaymentRepository>();
_loggerMock = new Mock <ILoggerAdapter <PaymentService> >();
_paymentService = new PaymentService(_loggerMock.Object, _acquiringBankClientMock.Object, _paymentRepositoryMock.Object);
_fixture = new Fixture();
_bankResponse = _fixture.Create <BankResponse>();
_acquiringBankClientMock.Setup(b => b.SendPaymentAsync(It.IsAny <Payment>()))
.Returns(Task.FromResult(_bankResponse));
}
public async Task Should_Be_Able_To_Preform_A_Payment_And_Recieve_A_Successful_Transaction()
{
var mockedIdentifier = new DateTimeOffset().ToUnixTimeMilliseconds().ToString();
var createPaymentDto = new CreatePaymentDto {
Issuer = "amazon-issuer-id",
CardHolder = "John Cage",
Value = 199.99m,
Currency = "Euro",
CardNumber = "1234-1234-1234-1235",
ExpiryMonth = 13,
ExpiryYear = 2099,
CCV = "12e2",
};
var bankResponse = new BankResponse {
id = mockedIdentifier,
successful = true,
message = "very nice",
statusCode = 1
};
var paymentResponse = new PaymentResponse {
paymentRequest = new PaymentModel {
Id = "mocked-id",
Issuer = "amazon-issuer-id",
CardHolder = "John Cage",
Value = 199.99m,
Currency = "Euro",
CardNumber = "1234-1234-1234-1235",
ExpiryMonth = 13,
ExpiryYear = 2099,
CCV = "12e2",
response = bankResponse,
},
paymentResponse = bankResponse,
};
var mockPaymentService = new Mock <IPaymentService>();
var mockLogger = new Mock <ILoggerService>();
mockPaymentService.Setup <PaymentResponse>(paymentService => paymentService.Create(createPaymentDto)).Returns(paymentResponse);
var controller = new PaymentController(mockLogger.Object, mockPaymentService.Object);
var result = controller.Create(createPaymentDto);
Assert.IsType <ActionResult <PaymentResponse> >(result);
Assert.IsType <PaymentResponse>(result.Value);
Assert.IsAssignableFrom <PaymentModel>(result.Value.paymentRequest);
Assert.IsAssignableFrom <BankResponse>(result.Value.paymentResponse);
Assert.Equal(result.Value.paymentRequest.response.id, result.Value.paymentResponse.id);
}
public async Task <ActionResult <Payment> > SentPayment([FromBody] Payment payment)
{
var created = await _paymentService.SendPaymentAsync(payment);
var response = new BankResponse
{
PaymentId = created.Id,
IsSuccessful = created.IsSuccessful
};
return(CreatedAtAction(nameof(GetPayment), new { guid = response.PaymentId }, payment));
}
public ActionResult <BankResponse> PostMakePayment(PayRequest payReq)
{
Console.WriteLine("Received request");
accountsDictionary = new Dictionary <string, CardAccount>()
{
{ "6759291632878588", card1 }, { "6226323207911141", card2 }, { "6762476347202597", card3 }, { "4547739567657049", card4 }, { "2377054708263528", card5 }, { "4017618626082491", card6 }, { "6229061805750548", card7 },
};
CardAccount card;
BankResponse bankResponse = new BankResponse();
bankResponse.Identifier = Guid.NewGuid().ToString();
if (!accountsDictionary.TryGetValue(payReq.Cardnumber, out card))
{
bankResponse.Status = 2000;
return(BadRequest(bankResponse));
}
if (!payReq.ExpiryDate.Equals(card.ExpiryDate))
{
bankResponse.Status = 2003;
return(BadRequest(bankResponse));
}
string date = "01/" + card.ExpiryDate;
DateTime dt1 = DateTime.Parse(date);
DateTime dt2 = DateTime.Now;
if ((dt1.Year - dt2.Year) < 0 || (dt1.Year - dt2.Year) > 3 && dt1.Month < dt2.Month)
{
bankResponse.Status = 2004;
return(BadRequest(bankResponse));
}
if (card.Cvv != payReq.Cvv)
{
bankResponse.Status = 2001;
return(BadRequest(bankResponse));
}
if (payReq.Amount > card.Balance)
{
bankResponse.Status = 2002;
return(BadRequest(bankResponse));
}
bankResponse.Status = 1000;
return(Ok(bankResponse));
}
public async Task <ActionResult <BankResponse> > PostPaymentToBank(PayRequest payReq)
{
int merchantID = Authenticate();
if (merchantID == -3)
{
return(BadRequest("An error occured."));
}
if (merchantID < 0)
{
return(Unauthorized());
}
if (payReq == null)
{
return(BadRequest());
}
try
{
CardValidator.validateCard(payReq);
payReq.Cardnumber = payReq.Cardnumber.Replace(" ", "");
BankResponse bankResponse = new BankResponse();
// bankResponse = unitOfWork.Payment.getPaymentDetails(merchantID, "");
bankResponse = await paymentService.makePayment(payReq);
Payment payment = new Payment()
{
Status = bankResponse.Status,
Paymentid = bankResponse.Identifier,
Merchantid = merchantID,
Amount = payReq.Amount,
Expirydate = payReq.ExpiryDate,
Cardholdername = payReq.CardHolderName,
Cardnumber = payReq.Cardnumber,
Cardtype = payReq.CardType,
Currency = payReq.Currency
};
paymentService.addPaymentDetails(payment);
if (bankResponse.Status == 1000)
{
return(Ok(bankResponse));
}
return(BadRequest(bankResponse));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public async Task ValidCardPaymentReturnsSuccess()
{
var transactionServiceMock = new Mock <ITransactionService>();
var bankServiceMock = new Mock <IBankService>();
var modelConverter = new ModelConverter(new MaskingService());
var loggerMock = new Mock <ILogger <CardPaymentService> >();
var cardPaymentService = new CardPaymentService(transactionServiceMock.Object, bankServiceMock.Object, modelConverter, loggerMock.Object);
var cardPaymentRequest = ModelDataHelper.GetValidCardPaymentRequest();
var merchant = ModelDataHelper.GetTestMerchant();
var cardPaymentContext = modelConverter.CreateCardPaymentContext(cardPaymentRequest, merchant);
var transaction = new Transaction()
{
TransactionId = Guid.NewGuid().ToString(),
CardDetail = cardPaymentContext.CardDetail,
Amount = cardPaymentContext.Amount,
MerchantId = merchant.Id,
MerchantReference = cardPaymentContext.MerchantReference,
RequestedOn = DateTime.UtcNow
};
transactionServiceMock.Setup(x => x.InitialiseTransactionAsync(It.IsAny <CardPaymentContext>())).ReturnsAsync(transaction);
var bankResponse = new BankResponse()
{
Id = "BNK_111",
Status = BankResponseStatus.Success,
Details = "Authorised"
};
bankServiceMock.Setup(x => x.ExecuteAsync(It.IsAny <BankCardRequest>())).ReturnsAsync(bankResponse);
var updatedTransaction = transaction;
updatedTransaction.BankDetails = bankResponse.Details;
updatedTransaction.BankReference = bankResponse.Id;
updatedTransaction.Status = TransactionStatus.Fulfilled;
updatedTransaction.ProcessedOn = DateTime.UtcNow;
transactionServiceMock.Setup(x => x.UpdateTransactionAsync(transaction.TransactionId, bankResponse)).ReturnsAsync(updatedTransaction);
var response = await cardPaymentService.ProcessAsync(cardPaymentRequest, merchant);
response.Should().NotBeNull();
response.Amount.Should().Be(cardPaymentRequest.Amount);
response.Currency.Should().Be(cardPaymentRequest.CurrencyCode);
response.Success.Should().BeTrue();
response.Status.Should().Be("fulfilled");
response.BankReference.Should().Be(bankResponse.Id);
}
public IHttpActionResult BankAPI([FromBody] ProcessPaymentRequestDTO merchantRequestDTO)
{
var bankResponseID = Guid.NewGuid();
var bankStatus = Status.Unsuccessfull;
var bank = new BankResponse()
{
BankResponseID = bankResponseID,
BankStatus = bankStatus
};
return(Json(bank));
}
public async Task <BankResponse> CheckStatus(string jmbg, string bankPIN, BankType bankType)
{
switch (bankType)
{
case BankType.FirstBank:
BankResponse response = await FirstBankService.CheckStatus(jmbg, bankPIN);
return(response);
default:
throw new InvalidOperationException("Unsupported bank");
}
}
public IActionResult Post([FromBody] Payment payment)
{
var response = new BankResponse();
var debit = _transactionSvc.Debit(payment);
if (debit.IsSuccess)
{
response = _transactionSvc.Credit(payment);
}
return(Ok(response));
}
public async Task <BankResponse> Withdraw(string jmbg, string bankPIN, decimal amount, BankType bankType)
{
switch (bankType)
{
case BankType.FirstBank:
BankResponse response = await FirstBankService.Withdraw(jmbg, bankPIN, amount);
return(response);
default:
throw new InvalidOperationException("Unsupported bank");
}
}
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);
}
private static void SendResponse(BankCustomer customer, string correlationId)
{
var bankResponse = new BankResponse()
{
FullName = customer.FullName,
EmailAddress = customer.EmailAddress,
Response = true
};
var queue = EndPoints.FromBankQueueName;
var routingKey = EndPoints.FromBankRoutingKey;
var connection = GetConnection.ConnectionGetter();
using var channel = connection.CreateModel();
channel.ExchangeDeclare(exchange: exchangeName,
durable: true,
type: ExchangeType.Direct);
channel.QueueDeclare(queue: queue,
durable: true,
exclusive: false,
autoDelete: false,
arguments: null);
channel.QueueBind(queue, exchangeName, routingKey);
Console.WriteLine("Besked sendt:");
Console.WriteLine("- - - - - - - - - - - - - - -");
Console.WriteLine($"Navn: {bankResponse.FullName}");
Console.WriteLine($"Email: {bankResponse.EmailAddress}");
Console.WriteLine($"CorrelationId: {correlationId}");
Console.WriteLine($"Svar fra banken: {(bankResponse.Response ? "Positivt" : "Negativt")}");
Console.WriteLine("------------------------------");
var message = JsonSerializer.Serialize(bankResponse);
var body = Encoding.UTF8.GetBytes(message);
var props = channel.CreateBasicProperties();
props.CorrelationId = correlationId;
props.Persistent = true;
channel.BasicPublish(exchange: exchangeName,
routingKey: routingKey,
basicProperties: props,
body: body);
CloseConnection.CloseAll(channel, connection);
}
public void TestMakingPayment()
{
BankResponse response = new BankResponse()
{
PaymentStatus = BankPaymentStatus.Successfull, UniqueIdentifier = "12321312312312312"
};
Mock <IBank> bank = new Mock <IBank>();
bank.Setup(p => p.TransferFunds(It.IsAny <long>(), It.IsAny <int>(), It.IsAny <long>(), It.IsAny <int>(), It.IsAny <double>())).Returns(response);
var val = _processingTask.enactPayment(bank.Object, 111111, 1234567890123456, _testPayment).Result;
Assert.IsNotNull(val);
}
public Payment Map(PaymentModel model, BankResponse bankResponse)
{
return(new Payment
{
Id = bankResponse.PaymentId,
Status = bankResponse.PaymentStatus,
ProcessedDate = bankResponse.ProcessedDate,
CardNumber = model.CardNumber,
Amount = model.Amount,
Currency = model.Currency,
CVV = model.CVV,
ExpiryDate = model.ExpiryDate
});
}
public HttpResponseMessage GetBanks(HttpRequestMessage request)
{
IEnumerable <string> token = null;
request.Headers.TryGetValues("Token-autorization", out token);
PersonEN personVerified = personBL.VerifyPersonAuthentication(token);
if (token != null)
{
if (personVerified != null)
{
if (personVerified.IsValidToken)
{
List <BankEN> theBanksList = bankBL.GetBankList(personVerified.CountryID);
if (theBanksList != null)
{
BankResponse bankResponse = interactor.CreateBankResponse(theBanksList);
return(Request.CreateResponse <IResponse>(HttpStatusCode.OK, bankResponse));
}
else
{
response.HttpCode = 500;
response.Message = "Something went wrong";
return(Request.CreateResponse <IResponse>(HttpStatusCode.InternalServerError, response));
}
}
else
{
response.HttpCode = 401;
response.Message = "Authentication token has expired.";
return(Request.CreateResponse <IResponse>(HttpStatusCode.Unauthorized, response));
}
}
else
{
response.HttpCode = 401;
response.Message = "Credentials are not valid.";
return(Request.CreateResponse <IResponse>(HttpStatusCode.Unauthorized, response));
}
}
else
{
response.HttpCode = 400;
response.Message = "Authorization token must be provided";
return(Request.CreateResponse <IResponse>(HttpStatusCode.BadRequest, response));
}
}
public Task <BankResponse> ProcessPayment(PaymentRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var result = new BankResponse
{
Success = FakePaymentSuccess(request),
TransactionId = Guid.NewGuid()
};
return(Task.FromResult(result));
}
/// <summary>
/// Save payment details and bank response to data storage
/// </summary>
/// <param name="bankResponse">Bank response for the given payment request</param>
/// <param name="paymentRequest">Payment request details</param>
public void SavePayment(BankResponse bankResponse, PaymentRequest paymentRequest)
{
var payment = new Payment()
{
PaymentId = bankResponse.PaymentId,
PaymentStatus = bankResponse.PaymentStatus,
Amount = paymentRequest.Amount,
Currency = paymentRequest.Currency,
TransactionDate = DateTime.Now,
CardNumber = paymentRequest.CardDetails.CardNumber,
ExpiryDate = CalculateExpiryDate(paymentRequest.CardDetails.ExpiryMonth, paymentRequest.CardDetails.ExpiryYear)
};
PaymentRepository.Add(payment);
}
public async void ReturnsPaymentRequest_WhenCalled()
{
var request = new PaymentRequestDto();
_bankEndpoint
.Setup(x => x.SubmitPaymentRequest(request))
.Returns(Task.FromResult(BankResponse.CreateResponse()));
var actual = await _sut.SubmitPaymentToBankAsync(request);
Assert.NotNull(actual);
Assert.IsType <PaymentRequestDto>(actual);
Assert.False(string.IsNullOrWhiteSpace(actual.PaymentIdentifier));
Assert.False(string.IsNullOrWhiteSpace(actual.Status));
}
public async Task Test01()
{
//Arrange
BankResponse bankResponse = new BankResponse();
//Act
using (var brasilAPI = new BrasilAPI())
{
bankResponse = await brasilAPI.Banks();
}
//Assert
Assert.IsNotNull(bankResponse);
Assert.IsTrue(bankResponse.Banks.Any());
}
public async Task <BankResponse> Deposit(string jmbg, string pin, decimal amount)
{
var status = Accounts.ContainsKey($"{jmbg}:{pin}");
if (status)
{
Accounts[$"{jmbg}:{pin}"] += amount;
}
var response = new BankResponse()
{
Status = status,
ErrorCodes = status ? "" : "Bank account not found for given jmbg and pin!"
};
return(response);
}
public BankResponse Create(BankViewModel bank)
{
BankResponse response = new BankResponse();
try
{
response = WpfApiHandler.SendToApi <BankViewModel, BankResponse>(bank, "Create");
}
catch (Exception ex)
{
response.Bank = new BankViewModel();
response.Success = false;
response.Message = ex.Message;
}
return(response);
}
// This is a fake bank service, it will be replaced with a proper one when we're closer to production.
public async Task <BankResponse> ProcessTransactionAsync(PaymentRequest paymentRequest,
CancellationToken cancellationToken = default(CancellationToken))
{
if (paymentRequest == null)
{
throw new ArgumentNullException(nameof(paymentRequest));
}
var transactionStatusCode = paymentRequest.Amount <= 2000 ? TransactionStatusCode.Successful : TransactionStatusCode.Unsuccessful;
var response = new BankResponse {
TransactionId = Guid.NewGuid(), TransactionStatusCode = transactionStatusCode
};
_logger.LogTrace("Bank response: {@Response}", response);
return(response);
}
public async Task Test02()
{
//Arrange
int code = 1;
BankResponse bankResponse = new BankResponse();
//Act
using (var brasilAPI = new BrasilAPI())
{
bankResponse = await brasilAPI.Banks(code);
}
//Assert
Assert.IsNotNull(bankResponse);
Assert.IsTrue(bankResponse.Banks.Any());
Assert.IsTrue(bankResponse.Banks.Count() == 1);
Assert.IsTrue(bankResponse.Banks.First().FullName.Contains("Brasil", StringComparison.OrdinalIgnoreCase));
}
public BankResponse Delete(Guid identifier)
{
BankResponse response = new BankResponse();
try
{
BankViewModel re = new BankViewModel();
re.Identifier = identifier;
response = WpfApiHandler.SendToApi <BankViewModel, BankResponse>(re, "Delete");
}
catch (Exception ex)
{
response.Bank = new BankViewModel();
response.Success = false;
response.Message = ex.Message;
}
return(response);
}
public static void SaveTransaction(ILogger log, Transaction transaction, BankResponse response)
{
List <TransactionSummary> transactions = new List <TransactionSummary>();
try
{
string filePath = @"C:\Transactions";
if (!Directory.Exists(filePath))
{
Directory.CreateDirectory(filePath);
}
string file = string.Format("{0}\\{1}", filePath, "Transactions.json");
if (File.Exists(file))
{
var json = File.ReadAllText(file);
transactions = JsonConvert.DeserializeObject <List <TransactionSummary> >(json);
}
transactions.Add(new TransactionSummary()
{
Amount = transaction.Amount,
TransactionTimeStamp = transaction.TransactionTimeStamp,
CardDetail = new CardDetails()
{
CardNumber = transaction.CardDetail.CardNumber,
CardType = transaction.CardDetail.CardType
},
TransactionId = response.TransactionId.ToString(),
HttpStatusCode = response.HttpStatusCode,
Message = response.Message,
TransactionSucceed = response.TransactionSucceed
});
File.WriteAllText(file, JsonConvert.SerializeObject(transactions));
}
catch (Exception ex)
{
log.LogError(string.Format(Constants.TransactionNotAvailable, ex.StackTrace));
}
}
public static BankResponse ProcessTransaction(MockBank mockbank)
{
var response = new BankResponse();
int i = 0;
response.Response = "Successful";
response.Status = "Successful";
if (!(mockbank.CVV.ToString().Length == 3))
{
response.Response = "Security Breach";
response.Status = "Failed";
}
if (mockbank.Amount > 100000)
{
response.Response = "Not enough fund";
response.Status = "Failed";
}
if (!(mockbank.CardNumber.Length == 12) && (int.TryParse(mockbank.CardNumber, out i) == true))
{
response.Response = "Invalid Card Number";
response.Status = "Failed";
}
if (mockbank.ExpiryYear < DateTime.Now.Year)
{
response.Response = "Card has expired";
response.Status = "Failed";
}
if ((mockbank.ExpiryYear == DateTime.Now.Year) && (Int32.Parse(mockbank.ExpiryMonth) < DateTime.Now.Month))
{
response.Response = "Card has expired";
response.Status = "Failed";
}
response.Id = Guid.NewGuid();
return(response);
}
public JsonResult Delete([FromBody] BankViewModel bank)
{
BankResponse response = new BankResponse();
try
{
response = this.bankService.Delete(bank.Identifier);
}
catch (Exception ex)
{
response.Success = false;
response.Message = ex.Message;
Console.WriteLine(ex.Message);
}
return(Json(response, new Newtonsoft.Json.JsonSerializerSettings()
{
Formatting = Newtonsoft.Json.Formatting.Indented
}));
}
public BankResponse ProcessPayment(Transaction transaction)
{
BankResponse response = null;
try
{
transaction.TransactionTimeStamp = DateTime.Now;
//Call Bank API, for this POC, I mocked the response to be either pass or fail
if (Common.Validation.IsCardExpired(_Log, Convert.ToDateTime(transaction.CardDetail.ExpiryDate)))
{
//Initiate Bank API call
// for this POC, I simulated transaction to pass if amount if positive
if (transaction.Amount % 2 == 0)
{
response = new BankResponse()
{
TransactionId = Guid.NewGuid(), HttpStatusCode = 200, TransactionSucceed = true
};
}
else
{
response = new BankResponse()
{
TransactionId = Guid.NewGuid(), HttpStatusCode = 400, TransactionSucceed = false
};
}
}
else
{
response = new BankResponse()
{
TransactionId = Guid.NewGuid(), HttpStatusCode = 422, TransactionSucceed = false, Message = Common.Constants.CardExipred
};
}
}
catch (Exception ex)
{
_Log.LogError(ex.Message);
}
return(response);
}
public BankResponse InsertBank(BankEntity bank)
{
var response = new BankResponse {
Acknowledge = AcknowledgeType.Success
};
try
{
if (!bank.Validate())
{
foreach (string error in bank.ValidationErrors)
{
response.Message += error + Environment.NewLine;
}
response.Acknowledge = AcknowledgeType.Failure;
return(response);
}
var banks = BankDao.GetBanksByBankAccount(bank.BankAccount);
if (banks.Count > 0)
{
response.Acknowledge = AcknowledgeType.Failure;
response.Message = @"Số tài khoản " + bank.BankAccount + @" đã tồn tại !";
return(response);
}
bank.BankId = Guid.NewGuid().ToString();
response.Message = BankDao.InsertBank(bank);
if (!string.IsNullOrEmpty(response.Message))
{
response.Acknowledge = AcknowledgeType.Failure;
return(response);
}
response.BankId = bank.BankId;
return(response);
}
catch (Exception ex)
{
response.Acknowledge = AcknowledgeType.Failure;
response.Message = ex.Message;
return(response);
}
}
public BankResponse DeleteAll()
{
BankResponse response = new BankResponse();
try
{
using (SqliteConnection db = new SqliteConnection("Filename=SirmiumERPGFC.db"))
{
db.Open();
db.EnableExtensions(true);
SqliteCommand insertCommand = new SqliteCommand();
insertCommand.Connection = db;
//Use parameterized query to prevent SQL injection attacks
insertCommand.CommandText = "DELETE FROM Banks";
try
{
insertCommand.ExecuteNonQuery();
}
catch (SqliteException error)
{
response.Success = false;
response.Message = error.Message;
MainWindow.ErrorMessage = error.Message;
return(response);
}
db.Close();
}
}
catch (SqliteException error)
{
response.Success = false;
response.Message = error.Message;
return(response);
}
response.Success = true;
return(response);
}
