public async void SubmitPaymentAsync_ReturnsSuccessfulResponse_WithSuccessfulRequest()
{
const string responseBody = @"
{
""accountNumber"": ""123123"",
""bankNumber"": 5000,
""companyNumber"": 3939,
""amount"": 12.34,
""convenienceFee"": 4.65,
""processDate"": ""2021-10-27T00:00:00.000Z"",
""name"": ""Test Payment"",
""confirmationNumber"": ""1234567890""
}";
var sut = GetTestClient(responseBody, HttpStatusCode.OK);
var cardPayment = new CardPaymentRequest();
var actual = await sut.LoanPayApi.SubmitPaymentAsync("", cardPayment);
Assert.False(actual.IsError);
Assert.Null(actual.Error);
Assert.NotNull(actual.Confirmation);
Assert.Equal("123123", actual.Confirmation.AccountNumber);
Assert.Equal(12.34m, actual.Confirmation.Amount);
Assert.Equal(4.65m, actual.Confirmation.ConvenienceFee);
Assert.Equal(new DateTime(2021, 10, 27), actual.Confirmation.ProcessDate);
Assert.Equal("Test Payment", actual.Confirmation.Name);
Assert.Equal("1234567890", actual.Confirmation.ConfirmationNumber);
}
public void Setup()
{
_cardPaymentRequest = new CardPaymentRequest {
Amount = 40.00M,
OrderNumber = "asdfghjkl00001",
Card = new Card {
Name = "John Doe",
Number = "5100000010001004",
ExpiryMonth = "12",
ExpiryYear = "18",
Cvd = "123"
}
};
_executer = new Mock <IWebCommandExecuter>();
_bambora = new Gateway()
{
MerchantId = 300200578,
PaymentsApiKey = "4BaD82D9197b4cc4b70a221911eE9f70",
ReportingApiKey = "4e6Ff318bee64EA391609de89aD4CF5d",
ProfilesApiKey = "D97D3BE1EE964A6193D17A571D9FBC80",
ApiVersion = "1"
};
}
public async void SubmitPaymentAsync_ReturnsError_WithErrorResponse()
{
const string responseBody = @"
{
""status"": ""BadRequest"",
""errors"": [
{
""code"": ""card-payment-error"",
""message"": ""Failed to submit card payment."",
""exception"": { }
}
],
""isError"": true,
""isEmpty"": true
}";
var sut = GetTestClient(responseBody, HttpStatusCode.BadRequest);
var cardPayment = new CardPaymentRequest();
var actual = await sut.LoanPayApi.SubmitPaymentAsync("", cardPayment);
Assert.True(actual.IsError);
Assert.Null(actual.Confirmation);
Assert.Contains("Failed to submit card payment.", actual.Error);
}
/// <summary>
/// Processes a card payment
/// </summary>
/// <param name="cardPaymentRequest">payment request from merchant</param>
/// <param name="merchant">Merchant details</param>
/// <returns></returns>
public async Task <CardPaymentResponse> ProcessAsync(CardPaymentRequest cardPaymentRequest, Merchant merchant)
{
var cardPaymentContext = _modelConverter.CreateCardPaymentContext(cardPaymentRequest, merchant);
_logger.LogInformation($"Initiating transaction for {cardPaymentContext.MerchantId} {cardPaymentContext.MerchantReference}");
//Generate transaction with unique id in pending state
var transaction = await _transactionService.InitialiseTransactionAsync(cardPaymentContext);
_logger.LogInformation($"Transaction {transaction.TransactionId} created for {cardPaymentContext.MerchantId} {cardPaymentContext.MerchantReference}");
var bankCardRequest = new BankCardRequest()
{
CardDetail = cardPaymentContext.CardDetail,
Amount = cardPaymentContext.Amount,
Cvv = cardPaymentRequest.Cvv,
Reference = cardPaymentContext.MerchantReference,
GatewayId = transaction.TransactionId
};
// go to bank and get the response
var response = await _bankService.ExecuteAsync(bankCardRequest);
_logger.LogInformation($"Bank response for TId={transaction.TransactionId} Bank [{response.Id} {response.Status}]");
// Update the transaction with bank response
var finalTransaction = await _transactionService.UpdateTransactionAsync(transaction.TransactionId, response);
_logger.LogInformation($"TId={transaction.TransactionId} updated with bank response [{response.Id} {response.Status}]");
return(_modelConverter.MapToCardPaymentResponse(finalTransaction));
}
public async Task <HubtelPosProxyResponse <MerchantCardResponse> > ChargeCardAsync(PaymentRequest paymentRequest, string accountId)
{
string merchantAccountNumber = await FindAccountNumberAsync(accountId).ConfigureAwait(false);
var url = $"{_merchantAccountConfiguration.PrivateBaseUrl}/merchants/{merchantAccountNumber}/receive/payworks";
var authToken = HubtelBasicAuthHelper.GenerateToken(_merchantAccountConfiguration.ApiKey, accountId);
var paymentType = _paymentTypeConfiguration.PaymentTypes.Find(x => x.Type.ToLower().Equals(paymentRequest.PaymentType));
var cardPaymentRequest = CardPaymentRequest.ToCardPaymentRequest(paymentRequest,
$"{_merchantAccountConfiguration.CallbackBaseUrl}/{paymentType.PrimaryCallbackUrl}",
$"{_merchantAccountConfiguration.CallbackBaseUrl}/{paymentType.SecondaryCallbackUrl}");
using (var response = await _merchantAccountHttpClient.PostAsync(url, cardPaymentRequest,
_merchantAccountConfiguration.Scheme, authToken))
{
var respData = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode)
{
var result = JsonConvert.DeserializeObject <MerchantCardResponse>(respData);
_logger.LogDebug(respData);
return(Responses.SuccessResponse(StatusMessage.Created, result, ResponseCodes.SUCCESS));
}
var error = GetMerchantAccountErrorResponse(respData, response.ReasonPhrase);
_logger.LogError(response.ReasonPhrase);
_logger.LogError(respData);
return(Responses.ErrorResponse(error.ToErrors(), new MerchantCardResponse(), error.Message, ResponseCodes.EXTERNAL_ERROR));
}
}
public void Setup()
{
_cardPaymentRequest = new CardPaymentRequest {
Amount = 40.00M,
OrderNumber = "asdfghjkl00001",
Card = new Card {
Name = "John Doe",
Number = "5100000010001004",
ExpiryMonth = "12",
ExpiryYear = "18",
Cvd = "123"
}
};
_executer = new Mock <IWebCommandExecuter>();
_bambora = new Gateway()
{
MerchantId = Constants.MerchantId,
SubMerchantId = Constants.SubMerchantId,
PaymentsApiKey = Constants.PaymentsApiKey,
ReportingApiKey = Constants.ReportingApiKey,
ProfilesApiKey = Constants.ProfilesApiKey,
ApiVersion = Constants.ApiVersion
};
}
public CardPaymentResponse DoPayment(CardPaymentRequest request)
{
var paymentStatus = _paymentRepository.GetPaymentStatus(request.RequestId);
if (paymentStatus != null)
{
throw new RequestAlreadyProcessedException(paymentStatus.Status, paymentStatus.RequestId);
}
var currentPaymentStatus = new PaymentStatus()
{
RequestId = request.RequestId, Status = PaymentStatusEnum.Scheduled
};
_paymentRepository.AddPaymentStatus(currentPaymentStatus);
var cards = _cardRepository.GetAllCards();
if (!cards.Contains(request.GetCard()))
{
return new CardPaymentResponse {
TransactionStatus = TransactionStatus.Declined, Message = "Wrong card details", RequestId = request.RequestId
}
}
;
var bankAccounts = _bankAccountRepository.GetAllBankAccounts();
if (!bankAccounts.Contains(request.GetBankAccount()))
{
return new CardPaymentResponse {
TransactionStatus = TransactionStatus.Declined, Message = "Wrong bank account details", RequestId = request.RequestId
}
}
;
try
{
// here the bank performs the transaction
currentPaymentStatus.TransactionId = Guid.NewGuid().ToString();
// transaction ok
currentPaymentStatus.Status = PaymentStatusEnum.Completed;
_paymentRepository.UpdatePaymentStatus(currentPaymentStatus);
}
catch (Exception e)
{
currentPaymentStatus.Status = PaymentStatusEnum.Error;
_paymentRepository.UpdatePaymentStatus(currentPaymentStatus);
throw;
}
// return the status
return(new CardPaymentResponse {
TransactionStatus = TransactionStatus.Succeeded, RequestId = request.RequestId, TransactionId = currentPaymentStatus.TransactionId
});
}
}
}
public async Task <IActionResult> CardPayment([FromBody] CardPaymentRequest cardPaymentRequest)
{
_logger.LogInformation($"Action=CardPayment Amount={cardPaymentRequest.Amount} Currency={cardPaymentRequest.CurrencyCode} Reference={cardPaymentRequest.Reference}");
var merchant = HttpContext.Items["Merchant"] as Merchant;
return(Ok(await _cardPaymentService.ProcessAsync(cardPaymentRequest, merchant)));
}
public CardPaymentCreated PostCardPayment(CardPaymentRequest cardPayment, string userIdentifier = null)
{
UseV2();
var uri = CreateUri(userIdentifier, cardpayments);
return(PostAsync <CardPaymentRequest, CardPaymentCreated>(uri, cardPayment));
}
/// <summary>
/// Pre-authorize a payment. Use this if you want to know if a customer has sufficient funds
/// before processing a payment. A real-world example of this is pre-authorizing at the gas pump
/// for $100 before you fill up, then end up only using $60 of gas; the customer is only charged
/// $60. The final payment is used with PreAuthCompletion().
/// </summary>
/// <returns>The response, in particular the payment ID that is needed to complete the purchase.</returns>
/// <param name="paymentRequest">Payment request.</param>
public PaymentResponse PreAuth(CardPaymentRequest paymentRequest)
{
Gateway.ThrowIfNullArgument(paymentRequest, "paymentRequest");
paymentRequest.Card.Complete = false; // false to make it a pre-auth
return(PreAuthInternal(paymentRequest));
}
public async Task <PaymentConfirmationResponse> SubmitPaymentAsync(string accessToken,
CardPaymentRequest cardPayment, CancellationToken cancellationToken = default)
{
var requestBody = JsonSerializer.Serialize(cardPayment, SerializerSettings);
return(await SubmitPaymentRequest(accessToken, requestBody, "payments/card", cancellationToken)
.ConfigureAwait(false));
}
public void GetPaymentStatus_ReturnsPaymentStatusResponse_WhenValidCardPaymentExists()
{
var tokenResponse = TestHelpers.GetCardToken(_accessToken, _loanPayClient);
var cardPayment = new CardPaymentRequest
{
BankNumber = TestHelpers.BankNumber,
CompanyNumber = TestHelpers.CompanyNumber,
AccountNumber = "123-123",
Amount = 12.34m,
ConvenienceFee = 4.65m,
PaymentMethod = new CardPaymentMethod
{
CardToken = tokenResponse.PaymentInformationToken.Token,
CardholderName = "Test Name",
CardExpiration = "0222",
Cvv = "123",
CardMeta = new CardPaymentMethodMetadata
{
IsDebit = tokenResponse.PaymentInformationToken.Metadata.IsDebitCard,
Network = tokenResponse.PaymentInformationToken.Metadata.Network
}
},
Contact = new ContactInfo
{
Name = "Test Name",
Phone = "(123) 456-7890",
Email = "*****@*****.**",
Address = "1039 3 Mile Rd NW",
City = "Walker",
State = "MI",
Zip = "49544"
},
ProcessDate = DateTime.Now,
SessionTimeStamp = DateTime.Now
};
var paymentResult = _loanPayClient.LoanPayApi.SubmitPaymentAsync(_accessToken, cardPayment, CancellationToken.None)
.ConfigureAwait(false)
.GetAwaiter()
.GetResult();
var confirmationNumber = paymentResult.Confirmation.ConfirmationNumber;
var actual = _loanPayClient.LoanPayApi.GetPaymentStatusAsync(_accessToken, confirmationNumber, CancellationToken.None)
.ConfigureAwait(false)
.GetAwaiter()
.GetResult();
if (actual.IsError)
{
_testOutputHelper.WriteLine(actual.Error);
}
Assert.False(actual.IsError);
Assert.Equal(Status.Processed, actual.PaymentStatus.Status);
}
public CardPaymentResponse Execute(CardPaymentRequest request)
{
CardPaymentResponse responseMessage = new CardPaymentResponse
{
AuthCode = Guid.NewGuid().ToString().Substring(0, 4).ToUpper()
};
Console.WriteLine("Worker activated to process response =>" + responseMessage.AuthCode, Color.Azure);
return(responseMessage);
}
public async void SubmitPaymentAsync_ReturnsError_WithFailedHttpStatusCode(HttpStatusCode statusCode, string responseString)
{
const string responseBody = @"";
var sut = GetTestClient(responseBody, statusCode);
var cardPayment = new CardPaymentRequest();
var actual = await sut.LoanPayApi.SubmitPaymentAsync("", cardPayment);
Assert.True(actual.IsError);
Assert.Null(actual.Confirmation);
Assert.StartsWith(responseString, actual.Error);
}
static void ProcessPreauthorization()
{
Console.WriteLine("Processing Pre-auth payments... ");
Gateway beanstream = new Gateway()
{
MerchantId = 300200578,
PaymentsApiKey = "4BaD82D9197b4cc4b70a221911eE9f70",
ApiVersion = "1"
};
CardPaymentRequest paymentRequest = new CardPaymentRequest {
Amount = 100.00,
OrderNumber = getRandomOrderId("test"),
Card = new Card {
Name = "John Doe",
Number = "5100000010001004",
ExpiryMonth = "12",
ExpiryYear = "18",
Cvd = "123"
}
};
// pre-authorize the payment for $100
PaymentResponse response = beanstream.Payments.PreAuth(paymentRequest);
// In order for Pre-authorizations to work, you must enable them on your account:
// http://support.beanstream.com/#docs/pre-authorizations-process-transaction-api.htm%3FTocPath%3DDeveloper%2520Resources%7CThe%2520Process%2520Transaction%2520API%7C_____8
//
// 1. Log in to the Online Member Area.
// 2. Navigate to administration > account admin > order settings in the left menu.
// 3. Under the heading Restrict Internet Transaction Processing Types, select either of the last two options:
// 3.a. Select Purchases or Pre-Authorization Only: allows you to process both types of transaction through your web interface
// 3.b. De-select Restrict Internet Transaction Processing Types: allows you to process all types of transactions including returns, voids and pre-auth completions
Console.WriteLine("Pre-auth Payment id: " + response.TransactionId + ", " + response.Message);
Assert.IsNotEmpty(response.TransactionId);
Assert.AreEqual("Approved", response.Message);
Assert.AreEqual("PA", response.TransType);
// complete the pre-auth and get the money from the customer
response = beanstream.Payments.PreAuthCompletion(response.TransactionId, 60.00);
Console.WriteLine("Pre-auth result: " + response.TransactionId + ", " + response.Message + "\n");
Assert.IsNotEmpty(response.TransactionId);
Assert.AreEqual("Approved", response.Message);
Assert.AreEqual("PAC", response.TransType);
}
public static void Main(string[] args)
{
var consoleConfiguration = new ConsoleConfiguration().Get();
using (var bus = RabbitHutch.CreateBus(consoleConfiguration[RabbitMqServer.ConStr]))
{
bus.SubscribeAsync <RegisterOrder>(RabbitMqServer.Registration.OrderQueue, message => Task.Factory.StartNew(() =>
{
Console.WriteLine("Payment = <" +
message.CardNumber + ", " +
message.CardHolderName + ", " +
message.ExpiryDate + ", " +
message.Amount + ">", Color.Lime);
var cardPaymentRequest = new CardPaymentRequest()
{
Amount = message.Amount,
CardHolderName = message.CardHolderName,
CardNumber = message.CardNumber,
ExpiryDate = message.ExpiryDate
};
var paymentResponse = bus.Request <CardPaymentRequest, CardPaymentResponse>(cardPaymentRequest);
var orderNotification = new OrderNotification()
{
Address = message.Address,
AuthCode = paymentResponse.AuthCode,
DeliveryDate = DateTime.Now.AddDays(14),
Email = message.Email,
Name = message.Name
};
bus.Publish(orderNotification, cfg => cfg.WithQueueName(RabbitMqServer.Notification.NotificationQueue));
}).ContinueWith(task =>
{
if (task.IsCompleted && !task.IsFaulted)
{
Console.WriteLine("Finished processing all messages", Color.Gray);
}
else
{
throw new EasyNetQException("Message processing exception - look in the default error queue (broker)");
}
}));
Console.WriteLine("Listening for messages. Hit <return> to quit.");
Console.ReadLine();
}
}
public CardPaymentRequest BuildCreditardPaymentRequest()
{
var req = new CardPaymentRequest(this.operation, this.intent, this.currency, this.description, this.userAgent, this.language, this.urls, this.payeeInfo);
foreach (var price in prices)
{
req.Payment.Prices.Add(price);
}
req.Payment.GeneratePaymentToken = this.generatePaymentToken;
req.Payment.PayerReference = this.payerReference;
req.Payment.Metadata = metadata;
return(req);
}
public async Task <string> GetPaymentUrlAsync(CardPaymentRequest request)
{
CardPaymentResponse result = await SendRequestAsync <CardPaymentResponse>(request, Link4PayApiType.ClientAuth, request.Transaction.TxnReference);
if (result == null)
{
return(string.Empty);
}
string url = _encryptionService.Decrypt(result.Payload);
string gatewayReference = url.Replace("//", "/").Split('/')[2];
string data = GetRedirectData(gatewayReference, request.Transaction.TxnReference);
return($"{_link4PaySettings.ExternalUrl}/redirect?payload={data}&url={url.ToBase64()}");
}
public void Setup()
{
_cardPaymentRequest = new CardPaymentRequest {
Amount = 40.00,
OrderNumber = "asdfghjkl00001",
Card = new Card {
Name = "John Doe",
Number = "5100000010001004",
ExpiryMonth = "12",
ExpiryYear = "18",
Cvd = "123"
}
};
_executer = new Mock <IWebCommandExecuter>();
}
private void InitiatePayment(APIClient client, int amount = 10000)
{
var request = new CardPaymentRequest
{
Amount = amount,
OrderId = "TEST" + TimedId,
IsMine = true
};
request.UrlReturn = "http://example.com/dummy/Payment";
request.Message = request.UrlReturn;
var result = client.PostCardPayment(request, UserId);
Assert.IsNotNull(result);
Assert.IsNotNullOrEmpty(result.Href);
Assert.IsTrue(result.Href.StartsWith(BaseUrl));
}
public async Task <ICardPaymentResponse> CreateCardPayment()
{
var totalAmount = this.cartService.CalculateTotal();
var vatAmount = new Amount(0);
try
{
var cardRequest = new CardPaymentRequest(Operation.Purchase,
PaymentIntent.Authorization, new Currency("SEK"),
"Test Purchase", this.payeeInfoOptions.PayeeReference,
new Language("sv-SE"),
new Urls(
this.urls.HostUrls.ToList(),
this.urls.CompleteUrl,
this.urls.TermsOfServiceUrl)
{
CancelUrl = this.urls.CancelUrl,
PaymentUrl = this.urls.PaymentUrl,
CallbackUrl = this.urls.CallbackUrl,
LogoUrl = this.urls.LogoUrl
},
new PayeeInfo(this.payeeInfoOptions.PayeeId,
this.payeeInfoOptions.PayeeReference)
);
foreach (var url in urls.HostUrls)
{
cardRequest.Payment.Urls.HostUrls.Add(url);
}
cardRequest.Payment.GenerateRecurrenceToken = true;
cardRequest.Payment.Prices.Add(new Price(new Amount(totalAmount), PriceType.CreditCard, vatAmount));
var cardPayment = await this.swedbankPayClient.Payments.CardPayments.Create(cardRequest);
this.cartService.PaymentLink = cardPayment.Payment.Id.OriginalString;
this.cartService.Instrument = PaymentInstrument.CreditCard;
this.cartService.PaymentOrderLink = null;
this.cartService.Update();
return(cardPayment);
}
catch (Exception ex)
{
Debug.Write(ex.Message);
return(null);
}
}
/// <summary>
/// Creates a card payment context from card payment request and merchant details
/// </summary>
/// <param name="cardPaymentRequest"></param>
/// <param name="merchant"></param>
/// <returns></returns>
public CardPaymentContext CreateCardPaymentContext(CardPaymentRequest cardPaymentRequest, Merchant merchant)
{
return(new CardPaymentContext()
{
CardDetail = new CardDetail()
{
ExpiryMonth = cardPaymentRequest.ExpiryMonth,
ExpiryYear = cardPaymentRequest.ExpiryYear,
CurrencyCode = cardPaymentRequest.CurrencyCode,
Name = cardPaymentRequest.Name,
Number = cardPaymentRequest.Number.Replace("-", "").Replace(" ", "")
},
Amount = cardPaymentRequest.Amount,
MerchantReference = cardPaymentRequest.Reference,
MerchantId = merchant.Id
});
}
public async void SubmitPaymentAsync_ReturnsError_WithMissingErrorsField()
{
const string responseBody = @"
{
""status"": ""BadRequest"",
""isError"": true,
""isEmpty"": true
}";
var sut = GetTestClient(responseBody, HttpStatusCode.BadRequest);
var cardPayment = new CardPaymentRequest();
var actual = await sut.LoanPayApi.SubmitPaymentAsync("", cardPayment);
Assert.True(actual.IsError);
Assert.Null(actual.Confirmation);
Assert.Contains("Could not read the response body.", actual.Error);
}
static void ProcessPreauthorization()
{
Console.WriteLine("Processing Pre-auth payments... ");
CardPaymentRequest paymentRequest = new CardPaymentRequest {
Amount = 100.00M,
OrderNumber = getRandomOrderId("test"),
Card = new Card {
Name = "John Doe",
Number = "5100000010001004",
ExpiryMonth = "12",
ExpiryYear = "18",
Cvd = "123"
}
};
// pre-authorize the payment for $100
PaymentResponse response = _bambora.Payments.PreAuth(paymentRequest);
// In order for Pre-authorizations to work, you must enable them on your account:
//
// 1. Log in to the Online Member Area.
// 2. Navigate to administration > account admin > order settings in the left menu.
// 3. Under the heading Restrict Internet Transaction Processing Types, select either of the last two options:
// 3.a. Select Purchases or Pre-Authorization Only: allows you to process both types of transaction through your web interface
// 3.b. De-select Restrict Internet Transaction Processing Types: allows you to process all types of transactions including returns, voids and pre-auth completions
Console.WriteLine("Pre-auth Payment id: " + response.TransactionId + ", " + response.Message);
Assert.IsNotEmpty(response.TransactionId);
Assert.AreEqual("Approved", response.Message);
Assert.AreEqual("PA", response.TransType);
// complete the pre-auth and get the money from the customer
response = _bambora.Payments.PreAuthCompletion(response.TransactionId, 60.00M);
Console.WriteLine("Pre-auth result: " + response.TransactionId + ", " + response.Message + "\n");
Assert.IsNotEmpty(response.TransactionId);
Assert.AreEqual("Approved", response.Message);
Assert.AreEqual("PAC", response.TransType);
}
public async void SubmitPaymentAsync_ReturnsError_WithMalformedJson()
{
const string responseBody = @"
{
""accountNumber"": ""123123"",
""bankNumber"": 5000,
""companyNumber"": 3939,
""amount"": 12.34,
""convenienceFee"": 4.65,
""processDate"": ""2021-10-27T00:00:00.000Z"",
""name"": ""Test Payment"",
""confirmationNumber"": ""1234567890""
";
var sut = GetTestClient(responseBody, HttpStatusCode.OK);
var cardPayment = new CardPaymentRequest();
var actual = await sut.LoanPayApi.SubmitPaymentAsync("", cardPayment);
Assert.True(actual.IsError);
Assert.Null(actual.Confirmation);
Assert.StartsWith("Could not read the response body", actual.Error);
}
public IActionResult DirectPayment([FromBody] DirectPaymentRequestModel directPaymentRequestModel)
{
try
{
var cardPaymentRequest = new CardPaymentRequest()
{
Amount = directPaymentRequestModel.Amount,
CardHolderName = directPaymentRequestModel.CardHolderName,
CardNumber = directPaymentRequestModel.CardNumber,
ExpiryDate = directPaymentRequestModel.ExpiryDate
};
using (var bus = RabbitMqConnectionHelper.Get())
{
var response = bus.Request <CardPaymentRequest, CardPaymentResponse>(cardPaymentRequest);
return(Ok(response));
}
}
catch (Exception exception)
{
return(BadRequest(exception.Message));
}
}
public PaymentResponse CardPayment(CardPaymentRequest cardDetails)
{
var accountId = _context.Accounts.Select(item => item).Where(item => item.AccountNumber == cardDetails.AccountNumber.ToString()).SingleOrDefault();
var cCardDetails = _context.Cards.Select(item => item).Where(item => item.AccountsId == accountId.Id && item.CardNumber == cardDetails.CardNumber.ToString()).SingleOrDefault();
// var shareDetails = _context.Shares.Select(item => item).Where(item => item.AccountsId == accountId.Id).SingleOrDefault();
var shareDetails = _context.Shares.Select(item => item).Where(item => item.AccountsId == accountId.Id).ToList()[0];
Transactions transactions = null;
if (shareDetails.Balance > Convert.ToDecimal(cardDetails.Amount))
{
if (Convert.ToDecimal(cardDetails.Amount) < Convert.ToDecimal(cCardDetails.PaymentDue))
{
// partial payment
shareDetails.Balance = shareDetails.Balance - Convert.ToDecimal(cardDetails.Amount);
_context.SaveChanges();
transactions = new Transactions();
transactions.Amount = Convert.ToDecimal(cardDetails.Amount);
transactions.AccountsId = accountId.Id;
transactions.Description = "card payment";
transactions.Postdate = DateTime.Today.ToString();
transactions.RecordId = 3;
transactions.Type = "CARD";
_context.Add(transactions);
_context.SaveChanges();
var cardPayment = _context.Cards.Select(item => item).Where(item => item.AccountsId == accountId.Id && item.CardNumber == cardDetails.CardNumber.ToString()).SingleOrDefault();
cardPayment.PaymentDue = cardPayment.PaymentDue - Convert.ToDecimal(cardDetails.Amount);
_context.SaveChanges();
return(new PaymentResponse()
{
Status = true,
Description = "Bill payment successful"
});
}
else
{
// Full payment
transactions = new Transactions();
shareDetails.Balance = shareDetails.Balance - Convert.ToDecimal(cardDetails.Amount);
//shareDetails.AccountsId = accountId.Id;
//_context.Update(share);
_context.SaveChanges();
transactions.Amount = Convert.ToDecimal(cardDetails.Amount);
transactions.AccountsId = accountId.Id;
transactions.Description = "card payment";
transactions.Postdate = DateTime.Today.ToString();
transactions.RecordId = 3;
transactions.Type = "Card payment";
_context.Add(transactions);
_context.SaveChanges();
var cardPayment = _context.Cards.Select(item => item).Where(item => item.AccountsId == accountId.Id && item.CardNumber == cardDetails.CardNumber.ToString()).SingleOrDefault();
cardPayment.PaymentDue = cardPayment.PaymentDue - Convert.ToDecimal(cardDetails.Amount);
cardPayment.PaymentDueDate = DateTime.Today.AddMonths(1).ToString();
cardPayment.Type = "CREDIT";
_context.SaveChanges();
return(new PaymentResponse()
{
Status = true,
Description = "Bill payment successful"
});
}
}
else
{
return(new PaymentResponse()
{
Status = false,
Description = "Share amount is less than payment amount"
});
}
}
public IActionResult CardPayment([FromBody] CardPaymentRequest value)
{
var paymentManger = new PaymentManager(_context);
return(Ok(paymentManger.CardPayment(value)));
}
private void submitPaymentButton_Click(object sender, EventArgs e)
{
//checking whether the fields are empty
if (amountTextBox.Text == String.Empty)
{
MessageBox.Show("Please input a valid amount");
}
else if (nameTextBox.Text == String.Empty)
{
MessageBox.Show("Please input the Name on the Card");
}
else if (cardNumberTextBox.Text == String.Empty)
{
MessageBox.Show("Please input the Card Nuber");
}
else if (monthComboBox.Text == String.Empty && yearComboBox.Text == String.Empty)
{
MessageBox.Show("Please input the Expiry Details");
}
else if (cardNumberTextBox.Text == String.Empty)
{
MessageBox.Show("Plese input the namber on the back of the card");
}
else
{
try
{
//validation for the amount
if (Convert.ToDouble(amountTextBox.Text) > 1000)
{
MessageBox.Show("Payment amount is limited to $1,000.");
}
else if (Convert.ToDouble(amountTextBox.Text) <= 0)
{
MessageBox.Show("Please input a valid amount");
}
else
{
const string paymentsAPIKeyString = "b9950D37FE0c4f92A1177F7C935CcBeA";
const int merchantIDInt = 300201147;
const string APIVersionInt = "1";
// Initialize Gateway connection
Gateway bsGateway = new Gateway();
bsGateway.MerchantId = merchantIDInt;
bsGateway.PaymentsApiKey = paymentsAPIKeyString;
bsGateway.ApiVersion = APIVersionInt;
// Setup the Credit Card details
Card ccCard = new Card();
ccCard.Name = nameTextBox.Text;
ccCard.Number = cardNumberTextBox.Text;
ccCard.ExpiryMonth = monthComboBox.SelectedItem.ToString();
ccCard.ExpiryYear = yearComboBox.SelectedItem.ToString();
ccCard.Cvd = cvvTextBox.Text;
// Setup the payment request
CardPaymentRequest reqCardPaymentRequest = new CardPaymentRequest();
reqCardPaymentRequest.Amount = Convert.ToDouble(amountTextBox.Text);
reqCardPaymentRequest.OrderNumber = "1264561589aa0" + DateTime.Now.TimeOfDay;
reqCardPaymentRequest.Card = ccCard;
// Process the payment and get the response from their servers
PaymentResponse response = bsGateway.Payments.MakePayment(reqCardPaymentRequest);
MessageBox.Show("Payment " + response.Message);//status message
//save data in the dat set
paymentsTableAdapter.Insert(
response.Created.ToString(),
response.Message,
response.Card.CardType,
nameTextBox.Text,
response.Card.LastFour,
Convert.ToDecimal(amountTextBox.Text),
response.OrderNumber,
response.TransactionId
);
//clearing fields
paymentsTableAdapter.Fill(paymentsDataSet.Payments);
amountTextBox.Text = nameTextBox.Text = cardNumberTextBox.Text = cvvTextBox.Text = String.Empty;
monthComboBox.SelectedIndex = yearComboBox.SelectedIndex = -1;
amountTextBox.Focus();
}
}
catch
{
MessageBox.Show("Invalid Payment Information. Payment was unsuccessful");
}
}
}
public CardPaymentRequestDto(CardPaymentRequest paymentRequest)
{
Payment = new CardPaymentDetailsDto(paymentRequest.Payment);
}
