public void ChargeCreditCard_ReturnsSuccessForValidCard()
{
ProcessorResponse processorResponse = _authorizeNetCreditCardPaymentGateway.ChargeCreditCard(VAILD_TEST_CC);
Assert.AreEqual(ProcessorResponseResult.Accepted, processorResponse.ProcessorResult);
Assert.IsNotNull(processorResponse);
}
/// <summary>
/// Update existing donor payment profile for a donor
/// </summary>
/// <param name="BankAccount">Donor payment profile details</param>
/// <returns>Payment Response with success, message, and profile token</returns>
public ProcessorResponse UpdateBankAccount(BankAccount BankAccount)
{
var response = new ProcessorResponse();
try
{
using (var db = new GenerousAPIEntities())
{
//save changes to database
db.Entry(BankAccount).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
}
response.Message = "Bank Account successfully updated";
response.AuthToken = BankAccount.BankAccountTokenId;
response.IsSuccess = true;
}
catch (Exception ex)
{
response.IsSuccess = false;
response.Message = ex.Message;
}
return(response);
}
/// <summary>
/// Delete a payment profile for a donor
/// </summary>
/// <param name="BankAccountTokenId">Payment profile token id</param>
/// <returns>Payment Response with success, message, and profile token</returns>
public ProcessorResponse DeleteBankAccount(string BankAccountTokenId)
{
var response = new ProcessorResponse();
try
{
using (var db = new GenerousAPIEntities())
{
var BankAccount = db.BankAccounts.Where(x => x.BankAccountTokenId == BankAccountTokenId).SingleOrDefault();
DbEntityEntry dbEntityEntry = db.Entry(BankAccount);
if (dbEntityEntry.State == System.Data.Entity.EntityState.Detached)
{
db.BankAccounts.Attach(BankAccount);
}
BankAccount.Active = false;
db.SaveChanges();
}
response.AuthToken = BankAccountTokenId;
response.Message = "Bank Account successfully deleted";
response.IsSuccess = true;
}
catch (Exception ex)
{
response.IsSuccess = false;
response.Message = ex.Message;
}
return(response);
}
/// <summary>
/// Delete a payment profile for a donor
/// </summary>
/// <param name="paymentProfileTokenId">Payment profile token id</param>
/// <returns>Payment Response with success, message, and profile token</returns>
public ProcessorResponse DeletePaymentProfile(string paymentProfileTokenId)
{
var response = new ProcessorResponse();
try
{
using (var db = new GenerousAPIEntities())
{
var paymentProfile = db.PaymentProfiles.Where(x => x.TokenId == paymentProfileTokenId).SingleOrDefault();
DbEntityEntry dbEntityEntry = db.Entry(paymentProfile);
if (dbEntityEntry.State == System.Data.Entity.EntityState.Detached)
{
db.PaymentProfiles.Attach(paymentProfile);
}
db.PaymentProfiles.Remove(paymentProfile);
db.SaveChanges();
}
response.Message = "Payment profile successfully deleted";
response.IsSuccess = true;
}
catch (Exception ex)
{
response.IsSuccess = false;
response.Message = ex.Message;
}
return(response);
}
/// <summary>
/// Update a record for transaction details
/// </summary>
/// <param name="transactionDetails">Transaction details</param>
/// <returns>Response with success, message, and profile token</returns>
public ProcessorResponse UpdateTransactionRecord(TransactionDetail transactionDetails)
{
var response = new ProcessorResponse();
try
{
using (var db = new GenerousAPIEntities())
{
//save changes to database
db.Entry(transactionDetails).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
}
response.Message = "Transaction successfully updated";
response.AuthToken = transactionDetails.PaymentProfileTokenId;
response.IsSuccess = true;
}
catch (Exception ex)
{
response.IsSuccess = false;
response.Message = ex.Message;
}
return(response);
}
public void SetUp()
{
var fixture = new Fixture();
_processorResponse = fixture.Create <ProcessorResponse>();
_authoriseResponseMapper = new AuthoriseResponseMapper();
}
public void RefundRequest_ReturnsSuccessForaPreviousRealValidChargeTransaction()
{
var rawResponse = "";//"1|1|1|This transaction has been approved.|919264|Y|3706081658|23708_1314322||204.00|CC|auth_capture||kim|wasserman||819peacock plaza|Key West|FL|33040|US|||[email protected]||||||||||||||027E6504A6CD489857DABD492B2DC118|P||||||||||||XXXX3413|Visa||||||||||||||||";
var processorResponse = new ProcessorResponse(rawResponse);
processorResponse = _authorizeNetCreditCardPaymentGateway.RefundRequestOnSameCreditCard(processorResponse.TransactionCode, "3413", new DateTime(2012, 6, 1), "204");
Assert.IsNotNull(processorResponse);
Assert.AreEqual(ProcessorResponseResult.Accepted, processorResponse.ProcessorResult);
}
public void ChargeCreditCard_FailsForInValidCard()
{
var invalidCard = VAILD_TEST_CC;
invalidCard.CreditCardNo = "41111111111112222";
ProcessorResponse processorResponse = _authorizeNetCreditCardPaymentGateway.ChargeCreditCard(invalidCard);
Assert.AreEqual(ProcessorResponseResult.Fail, processorResponse.ProcessorResult);
Assert.IsNotNull(processorResponse);
}
public void ChargeCreditCard_DeclinesForExpiredCard()
{
var expiredCard = VAILD_TEST_CC;
expiredCard.ExpiryMonth = 1;
expiredCard.ExpiryYear = 2001;
ProcessorResponse processorResponse = _authorizeNetCreditCardPaymentGateway.ChargeCreditCard(expiredCard);
Assert.AreEqual(ProcessorResponseResult.Rejected, processorResponse.ProcessorResult);
Assert.IsNotNull(processorResponse);
}
public void VoidRequest_ReturnsSuccessForRealValidChargeTransaction()
{
ProcessorResponse processorResponse = _authorizeNetCreditCardPaymentGateway.ChargeCreditCard(VALID_REAL_CC);
Assert.IsNotNull(processorResponse);
Assert.AreEqual(ProcessorResponseResult.Accepted, processorResponse.ProcessorResult);
processorResponse = _authorizeNetCreditCardPaymentGateway.VoidRequestforaPreviousResponse(processorResponse.RawResponse);
Assert.IsNotNull(processorResponse);
Assert.AreEqual(ProcessorResponseResult.Accepted, processorResponse.ProcessorResult);
}
public void RefundRequest_ReturnsSuccessForRealValidChargeTransaction()
{
ProcessorResponse processorResponse = _authorizeNetCreditCardPaymentGateway.ChargeCreditCard(VALID_REAL_CC);
Assert.IsNotNull(processorResponse);
Assert.AreEqual(ProcessorResponseResult.Accepted, processorResponse.ProcessorResult);
processorResponse = _authorizeNetCreditCardPaymentGateway.RefundRequestOnSameCreditCard(processorResponse.TransactionCode, VALID_REAL_CC.CreditCardNo, new DateTime(VALID_REAL_CC.ExpiryYear, VALID_REAL_CC.ExpiryMonth, 1), "10");
Assert.IsNotNull(processorResponse);
Assert.AreEqual(ProcessorResponseResult.Accepted, processorResponse.ProcessorResult);
}
private PaymentViewData GetPaymentInstrumentInformation(PaymentInstrument paymentInstrument, PaymentViewData paymentViewData)
{
if (paymentInstrument is CheckPayment)
{
var checkPayment = paymentInstrument as CheckPayment;
paymentViewData.InstrumentNumber = checkPayment.Check.CheckNumber;
}
else if (paymentInstrument is ECheckPayment)
{
var eCheckPayment = paymentInstrument as ECheckPayment;
var processorResponse = eCheckPayment.ProcessorResponse.Split('|');
paymentViewData.ProcessorResponse = processorResponse.Length >= 6
? processorResponse.GetValue(6).ToString()
: "-N/A-";
paymentViewData.InstrumentNumber = eCheckPayment.ECheck.CheckNumber;
}
else if (paymentInstrument is ChargeCardPayment)
{
var chargeCardPayment = paymentInstrument as ChargeCardPayment;
paymentViewData.ProcessorResponse = "-N/A-";
if (ProcessorResponse.IsValidResponseString(chargeCardPayment.ProcessorResponse))
{
paymentViewData.ProcessorResponse =
new ProcessorResponse(chargeCardPayment.ProcessorResponse).TransactionCode;
}
var chargeCard = _chargeCardRepository.GetById(chargeCardPayment.ChargeCardId);
if (chargeCard != null)
{
paymentViewData.InstrumentDate = chargeCard.ExpirationDate.ToString("MM/yyyy");
paymentViewData.InstrumentNumber = chargeCard.Number.Length > 3 ? chargeCard.TypeId + " - ends with " + chargeCard.Number.Substring(
chargeCard.Number.Length - 4, 4) : chargeCard.Number;
}
}
else if (paymentInstrument is InsurancePayment)
{
var insurancePayment = paymentInstrument as InsurancePayment;
if (insurancePayment.AmountToBePaid > insurancePayment.Amount)
{
paymentViewData.ProcessorResponse = "Amount: $" + insurancePayment.AmountToBePaid.ToString("0.00") + ", Status: Pending for settlement";
}
else
{
paymentViewData.ProcessorResponse = "Amount: $" + insurancePayment.AmountToBePaid.ToString("0.00") + ", Status: Payment settled";
}
}
return(paymentViewData);
}
/// <summary>
/// Clear out records from table
/// </summary>
/// <returns>ProcessorResponse info</returns>
public ProcessorResponse ClearExpiringCreditCardInfo()
{
var response = new ProcessorResponse();
try
{
using (var db = new GenerousAPIEntities())
{
db.Database.ExecuteSqlCommand("DELETE from ExpiringCreditCardsForOrganisation");
}
response.IsSuccess = true;
}
catch (Exception ex)
{
response.IsSuccess = false;
}
return(response);
}
/// <summary>
/// Create a new record for transaction details
/// </summary>
/// <param name="transactionDetails">Transaction details</param>
/// <returns>Response with success, message, and profile token</returns>
public ProcessorResponse CreateTransactionRecord(TransactionDetail transactionDetails)
{
var response = new ProcessorResponse();
try
{
using (var db = new GenerousAPIEntities())
{
db.TransactionDetails.Add(transactionDetails);
db.SaveChanges();
}
response.Message = "Transaction successfully saved";
response.IsSuccess = true;
}
catch (Exception ex)
{
response.IsSuccess = false;
response.Message = ex.Message;
}
return(response);
}
/// <summary>
/// Create a new donor payment profile for a donor
/// </summary>
/// <param name="PaymentProfile">Donor payment profile details</param>
/// <returns>Payment Response with success, message, and profile token</returns>
public ProcessorResponse CreatePaymentProfile(PaymentProfile PaymentProfile)
{
var response = new ProcessorResponse();
try
{
using (var db = new GenerousAPIEntities())
{
db.PaymentProfiles.Add(PaymentProfile);
db.SaveChanges();
}
response.Message = "Payment profile successfully saved";
response.AuthToken = PaymentProfile.TokenId;
response.IsSuccess = true;
}
catch (Exception ex)
{
response.IsSuccess = false;
response.Message = ex.Message + ex.InnerException;
}
return(response);
}
/// <summary>
/// Create a new donor payment profile for a donor
/// </summary>
/// <param name="BankAccount">Donor payment profile details</param>
/// <returns>Payment Response with success, message, and profile token</returns>
public ProcessorResponse CreateBankAccount(BankAccount BankAccount)
{
var response = new ProcessorResponse();
try
{
using (var db = new GenerousAPIEntities())
{
db.BankAccounts.Add(BankAccount);
db.SaveChanges();
}
response.Message = "Bank Account successfully saved";
response.AuthToken = BankAccount.BankAccountTokenId;
response.IsSuccess = true;
}
catch (Exception ex)
{
response.IsSuccess = false;
response.Message = ex.Message;
}
return(response);
}
/// <summary>
/// Checks if the given transaction is valid for refund or not
/// </summary>
/// <param name="cardPayment"></param>
/// <param name="amountToRefund"></param>
/// <returns></returns>
public bool IsCardValidforRefund(ChargeCardPayment cardPayment, decimal amountToRefund, out string reasonForFailure)
{
reasonForFailure = string.Empty;
if (cardPayment.Amount < amountToRefund)
{
reasonForFailure = "The payment gateway doesn't allow refund of an amount greater than the one in the last transaction made. The Last Transaction amount is ($" + cardPayment.Amount.ToString("0.00") + ").";
return(false);
}
if (cardPayment.DataRecorderMetaData.DateCreated < DateTime.Now.Date.AddDays(-120))
{
reasonForFailure = "Can Not Refund against the last transaction, made on Card on file. As the valid date of making a request is within 120 days.";
return(false);
}
if (!ProcessorResponse.IsValidResponseString(cardPayment.ProcessorResponse))
{
reasonForFailure = "No valid Transaction Code found in the database, for the selected card on file.";
return(false);
}
return(true);
}
public ProcessorResponse VoidRequestforaPreviousResponse(string rawResponse)
{
var processorResponse = new ProcessorResponse(rawResponse);
return(VoidRequest(processorResponse.TransactionCode));
}
public void ManagePayment(PaymentEditModel paymentEditModel, long customerId, string ipAddress, string uniquePaymentReference)
{
if (paymentEditModel.Payments == null || paymentEditModel.Payments.Count() < 1)
{
return;
}
var customer = _customerRepository.GetCustomer(customerId);
var payments = paymentEditModel.Payments.Where(p => p.Amount != 0);
int index = 1;
try
{
foreach (var payment in payments)
{
if (payment.PaymentType == PaymentType.ElectronicCheck.PersistenceLayerId && paymentEditModel.PaymentFlow == PaymentFlow.In)
{
var response = _checkService.ChargefromECheck(payment.ECheck.ECheck,
Mapper.Map <AddressEditModel, Address>(
paymentEditModel.ExistingBillingAddress), customer, ipAddress,
uniquePaymentReference);
if (response.ProcessorResult != ProcessorResponseResult.Accepted)
{
new NLogLogManager().GetLogger <PaymentController>().Info("ECheck Transaction - Details [RawResponse: " + response.RawResponse + "]");
throw new Exception("Transaction Failed!");
}
payment.IsProcessed = true;
payment.ECheck.ECheckPayment.ProcessorResponse = response.RawResponse;
}
else if ((payment.PaymentType == PaymentType.CreditCard.PersistenceLayerId || payment.PaymentType == PaymentType.CreditCardOnFile_Value) && payment.ChargeCard != null)
{
var transactionAmount = payment.ChargeCard.ChargeCardPayment.Amount;
if (paymentEditModel.PaymentFlow == PaymentFlow.Out)
{
transactionAmount = -1 * transactionAmount;
}
ProcessorResponse response = null;
if (paymentEditModel.PaymentFlow == PaymentFlow.Out)
{
if (_isEccEnabled)
{
response = _chargeCardService.ApplyRefundtoNewCard(transactionAmount, customer.Name,
payment.ChargeCard.ChargeCard,
payment.BillingAddress, ipAddress,
uniquePaymentReference + "(" + index +
")", customer.Email != null ? customer.Email.ToString() : string.Empty);
}
else if (payment.PaymentType == PaymentType.CreditCardOnFile_Value)
{
var cardPayment = _chargeCardPaymentRepository.GetById(payment.ChargeCard.ChargeCardPayment.Id);
string reasonForFailure = "";
bool isValidcard = _chargeCardService.IsCardValidforRefund(cardPayment, payment.Amount, out reasonForFailure);
if (!isValidcard)
{
throw new Exception(reasonForFailure);
}
string previousResponse = cardPayment.ProcessorResponse;
if (cardPayment.Amount == payment.Amount)
{
response = _chargeCardService.VoidRequest(previousResponse);
if (response.ProcessorResult != ProcessorResponseResult.Accepted)
{
response = _chargeCardService.ApplyRefundtoCardonFile(transactionAmount, payment.ChargeCard.ChargeCard.Number, payment.ChargeCard.ChargeCard.ExpirationDate, previousResponse);
}
else
{
new NLogLogManager().GetLogger <PaymentController>().Info("CC Void Request - Details [RawResponse: " + response.RawResponse + "]");
}
}
else
{
response = _chargeCardService.ApplyRefundtoCardonFile(transactionAmount, payment.ChargeCard.ChargeCard.Number, payment.ChargeCard.ChargeCard.ExpirationDate, previousResponse);
}
}
else
{
throw new Exception("Refund on the provided card is not allowed. Please choose any other option.");
}
}
else
{
response = _chargeCardService.ChargefromCard(transactionAmount, new Name(payment.ChargeCard.ChargeCard.NameOnCard), payment.ChargeCard.ChargeCard, payment.BillingAddress, ipAddress,
uniquePaymentReference + "(" + index + ")", customer.Email != null ? customer.Email.ToString() : string.Empty);
}
if (response.ProcessorResult != ProcessorResponseResult.Accepted)
{
new NLogLogManager().GetLogger <PaymentController>().Info("CC Transaction - Details [RawResponse: " + response.RawResponse + "]");
throw new Exception("Transaction Failed!");
}
payment.IsProcessed = true;
payment.ChargeCard.ChargeCardPayment.ProcessorResponse = response.RawResponse;
}
index++;
}
}
catch (Exception ex)
{
throw new Exception(
"An exception caused while " + (paymentEditModel.PaymentFlow == PaymentFlow.Out ? "refunding" : "charging") + " amount. Message: " + ex.Message, ex);
}
}
public ProcessorResponse ApplyRefundtoCardonFile(decimal amountToRefund, string cardNumber, DateTime expiryDate, string rawResponse)
{
var processorResponse = new ProcessorResponse(rawResponse);
return(_paymentProcessor.RefundRequestOnSameCreditCard(processorResponse.TransactionCode, cardNumber, expiryDate, (amountToRefund > 0 ? (-1 * amountToRefund) : amountToRefund).ToString()));
}
private void CompleteEditModel(RefundRequestResultEditModel model, long customerId)
{
string value = _configurationSettingRepository.GetConfigurationValue(ConfigurationSettingName.CancellationFee);
if (!string.IsNullOrEmpty(value))
{
decimal fee;
Decimal.TryParse(value.Trim(), out fee);
model.CancellationFee = fee;
}
if (model.PaymentEditModel == null)
{
model.PaymentEditModel = new PaymentEditModel
{
PaymentFlow = PaymentFlow.Out
};
}
if (_isEccEnabled)
{
model.PaymentEditModel.AllowedPaymentTypes = new[] { new OrderedPair <long, string>(PaymentType.Check.PersistenceLayerId, PaymentType.Check.Name),
new OrderedPair <long, string>(PaymentType.Cash.PersistenceLayerId, PaymentType.Cash.Name),
new OrderedPair <long, string>(PaymentType.CreditCard.PersistenceLayerId, PaymentType.CreditCard.Name) }
}
;
else
{
model.PaymentEditModel.AllowedPaymentTypes = new[]
{
new OrderedPair <long, string>(PaymentType.Check.PersistenceLayerId, PaymentType.Check.Name),
new OrderedPair <long, string>(PaymentType.Cash.PersistenceLayerId, PaymentType.Cash.Name)
}
};
var order = _orderRepository.GetOrder(model.OrderId);
var validCardPayment = order.PaymentsApplied.Where(pi => pi.PaymentType == PaymentType.CreditCard).OrderBy(
pi => pi.DataRecorderMetaData.DateCreated).Select(pi => (ChargeCardPayment)pi).LastOrDefault();
if (validCardPayment != null && (_isEccEnabled || (validCardPayment.Amount > 0 && validCardPayment.DataRecorderMetaData.DateCreated > DateTime.Now.Date.AddDays(-120) && ProcessorResponse.IsValidResponseString(validCardPayment.ProcessorResponse))))
{
model.PaymentEditModel.ChargeCardonFile = new ChargeCardPaymentEditModel()
{
ChargeCardPayment = validCardPayment,
ChargeCard = _chargeCardRepository.GetById(validCardPayment.ChargeCardId)
};
model.PaymentEditModel.AllowedPaymentTypes = model.PaymentEditModel.AllowedPaymentTypes.Concat(new[]
{
new OrderedPair <long, string>(PaymentType.CreditCardOnFile_Value, PaymentType.CreditCardOnFile_Text)
});
}
model.PaymentEditModel.ExistingBillingAddress =
Mapper.Map <Address, AddressEditModel>(_customerRepository.GetCustomer(customerId).BillingAddress) ?? new AddressEditModel();
}
public CreditCardReconcileListModel Create(IEnumerable <ChargeCardPayment> chargeCardPayments, IEnumerable <ChargeCard> chargeCards, IEnumerable <OrderedPair <long, long> > orderPaymentIdOrderedPairs, IEnumerable <Order> orders,
IEnumerable <OrderedPair <long, string> > customerNameIdPairs, IEnumerable <Event> events, IEnumerable <OrderedPair <long, string> > eventPods, IEnumerable <OrderedPair <long, string> > corporateAccountNameOrderedPairs)
{
var listModel = new CreditCardReconcileListModel();
var array = new CreditCardReconcileModel[chargeCardPayments.Count()];
var index = 0;
foreach (var chargeCardPayment in chargeCardPayments)
{
var chargeCard = chargeCards.Where(c => c.Id == chargeCardPayment.ChargeCardId).SingleOrDefault();
var orderId =
orderPaymentIdOrderedPairs.Where(p => p.SecondValue == chargeCardPayment.PaymentId).Select(p => p.FirstValue).SingleOrDefault();
var order = orders.Where(o => o.Id == orderId).SingleOrDefault();
if (order == null)
{
continue;
}
var customerName = customerNameIdPairs.Where(p => p.FirstValue == order.CustomerId).FirstOrDefault();
var eventPod = eventPods.Where(ep => ep.FirstValue == order.EventId).SingleOrDefault();
string pods = eventPod != null ? eventPod.SecondValue : string.Empty;
var theEvent = events != null && order.EventId.HasValue
? events.Where(e => e.Id == order.EventId).SingleOrDefault()
: null;
string prepaid = "No";
decimal prePaidSum = 0;
if (theEvent != null)
{
prePaidSum = order.PaymentsApplied.Where(
pa => pa.DataRecorderMetaData.DateCreated < theEvent.EventDate).Sum(
p => p.Amount);
if (
order.PaymentsApplied.Where(pa => pa.DataRecorderMetaData.DateCreated < theEvent.EventDate).
Count() > 0 && prePaidSum < order.DiscountedTotal)
{
prepaid = "Partial Paid";
}
else if (order.DiscountedTotal == order.TotalAmountPaid &&
order.PaymentsApplied.Where(pa => pa.DataRecorderMetaData.DateCreated >= theEvent.EventDate)
.Count() < 1)
{
prepaid = "Yes";
}
else if (chargeCardPayment.DataRecorderMetaData.DataRecorderCreator.Id == customerName.FirstValue)
{
prepaid = "Yes";
}
}
else
{
prepaid = " -N/A-";
prePaidSum = order.PaymentsApplied.Sum(p => p.Amount);
}
var account = theEvent != null?corporateAccountNameOrderedPairs.FirstOrDefault(x => x.FirstValue == theEvent.Id) : null;
var model = new CreditCardReconcileModel
{
EventId = theEvent != null ? theEvent.Id : 0,
Amount = chargeCardPayment.Amount,
CardType = chargeCard.TypeId.ToString(),
CustomerName = customerName.SecondValue,
DateApproved = chargeCardPayment.DataRecorderMetaData.DateCreated,
Pod = pods,
ReceiptNumber = ProcessorResponse.IsValidResponseString(chargeCardPayment.ProcessorResponse) ? new ProcessorResponse(chargeCardPayment.ProcessorResponse).TransactionCode : chargeCardPayment.ProcessorResponse,
IsOnline = chargeCardPayment.DataRecorderMetaData.DataRecorderCreator.Id == customerName.FirstValue,
Prepaid = prepaid,
CorporatePartner = account == null ? "N/A" : account.SecondValue,
EventType = theEvent != null ? ((theEvent.EventType == EventType.Retail) ? EventType.Retail.ToString() : EventType.Corporate.ToString()) : "N/A"
};
array[index++] = model;
}
listModel.Collection = array;
return(listModel);
}
public ProcessorResponse VoidRequest(string rawResponse)
{
var processorResponse = new ProcessorResponse(rawResponse);
return(_paymentProcessor.VoidRequest(processorResponse.TransactionCode));
}
