public static bool IsValid(this CreditCard creditCard, PostPaymentRequest request)
{
if (creditCard.IssuingNetwork != request.IssuingNetwork)
{
return(false);
}
if (creditCard.CardNumber != request.CardNumber)
{
return(false);
}
if (!creditCard.ExpirationDate.HasValue && !request.ExpirationDate.HasValue)
{
return(false);
}
if (creditCard.ExpirationDate.Value.Year != request.ExpirationDate.Value.Year)
{
return(false);
}
if (creditCard.ExpirationDate.Value.Month != request.ExpirationDate.Value.Month)
{
return(false);
}
if (creditCard.Cvv != request.Cvv)
{
return(false);
}
return(true);
}
public async Task <HttpResponseMessage> PostPaymentAsync(PostPaymentRequest request)
{
var token = await IdentityServerHelper.GetRothschildHouseTokenAsync();
client.SetBearerToken(token.AccessToken);
return(await client.PostAsync(apiUrl.Controller("Transaction").Action("Payment").ToString(), request.GetStringContent()));
}
public static bool HasFounds(this CreditCard creditCard, PostPaymentRequest request)
{
if (creditCard.AvailableFounds <= request.Amount)
{
return(false);
}
return(true);
}
public async Task <IActionResult> PostPayment([FromBody] PostPaymentRequest request)
{
// todo: check if customer exists in database
var creditCards = await DbContext.GetCreditCardByCardHolderName(request.CardHolderName).ToListAsync();
var creditCard = default(CreditCard);
if (creditCards.Count > 1)
{
creditCard = creditCards.FirstOrDefault(item => item.CardNumber == request.CardNumber);
if (creditCard == null)
{
return(BadRequest(string.Format("There isn't record for credit card with last 4 digits: {0}.", request.CardNumber)));
}
}
else if (creditCards.Count == 1)
{
creditCard = creditCards.First();
}
else
{
return(BadRequest(string.Format("There isn't record for credit card with last 4 digits: {0}.", request.CardNumber)));
}
// todo: check credit card info in database
if (!creditCard.IsValid(request))
{
return(BadRequest(string.Format("There is invalid data for credit card in this transaction.")));
}
// todo: check if customer has available credit (limit)
if (!creditCard.HasFounds(request))
{
return(BadRequest(string.Format("There isn't founds to approve this transaction.")));
}
var txn = new PaymentTransaction
{
PaymentTransactionID = Guid.NewGuid(),
CreditCardID = creditCard.CreditCardID,
ConfirmationID = Guid.NewGuid(),
Amount = request.Amount,
PaymentDateTime = DateTime.Now
};
DbContext.PaymentTransactions.Add(txn);
creditCard.AvailableFounds -= request.Amount;
await DbContext.SaveChangesAsync();
return(Ok(new { txn.ConfirmationID, creditCard.Last4Digits }));
}
public async Task <IActionResult> Post([FromBody] PostPaymentRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var paymentId = Guid.NewGuid();
try
{
var payment = _mapper.Map <Payment>(request);
payment.Id = paymentId;
payment.CardNumber = _encryptionService.Encrypt(request.CardNumber);
var bankRequest = _mapper.Map <BankRequest>(request);
await _paymentRepository.AddPaymentAsync(payment);
_logger.LogInformation($"POST - Starting request to bank for payment {payment.Id}");
var bankResponse = await _bankRequestService.PostBankRequestAsync(bankRequest);
payment.BankResponseId = bankResponse.Id;
payment.PaymentStatus = bankResponse.PaymentStatus;
await _paymentRepository.UpdatePaymentAsync(payment);
var postPaymentResponse = new PostPaymentResponse {
PaymentId = payment.Id
};
return(Ok(postPaymentResponse));
}
catch (Exception ex)
{
_logger.LogError($"POST - Failed due to exception ${ex.GetType()} with error ${ex.Message} for request ${paymentId}");
return(StatusCode(500));
}
}
private static (Transaction, Transaction) CreateTransactions(PostPaymentRequest postPaymentRequest)
{
var utcNow = DateTime.UtcNow;
var debitTransaction = new Transaction
{
Amount = postPaymentRequest.Amount * -1,
TransactionTimeUtc = utcNow,
Description = postPaymentRequest.Description,
MerchantName = postPaymentRequest.MerchantName
};
var creditTransaction = new Transaction
{
//this needs tweaking... doesn't work for outbound transactions because it doesn't capture the account number to send it to
Amount = postPaymentRequest.Amount,
TransactionTimeUtc = utcNow,
Description = postPaymentRequest.Description,
MerchantName = postPaymentRequest.MerchantName
};
return(debitTransaction, creditTransaction);
}
public async Task <HttpResponseMessage> PostPaymentAsync(TokenResponse token, PostPaymentRequest request)
=> new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(JsonConvert.SerializeObject(PaymentResponseMocks.SuccessPayment))
};
public async Task <IActionResult> PostPaymentAsync([FromBody] PostPaymentRequest request)
{
Logger?.LogDebug("'{0}' has been invoked", nameof(PostPaymentAsync));
var creditCards = await DbContext.GetCreditCardByCardHolderName(request.CardHolderName).ToListAsync();
var creditCard = default(CreditCard);
var last4Digits = request.CardNumber.Substring(request.CardNumber.Length - 4);
if (creditCards.Count > 1)
{
creditCard = creditCards.FirstOrDefault(item => item.CardNumber == request.CardNumber);
}
else if (creditCards.Count == 1)
{
creditCard = creditCards.First();
}
if (creditCard == null)
{
return(BadRequest(string.Format("There is not record for credit card with last 4 digits: {0}.", last4Digits)));
}
/* Check credit card information */
if (!creditCard.IsValid(request))
{
return(BadRequest(string.Format("Invalid information for card payment.")));
}
/* Check if customer has available credit (limit) */
if (!creditCard.HasFounds(request))
{
return(BadRequest(string.Format("There are no founds to approve the payment.")));
}
using (var txn = await DbContext.Database.BeginTransactionAsync())
{
try
{
var paymentTxn = new PaymentTransaction
{
PaymentTransactionID = Guid.NewGuid(),
CreditCardID = creditCard.CreditCardID,
ConfirmationID = Guid.NewGuid(),
Amount = request.Amount,
PaymentDateTime = DateTime.Now
};
DbContext.PaymentTransactions.Add(paymentTxn);
creditCard.AvailableFounds -= request.Amount;
await DbContext.SaveChangesAsync();
txn.Commit();
Logger?.LogInformation("The payment for card with last 4 digits: '{0}' was successfully. Confirmation #: {1}", last4Digits, paymentTxn.ConfirmationID);
var response = new PaymentResponse
{
ConfirmationID = paymentTxn.ConfirmationID,
PaymentDateTime = paymentTxn.PaymentDateTime,
Last4Digits = creditCard.Last4Digits
};
return(Ok(response));
}
catch (Exception ex)
{
Logger?.LogCritical("There was an error on '{0}': {1}", nameof(PostPaymentAsync), ex);
txn.Rollback();
return(new ObjectResult(ex.Message)
{
StatusCode = (int)HttpStatusCode.InternalServerError
});
}
}
}
public async Task <HttpResponseMessage> PostPaymentAsync(PostPaymentRequest request)
{
return(await client.PostAsync(apiUrl.Controller("Transaction").Action("Payment").ToString(), request.GetStringContent()));
}
public async Task <IActionResult> PostPayment([FromBody] PostPaymentRequest postPaymentRequest)
{
_logger.LogInformation("incoming post payment request", postPaymentRequest);
if (IsValid(postPaymentRequest))
{
var(debit, credit) = CreateTransactions(postPaymentRequest);
var fromAccount = await GetAccount(postPaymentRequest.FromAccount);
if (fromAccount == null)
{
return(NotFound());
}
fromAccount.PostTransaction(debit);
var interIntra = "";
if (IsIntrabank(postPaymentRequest))
{
_logger.LogInformation("intrabank payment request", postPaymentRequest);
var toAccount = await GetAccount(postPaymentRequest.ToAccount, false);
if (toAccount == null)
{
return(NotFound());
}
toAccount.PostTransaction(credit);
interIntra = "intra";
}
else
{
_logger.LogInformation("outbound payment request", postPaymentRequest);
await AddToSettlementBatch(credit);
interIntra = "inter";
}
await _db.SaveChangesAsync();
_logger.LogInformation($"Posted {interIntra}-bank transaction of ${credit.Amount} from {postPaymentRequest.FromAccount} to {postPaymentRequest.ToAccount}");
/*await _cloudWatch.PutMetricDataAsync(new PutMetricDataRequest
* {
* Namespace = "Payments",
* MetricData = new List<MetricDatum>
* {
* new MetricDatum
* {
* MetricName = "TransferEvent",
* Unit = StandardUnit.Count,
* Value = 1,
* TimestampUtc = DateTime.UtcNow,
* Dimensions = new List<Dimension>
* {
* new Dimension { Name = "InterIntra", Value = interIntra }
* }
* },
* new MetricDatum
* {
* MetricName = "TransferValue",
* Unit = StandardUnit.None,
* Value = (double) credit.Amount,
* TimestampUtc = DateTime.UtcNow,
* Dimensions = new List<Dimension>
* {
* new Dimension { Name = "InterIntra", Value = interIntra }
* }
* }
* }
* });*/
return(Ok());
}
return(UnprocessableEntity());
}
private bool IsValid(PostPaymentRequest postPaymentRequest)
{
return(postPaymentRequest.Amount > 0M && IsExistingAccount(postPaymentRequest.FromAccount));
}
private bool IsIntrabank(PostPaymentRequest postPaymentRequest)
{
return(postPaymentRequest.ToAccount.StartsWith(_config["BankPrefix"]));
}
/// <summary>
///
/// </summary>
/// <param name="httpClient"></param>
/// <param name="request"></param>
/// <returns></returns>
public static async Task <HttpResponseMessage> PostPaymentAsync(this HttpClient httpClient, PostPaymentRequest request)
{
return(await httpClient.PostAsync("http://localhost:19000/api/v1/Transaction/Payment", GetStringContent(request)));
}
public async Task <HttpResponseMessage> PostPaymentAsync(TokenResponse token, PostPaymentRequest request)
{
using (var client = new HttpClient())
{
client.SetBearerToken(token.AccessToken);
return(await client.PostAsync(
apiUrl.Controller("Transaction").Action("Payment").ToString(),
request.GetStringContent()
));
}
}
public async Task <IActionResult> PostPayment([FromBody] PostPaymentRequest request)
{
return(Ok());
}
