/// <summary>
/// Does the actual work of refunding a payment
/// </summary>
/// <param name="invoice">The <see cref="IInvoice"/></param>
/// <param name="payment">The previously Authorize payment to be captured</param>
/// <param name="amount">The amount to be refunded</param>
/// <param name="args">Any arguments required to process the payment.</param>
/// <returns>The <see cref="IPaymentResult"/></returns>
protected override IPaymentResult PerformRefundPayment(IInvoice invoice, IPayment payment, decimal amount, ProcessorArgumentCollection args)
{
var result = _processor.RefundPayment(invoice, payment, amount);
if (!result.Payment.Success)
{
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Denied,
result.Payment.Exception.Message, 0);
return result;
}
// use the overloaded AppliedPayments method here for testing if we don't have
// a MerchelloContext
foreach (var applied in payment.AppliedPayments(GatewayProviderService))
{
applied.TransactionType = AppliedPaymentType.Refund;
applied.Amount = 0;
applied.Description += " - Refunded";
GatewayProviderService.Save(applied);
}
payment.Amount = payment.Amount - amount;
if (payment.Amount != 0)
{
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Debit,
"To show partial payment remaining after refund", payment.Amount);
}
GatewayProviderService.Save(payment);
return new PaymentResult(Attempt<IPayment>.Succeed(payment), invoice, false);
}
/// <summary>
/// Does the actual work capturing a payment
/// </summary>
/// <param name="invoice">The <see cref="IInvoice"/></param>
/// <param name="payment">The previously Authorize payment to be captured</param>
/// <param name="amount">The amount to capture</param>
/// <param name="args">Any arguments required to process the payment.</param>
/// <returns>The <see cref="IPaymentResult"/></returns>
protected override IPaymentResult PerformCapturePayment(IInvoice invoice, IPayment payment, decimal amount, ProcessorArgumentCollection args)
{
var result = _processor.PriorAuthorizeCapturePayment(invoice, payment);
GatewayProviderService.Save(payment);
if (!result.Payment.Success)
{
GatewayProviderService.ApplyPaymentToInvoice(
payment.Key,
invoice.Key,
AppliedPaymentType.Denied,
result.Payment.Exception.Message,
0);
}
else
{
GatewayProviderService.ApplyPaymentToInvoice(
payment.Key,
invoice.Key,
AppliedPaymentType.Debit,
payment.ExtendedData.GetValue(Constants.ExtendedDataKeys.CaptureTransactionResult),
amount);
}
return(result);
}
private IPaymentResult ProcessPayment(IInvoice invoice, TransactionMode transactionMode, decimal amount, ProcessorArgumentCollection args)
{
var cc = args.AsCreditCardFormData();
var payment = GatewayProviderService.CreatePayment(PaymentMethodType.CreditCard, invoice.Total, PaymentMethod.Key);
payment.CustomerKey = invoice.CustomerKey;
payment.Authorized = false;
payment.Collected = false;
payment.PaymentMethodName = string.Format("{0} Chase Credit Card", cc.CreditCardType);
payment.ExtendedData.SetValue(Constants.ExtendedDataKeys.CcLastFour, cc.CardNumber.Substring(cc.CardNumber.Length - 4, 4).EncryptWithMachineKey());
var result = _processor.ProcessPayment(invoice, payment, transactionMode, amount, cc);
GatewayProviderService.Save(payment);
if (!result.Payment.Success)
{
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Denied, result.Payment.Exception.Message, 0);
}
else
{
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Debit,
payment.ExtendedData.GetValue(Constants.ExtendedDataKeys.AuthorizationTransactionResult) +
(transactionMode == TransactionMode.AuthorizeAndCapture ? string.Empty : " to show record of Authorization"),
transactionMode == TransactionMode.AuthorizeAndCapture ? invoice.Total : 0);
}
return(result);
}
/// <summary>
/// Does the actual work of authorizing the payment
/// </summary>
/// <param name="invoice">
/// The invoice.
/// </param>
/// <param name="args">
/// The args.
/// </param>
/// <returns>
/// The <see cref="IPaymentResult"/>.
/// </returns>
protected override IPaymentResult PerformAuthorizePayment(IInvoice invoice, ProcessorArgumentCollection args)
{
var paymentMethodNonce = args.GetPaymentMethodNonce();
if (string.IsNullOrEmpty(paymentMethodNonce))
{
var error = new InvalidOperationException("No payment method nonce was found in the ProcessorArgumentCollection");
LogHelper.Debug <BraintreeSimpleTransactionPaymentGatewayMethod>(error.Message);
return(new PaymentResult(Attempt <IPayment> .Fail(error), invoice, false));
}
var attempt = ProcessPayment(invoice, TransactionOption.Authorize, invoice.Total, paymentMethodNonce);
var payment = attempt.Payment.Result;
GatewayProviderService.Save(payment);
if (!attempt.Payment.Success)
{
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Denied, attempt.Payment.Exception.Message, 0);
}
else
{
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Debit, "To show record of Braintree Authorization", 0);
}
return(attempt);
}
private IPaymentResult ProcessPayment(IInvoice invoice, TransactionMode transactionMode, decimal amount, ProcessorArgumentCollection args)
{
var quickPayResponseData = args.AsQuickPayCallbackResponseModel();
var payment = GatewayProviderService.CreatePayment(PaymentMethodType.CreditCard, invoice.Total, PaymentMethod.Key);
payment.CustomerKey = invoice.CustomerKey;
payment.Authorized = false;
payment.Collected = false;
payment.PaymentMethodName = "QuickPay";
payment.ExtendedData.SetValue(Constants.ExtendedDataKeys.QuickpayPaymentId, quickPayResponseData.PaymentId);
payment.ExtendedData.SetValue(Constants.ExtendedDataKeys.PaymentAmount, quickPayResponseData.Amount);
payment.ExtendedData.SetValue(Constants.ExtendedDataKeys.PaymentCurrency, quickPayResponseData.Currency);
var result = _processor.ProcessPayment(invoice, payment, transactionMode, amount);
GatewayProviderService.Save(payment);
if (!result.Payment.Success)
{
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Denied, result.Payment.Exception.Message, 0);
}
else
{
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Debit,
(transactionMode == TransactionMode.AuthorizeAndCapture ? string.Empty : "Payment authorized and ready for capture"),
transactionMode == TransactionMode.AuthorizeAndCapture ? invoice.Total : 0);
}
return(result);
}
/// <summary>
/// Performs the capture payment operation.
/// </summary>
/// <param name="invoice">
/// The invoice.
/// </param>
/// <param name="payment">
/// The payment.
/// </param>
/// <param name="amount">
/// The amount.
/// </param>
/// <param name="args">
/// The args.
/// </param>
/// <returns>
/// The <see cref="IPaymentResult"/>.
/// </returns>
protected override IPaymentResult PerformCapturePayment(IInvoice invoice, IPayment payment, decimal amount, ProcessorArgumentCollection args)
{
// We need to determine if the entire amount authorized has been collected before marking
// the payment collected.
var appliedPayments = GatewayProviderService.GetAppliedPaymentsByPaymentKey(payment.Key);
var applied = appliedPayments.Sum(x => x.Amount);
var isPartialPayment = amount - applied <= 0;
var processor = new PayPalExpressCheckoutPaymentProcessor(_paypalApiService);
var record = processor.VerifySuccessAuthorziation(invoice, payment);
if (record.Success)
{
record = _paypalApiService.ExpressCheckout.Capture(invoice, payment, amount, isPartialPayment);
payment.SavePayPalTransactionRecord(record);
payment.Collected = (amount + applied) == payment.Amount;
payment.Authorized = true;
GatewayProviderService.Save(payment);
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Debit, "PayPal ExpressCheckout SUCCESS payment", amount);
return(new PaymentResult(Attempt <IPayment> .Succeed(payment), invoice, CalculateTotalOwed(invoice).CompareTo(amount) <= 0));
}
return(new PaymentResult(Attempt <IPayment> .Fail(payment), invoice, false));
}
/// <summary>
/// Does the actual work of creating and processing the payment
/// </summary>
/// <param name="invoice">The <see cref="IInvoice"/></param>
/// <param name="args">Any arguments required to process the payment. (Maybe a username, password or some API Key)</param>
/// <returns>The <see cref="IPaymentResult"/></returns>
protected override IPaymentResult PerformAuthorizePayment(IInvoice invoice, ProcessorArgumentCollection args)
{
var authorizeAmount = invoice.Total;
if (args.ContainsKey("authorizePaymentAmount"))
{
authorizeAmount = Convert.ToDecimal(args["authorizePaymentAmount"]);
}
var payment = GatewayProviderService.CreatePayment(PaymentMethodType.Cash, authorizeAmount, PaymentMethod.Key);
payment.CustomerKey = invoice.CustomerKey;
payment.PaymentMethodName = PaymentMethod.Name;
payment.ReferenceNumber = PaymentMethod.PaymentCode + "-" + invoice.PrefixedInvoiceNumber();
payment.Collected = false;
payment.Authorized = true;
GatewayProviderService.Save(payment);
// In this case, we want to do our own Apply Payment operation as the amount has not been collected -
// so we create an applied payment with a 0 amount. Once the payment has been "collected", another Applied Payment record will
// be created showing the full amount and the invoice status will be set to Paid.
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Debit, string.Format("To show promise of a {0} payment", PaymentMethod.Name), 0);
//// If this were using a service we might want to store some of the transaction data in the ExtendedData for record
////payment.ExtendData
return(new PaymentResult(Attempt.Succeed(payment), invoice, false));
}
/// <summary>
/// Does the actual work of creating and processing the payment
/// </summary>
/// <param name="invoice">The <see cref="IInvoice"/></param>
/// <param name="args">Any arguments required to process the payment.</param>
/// <returns>The <see cref="IPaymentResult"/></returns>
protected override IPaymentResult PerformAuthorizePayment(IInvoice invoice, ProcessorArgumentCollection args)
{
var payment = GatewayProviderService.CreatePayment(PaymentMethodType.CreditCard, invoice.Total, PaymentMethod.Key);
payment.CustomerKey = invoice.CustomerKey;
payment.PaymentMethodName = PaymentMethod.Name;
payment.ReferenceNumber = PaymentMethod.PaymentCode + "-" + invoice.PrefixedInvoiceNumber();
payment.Authorized = false;
payment.Collected = false;
//Setting the payment Amount == 0.00 to let CardConnect validate the authorization
payment.Amount = Decimal.Parse("0.00");
// Have to save here to generate the payment key
GatewayProviderService.Save(payment);
var result = ((CardConnectPaymentProcessor)_processor).InitializePayment(invoice, payment, args.AsCreditCard());
if (!result.Payment.Success)
{
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Denied, "CardConnect: request initialization error: " + result.Payment.Exception.Message, 0);
}
else
{
// Have to save here to persist the record so it can be used in later processing.
GatewayProviderService.Save(payment);
// In this case, we want to do our own Apply Payment operation as the amount has not been collected -
// so we create an applied payment with a 0 amount. Once the payment has been "collected", another Applied Payment record will
// be created showing the full amount and the invoice status will be set to Paid.
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Debit, "CardConnect Perform Authorize Payment", 0);
}
return(result);
}
protected override IPaymentResult PerformCapturePayment(IInvoice invoice, IPayment payment, decimal amount,
ProcessorArgumentCollection args)
{
var token = args["token"];
var payerId = args["PayerID"];
var result = _processor.CompletePayment(invoice, payment, token, payerId);
GatewayProviderService.Save(payment);
// TODO
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Debit, "PayPal Payment", payment.Amount);
/*
* if (!result.Payment.Success)
* {
* GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Denied,
* result.Payment.Exception.Message, 0);
* }
* else
* {
* GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Debit,
* payment.ExtendedData.GetValue(Constants.ExtendedDataKeys.CaptureTransactionResult), amount);
* }
*/
return(result);
}
/// <summary>
/// The process payment.
/// </summary>
/// <param name="invoice">
/// The invoice.
/// </param>
/// <param name="transactionMode">
/// The transaction mode.
/// </param>
/// <param name="amount">
/// The amount.
/// </param>
/// <param name="args">
/// The args.
/// </param>
/// <returns>
/// The <see cref="IPaymentResult"/>.
/// </returns>
private IPaymentResult ProcessPayment(IInvoice invoice, TransactionMode transactionMode, decimal amount, ProcessorArgumentCollection args)
{
var po = args.AsPurchaseOrderFormData();
var payment = GatewayProviderService.CreatePayment(PaymentMethodType.PurchaseOrder, invoice.Total, PaymentMethod.Key);
payment.CustomerKey = invoice.CustomerKey;
payment.Authorized = false;
payment.Collected = false;
payment.PaymentMethodName = "Purchase Order";
var result = _processor.ProcessPayment(invoice, payment, amount, po);
GatewayProviderService.Save(payment);
if (!result.Payment.Success)
{
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Denied, result.Payment.Exception.Message, 0);
}
else
{
MerchelloContext.Current.Services.InvoiceService.Save(invoice, false);
GatewayProviderService.ApplyPaymentToInvoice(
payment.Key,
invoice.Key,
AppliedPaymentType.Debit,
payment.ExtendedData.GetValue(Constants.ExtendedDataKeys.AuthorizationTransactionResult)
+ (transactionMode == TransactionMode.AuthorizeAndCapture
? string.Empty
: " to show record of Authorization"),
transactionMode == TransactionMode.AuthorizeAndCapture ? invoice.Total : 0);
}
return(result);
}
/// <summary>
/// Does the actual work of authorizing and capturing a payment
/// </summary>
/// <param name="invoice">The <see cref="IInvoice"/></param>
/// <param name="amount">The amount to capture</param>
/// <param name="args">Any arguments required to process the payment.</param>
/// <returns>The <see cref="IPaymentResult"/></returns>
protected override IPaymentResult PerformAuthorizeCapturePayment(IInvoice invoice, decimal amount, ProcessorArgumentCollection args)
{
var payment = GatewayProviderService.CreatePayment(PaymentMethodType.PurchaseOrder, amount, PaymentMethod.Key);
payment.CustomerKey = invoice.CustomerKey;
payment.PaymentMethodName = PaymentMethod.Name;
payment.ReferenceNumber = PaymentMethod.PaymentCode + "-" + invoice.PrefixedInvoiceNumber();
payment.Collected = true;
payment.Authorized = true;
var po = args.AsPurchaseOrderFormData();
if (string.IsNullOrEmpty(po.PurchaseOrderNumber))
{
return(new PaymentResult(Attempt <IPayment> .Fail(payment, new Exception("Error Purchase Order Number is empty")), invoice, false));
}
invoice.PoNumber = po.PurchaseOrderNumber;
MerchelloContext.Current.Services.InvoiceService.Save(invoice);
GatewayProviderService.Save(payment);
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Debit, "Cash payment", amount);
return(new PaymentResult(Attempt <IPayment> .Succeed(payment), invoice, CalculateTotalOwed(invoice).CompareTo(amount) <= 0));
}
/// <summary>
/// Does the actual work capturing a payment
/// </summary>
/// <param name="invoice">The <see cref="IInvoice"/></param>
/// <param name="payment">The previously Authorize payment to be captured</param>
/// <param name="amount">The amount to capture</param>
/// <param name="args">Any arguments required to process the payment.</param>
/// <returns>The <see cref="IPaymentResult"/></returns>
protected override IPaymentResult PerformCapturePayment(IInvoice invoice, IPayment payment, decimal amount, ProcessorArgumentCollection args)
{
// We need to determine if the entire amount authorized has been collected before marking
// the payment collected.
var appliedPayments = GatewayProviderService.GetAppliedPaymentsByPaymentKey(payment.Key);
var applied = appliedPayments.Sum(x => x.Amount);
var newTotalPaymentAmount = amount + applied;
// There could be an adjustment, and the capture amount could be more than the payment amount
if (newTotalPaymentAmount > payment.Amount)
{
// We are capturing more money so update payment total
payment.Amount = newTotalPaymentAmount;
}
payment.Collected = newTotalPaymentAmount == payment.Amount;
payment.Authorized = true;
GatewayProviderService.Save(payment);
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Debit, "Purchase Order Payment", amount);
return(new PaymentResult(Attempt <IPayment> .Succeed(payment), invoice, CalculateTotalOwed(invoice).CompareTo(amount) <= 0));
}
/// <summary>
/// Does the actual work of creating and processing the payment
/// </summary>
/// <param name="invoice">The <see cref="IInvoice"/></param>
/// <param name="args">Any arguments required to process the payment.</param>
/// <returns>The <see cref="IPaymentResult"/></returns>
protected override IPaymentResult PerformAuthorizePayment(IInvoice invoice, ProcessorArgumentCollection args)
{
var po = args.AsPurchaseOrderFormData();
var payment = GatewayProviderService.CreatePayment(PaymentMethodType.PurchaseOrder, invoice.Total, PaymentMethod.Key);
payment.CustomerKey = invoice.CustomerKey;
payment.PaymentMethodName = PaymentMethod.Name;
payment.ReferenceNumber = PaymentMethod.PaymentCode + "-" + invoice.PrefixedInvoiceNumber();
payment.Collected = false;
payment.Authorized = true;
if (string.IsNullOrEmpty(po.PurchaseOrderNumber))
{
return(new PaymentResult(Attempt <IPayment> .Fail(payment, new Exception("Error Purchase Order Number is empty")), invoice, false));
}
invoice.PoNumber = po.PurchaseOrderNumber;
MerchelloContext.Current.Services.InvoiceService.Save(invoice);
GatewayProviderService.Save(payment);
// In this case, we want to do our own Apply Payment operation as the amount has not been collected -
// so we create an applied payment with a 0 amount. Once the payment has been "collected", another Applied Payment record will
// be created showing the full amount and the invoice status will be set to Paid.
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Debit, string.Format("To show promise of a {0} payment", PaymentMethod.Name), 0);
//// If this were using a service we might want to store some of the transaction data in the ExtendedData for record
////payment.ExtendData
return(new PaymentResult(Attempt.Succeed(payment), invoice, false));
}
/// <summary>
/// Does the actual work of voiding a payment
/// </summary>
/// <param name="invoice">The invoice to which the payment is associated</param>
/// <param name="payment">The payment to be voided</param>
/// <param name="args">Additional arguements required by the payment processor</param>
/// <returns>A <see cref="IPaymentResult"/></returns>
protected override IPaymentResult PerformVoidPayment(IInvoice invoice, IPayment payment, ProcessorArgumentCollection args)
{
var result = _processor.VoidPayment(invoice, payment);
if (!result.Payment.Success)
{
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Denied,
result.Payment.Exception.Message, 0);
return(result);
}
// use the overloaded AppliedPayments method here for testing if we don't have
// a MerchelloContext
foreach (var applied in payment.AppliedPayments(GatewayProviderService))
{
applied.TransactionType = AppliedPaymentType.Refund;
applied.Amount = 0;
applied.Description += " - **Void**";
GatewayProviderService.Save(applied);
}
payment.Voided = true;
GatewayProviderService.Save(payment);
return(new PaymentResult(Attempt <IPayment> .Succeed(payment), invoice, false));
}
/// <summary>
/// Performs the actual work of performing the refund.
/// </summary>
/// <param name="invoice">
/// The invoice.
/// </param>
/// <param name="payment">
/// The payment.
/// </param>
/// <param name="amount">
/// The amount.
/// </param>
/// <param name="args">
/// The args.
/// </param>
/// <returns>
/// The <see cref="IPaymentResult"/>.
/// </returns>
protected override IPaymentResult PerformRefundPayment(IInvoice invoice, IPayment payment, decimal amount, ProcessorArgumentCollection args)
{
var transaction = payment.ExtendedData.GetBraintreeTransaction();
if (transaction == null)
{
var error = new NullReferenceException("Braintree transaction could not be found and/or deserialized from payment extended data collection");
return(new PaymentResult(Attempt <IPayment> .Fail(payment, error), invoice, false));
}
var attempt = BraintreeApiService.Transaction.Refund(transaction.Id, amount);
if (!attempt.IsSuccess())
{
var error = new BraintreeApiException(attempt.Errors, attempt.Message);
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Refund, error.Message, 0);
return(new PaymentResult(Attempt <IPayment> .Fail(payment, error), invoice, false));
}
payment.Amount = payment.Amount - amount;
if (payment.Amount != 0)
{
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Debit, "To show partial payment remaining after refund", payment.Amount);
}
GatewayProviderService.Save(payment);
return(new PaymentResult(Attempt <IPayment> .Succeed(payment), invoice, false));
}
protected override IPaymentResult PerformCapturePayment(IInvoice invoice, IPayment payment, decimal amount, ProcessorArgumentCollection args)
{
var payedTotalList = invoice.AppliedPayments().Select(item => item.Amount).ToList();
var payedTotal = (payedTotalList.Count == 0 ? 0 : payedTotalList.Aggregate((a, b) => a + b));
var isPartialPayment = amount + payedTotal < invoice.Total;
var result = _processor.CapturePayment(invoice, payment, amount, isPartialPayment);
//GatewayProviderService.Save(payment);
if (!result.Payment.Success)
{
//payment.VoidPayment(invoice, payment.PaymentMethodKey.Value);
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Denied, "PayPal: request capture error: " + result.Payment.Exception.Message, 0);
}
else
{
GatewayProviderService.Save(payment);
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Debit, "PayPal: captured", amount);
//GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Debit, payment.ExtendedData.GetValue(Constants.ExtendedDataKeys.CaptureTransactionResult), amount);
}
return(result);
}
private IPaymentResult InitializePayment(IInvoice invoice, ProcessorArgumentCollection args, decimal captureAmount)
{
var payment = GatewayProviderService.CreatePayment(PaymentMethodType.CreditCard, invoice.Total, PaymentMethod.Key);
payment.CustomerKey = invoice.CustomerKey;
payment.Authorized = false;
payment.Collected = false;
payment.PaymentMethodName = "PayPal";
payment.ExtendedData.SetValue(Constants.ExtendedDataKeys.CaptureAmount, captureAmount.ToString(System.Globalization.CultureInfo.InvariantCulture));
GatewayProviderService.Save(payment);
var result = _processor.InitializePayment(invoice, payment, args);
if (!result.Payment.Success)
{
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Denied, "PayPal: request initialization error: " + result.Payment.Exception.Message, 0);
}
else
{
GatewayProviderService.Save(payment);
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Debit, "PayPal: initialized", 0);
}
return(result);
}
/// <summary>
/// The perform authorize payment.
/// </summary>
/// <param name="invoice">
/// The invoice.
/// </param>
/// <param name="args">
/// The args.
/// </param>
/// <returns>
/// The <see cref="IPaymentResult"/>.
/// </returns>
protected override IPaymentResult PerformAuthorizePayment(IInvoice invoice, ProcessorArgumentCollection args)
{
// The Provider settings
if (BraintreeApiService.BraintreeProviderSettings.DefaultTransactionOption == TransactionOption.SubmitForSettlement)
{
return(this.PerformAuthorizeCapturePayment(invoice, invoice.Total, args));
}
var paymentMethodToken = args.GetPaymentMethodToken();
if (string.IsNullOrEmpty(paymentMethodToken))
{
var error = new InvalidOperationException("No payment method token was found in the ProcessorArgumentCollection");
LogHelper.Debug <BraintreeStandardTransactionPaymentGatewayMethod>(error.Message);
return(new PaymentResult(Attempt <IPayment> .Fail(error), invoice, false));
}
var attempt = ProcessPayment(invoice, TransactionOption.Authorize, invoice.Total, paymentMethodToken);
var payment = attempt.Payment.Result;
GatewayProviderService.Save(payment);
if (!attempt.Payment.Success)
{
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Denied, attempt.Payment.Exception.Message, 0);
}
else
{
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Debit, "To show record of Braintree Authorization", 0);
}
return(attempt);
}
/// <summary>
/// Processes the Authorize and AuthorizeAndCapture transactions
/// </summary>
/// <param name="invoice">The <see cref="IInvoice"/> to be paid</param>
/// <param name="payment">The <see cref="Core.Models.IPayment"/> record</param>
/// <param name="args"></param>
/// <returns>The <see cref="Core.Gateways.Payment.IPaymentResult"/></returns>
public IPaymentResult InitializePayment(IInvoice invoice, IPayment payment, CreditCard creditCard)
{
try
{
#region New
//Credit Card Information
var models = Map(invoice, payment, creditCard);
var response = CardConnectService.AuthorizeTransaction(models);
#endregion New
if (response != null)
{
//Get the CardConnect Response
switch (response.Respstat)
{
case "A":
{
payment.Collected = false;
payment.Authorized = true;
payment.SaveCarConnectTransactionRecord(response);
GatewayProviderService service = new GatewayProviderService();
service.ApplyPaymentToInvoice(
payment.Key,
invoice.Key, Core.AppliedPaymentType.Debit,
"CardConnect: " + response.Resptext + " Authorized Amount " + string.Format("{0:C}", invoice.Total) + " for Capture... RetRef: " + response.Retref,
0
);
//If the payment was acepted, redirect the user to a thank you landing page
return(new PaymentResult(Attempt <IPayment> .Succeed(payment), invoice, true));
}
case "B":
case "C":
default:
{
payment.Collected = false;
payment.Authorized = false;
//If the payment was'nt acepted, redirect the user to a Cancel Url
return(new PaymentResult(Attempt <IPayment> .Fail(payment, new Exception("CardConnect: " + response.Resptext)), invoice, true));
}
}
}
else
{
payment.Collected = false;
payment.Authorized = false;
return(new PaymentResult(Attempt <IPayment> .Fail(payment, new Exception("CardConnect: Null Response")), invoice, true));
}
}
catch (Exception ex)
{
payment.Collected = false;
payment.Authorized = false;
return(new PaymentResult(Attempt <IPayment> .Fail(payment, ex), invoice, true));
}
}
private void AssertPaymentApplied(IPaymentResult response, IInvoice invoice)
{
// Apply the payment to the invoice if it was not done in the sub class
var payment = response.Payment.Result;
if (payment.AppliedPayments(GatewayProviderService).FirstOrDefault(x => x.InvoiceKey == invoice.Key) == null)
{
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Debit, PaymentMethod.Name, payment.Amount);
}
}
/// <summary>
/// Does the actual work of capturing a payment
/// </summary>
/// <param name="invoice">The <see cref="IInvoice"/></param>
/// <param name="payment">the <see cref="IPayment"/></param>
/// <param name="amount">The amount</param>
/// <param name="args">Any arguments required to process the payment. (Maybe a username, password or some Api Key)</param>
/// <returns>The <see cref="IPaymentResult"/></returns>
protected override IPaymentResult PerformCapturePayment(IInvoice invoice, IPayment payment, decimal amount, ProcessorArgumentCollection args)
{
payment.Collected = true;
payment.Authorized = true;
GatewayProviderService.Save(payment);
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Debit, "Cash payment", amount);
return(new PaymentResult(Attempt <IPayment> .Succeed(payment), invoice, CalculateTotalOwed(invoice).CompareTo(amount) <= 0));
}
/// <summary>
/// Performs the AuthorizePayment operation.
/// </summary>
/// <param name="invoice">
/// The invoice.
/// </param>
/// <param name="args">
/// The <see cref="ProcessorArgumentCollection"/>.
/// </param>
/// <returns>
/// The <see cref="IPaymentResult"/>.
/// </returns>
/// <remarks>
/// For the ExpressCheckout there is not technically an "Authorize" but we use this to start the checkout process and to
/// mark intent to pay before redirecting the customer to PayPal. e.g. This method is called after the customer has
/// clicked the Pay button, we then save the invoice and "Authorize" a payment setting the invoice status to Unpaid before redirecting.
/// IN this way, we have both an Invoice and a Payment (denoting the redirect). When the customer completes the purchase on PayPal sites
/// the payment will be used to perform a capture and the invoice status will be changed to Paid. In the event the customer cancels,
/// the invoice will either be voided or deleted depending on the configured setting.
/// Events are included in the controller handling the response to allow developers to override success and cancel redirect URLs.
/// </remarks>
protected override IPaymentResult PerformAuthorizePayment(IInvoice invoice, ProcessorArgumentCollection args)
{
var authorizeAmount = invoice.Total;
if (args.ContainsKey("authorizePaymentAmount"))
{
authorizeAmount = Convert.ToDecimal(args["authorizePaymentAmount"]);
}
var payment = GatewayProviderService.CreatePayment(PaymentMethodType.Redirect, authorizeAmount, PaymentMethod.Key);
payment.CustomerKey = invoice.CustomerKey;
payment.PaymentMethodName = PaymentMethod.Name;
payment.ReferenceNumber = PaymentMethod.PaymentCode + "-" + invoice.PrefixedInvoiceNumber();
payment.Collected = false;
payment.Authorized = false; // this is technically not the authorization. We'll mark this in a later step.
// Have to save here to generate the payment key
GatewayProviderService.Save(payment);
// Now we want to get things setup for the ExpressCheckout
var record = this._paypalApiService.ExpressCheckout.SetExpressCheckout(invoice, payment);
payment.SavePayPalTransactionRecord(record);
// Have to save here to persist the record so it can be used in later processing.
GatewayProviderService.Save(payment);
// In this case, we want to do our own Apply Payment operation as the amount has not been collected -
// so we create an applied payment with a 0 amount. Once the payment has been "collected", another Applied Payment record will
// be created showing the full amount and the invoice status will be set to Paid.
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Debit, string.Format("To show promise of a {0} payment via PayPal Express Checkout", PaymentMethod.Name), 0);
// if the ACK was success return a success IPaymentResult
if (record.Success)
{
return(new PaymentResult(Attempt <IPayment> .Succeed(payment), invoice, false, record.SetExpressCheckout.RedirectUrl));
}
// In the case of a failure, package up the exception so we can bubble it up.
var ex = new PayPalApiException("PayPal Checkout Express initial response ACK was not Success");
if (record.SetExpressCheckout.ErrorTypes.Any())
{
ex.ErrorTypes = record.SetExpressCheckout.ErrorTypes;
}
return(new PaymentResult(Attempt <IPayment> .Fail(payment, ex), invoice, false));
}
/// <summary>
/// Does the actual work of capturing a payment
/// </summary>
/// <param name="invoice">The <see cref="IInvoice"/></param>
/// <param name="payment">the <see cref="IPayment"/></param>
/// <param name="amount">The amount</param>
/// <param name="args">Any arguments required to process the payment. (Maybe a username, password or some API Key)</param>
/// <returns>The <see cref="IPaymentResult"/></returns>
protected override IPaymentResult PerformCapturePayment(IInvoice invoice, IPayment payment, decimal amount, ProcessorArgumentCollection args)
{
// We need to determine if the entire amount authorized has been collected before marking
// the payment collected.
var appliedPayments = GatewayProviderService.GetAppliedPaymentsByPaymentKey(payment.Key);
var applied = appliedPayments.Sum(x => x.Amount);
payment.Collected = (amount + applied) == payment.Amount;
payment.Authorized = true;
GatewayProviderService.Save(payment);
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Debit, "Cash payment", amount);
return(new PaymentResult(Attempt <IPayment> .Succeed(payment), invoice, CalculateTotalOwed(invoice).CompareTo(amount) <= 0));
}
/// <summary>
/// The perform authorize capture payment.
/// </summary>
/// <param name="invoice">
/// The invoice.
/// </param>
/// <param name="amount">
/// The amount.
/// </param>
/// <param name="args">
/// The args.
/// </param>
/// <returns>
/// The <see cref="IPaymentResult"/>.
/// </returns>
protected override IPaymentResult PerformAuthorizeCapturePayment(IInvoice invoice, decimal amount, ProcessorArgumentCollection args)
{
var payment = GatewayProviderService.CreatePayment(PaymentMethodType.Cash, amount, PaymentMethod.Key);
payment.CustomerKey = invoice.CustomerKey;
payment.PaymentMethodName = PaymentMethod.Name;
payment.ReferenceNumber = PaymentMethod.PaymentCode + "-" + invoice.PrefixedInvoiceNumber();
payment.Collected = true;
payment.Authorized = true;
GatewayProviderService.Save(payment);
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Debit, "Cash payment", amount);
return(new PaymentResult(Attempt <IPayment> .Succeed(payment), invoice, CalculateTotalOwed(invoice).CompareTo(amount) <= 0));
}
private IPaymentResult ProcessPayment(IInvoice invoice, ProcessorArgumentCollection args)
{
var payment = GatewayProviderService.CreatePayment(PaymentMethodType.Cash, invoice.Total, PaymentMethod.Key);
payment.CustomerKey = invoice.CustomerKey;
payment.Authorized = false;
payment.Collected = false;
payment.PaymentMethodName = "PayPal";
GatewayProviderService.Save(payment);
var result = _processor.ProcessPayment(invoice, payment, args);
GatewayProviderService.Save(payment);
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Debit, string.Format("To show promise of a {0} payment", PaymentMethod.Name), 0);
return(result);
}
/// <summary>
/// The perform capture payment.
/// </summary>
/// <param name="invoice">
/// The invoice.
/// </param>
/// <param name="payment">
/// The payment.
/// </param>
/// <param name="amount">
/// The amount.
/// </param>
/// <param name="args">
/// The args.
/// </param>
/// <returns>
/// The <see cref="IPaymentResult"/>.
/// </returns>
protected override IPaymentResult PerformCapturePayment(IInvoice invoice, IPayment payment, decimal amount, ProcessorArgumentCollection args)
{
payment.Collected = true;
payment.Authorized = true;
string transaction;
if (args.TryGetValue(Constants.ExtendedDataKeys.BraintreeTransaction, out transaction))
{
payment.ExtendedData.SetValue(Constants.ExtendedDataKeys.BraintreeTransaction, transaction);
}
GatewayProviderService.Save(payment);
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Debit, "Braintree subscription payment", amount);
return(new PaymentResult(Attempt <IPayment> .Succeed(payment), invoice, CalculateTotalOwed(invoice).CompareTo(amount) <= 0));
}
protected override IPaymentResult PerformCapturePayment(IInvoice invoice, IPayment payment, decimal amount, ProcessorArgumentCollection args)
{
var isPartialPayment = CalculateTotalOwed(invoice) + amount <= payment.Amount;
var result = _processor.CapturePayment(invoice, payment, amount, isPartialPayment);
GatewayProviderService.Save(payment);
if (!result.Payment.Success)
{
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Denied, result.Payment.Exception.Message, 0);
}
else
{
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Debit, "PayPal Payment", amount);
}
return(result);
}
/// <summary>
/// The perform authorize payment.
/// </summary>
/// <param name="invoice">
/// The invoice.
/// </param>
/// <param name="args">
/// The args.
/// </param>
/// <returns>
/// The <see cref="IPaymentResult"/>.
/// </returns>
protected override IPaymentResult PerformAuthorizePayment(IInvoice invoice, ProcessorArgumentCollection args)
{
var payment = GatewayProviderService.CreatePayment(PaymentMethodType.CreditCard, invoice.Total, PaymentMethod.Key);
payment.CustomerKey = invoice.CustomerKey;
payment.PaymentMethodName = PaymentMethod.Name;
payment.ReferenceNumber = PaymentMethod.PaymentCode + "-" + invoice.PrefixedInvoiceNumber();
payment.Collected = false;
payment.Authorized = true;
GatewayProviderService.Save(payment);
// In this case, we want to do our own Apply Payment operation as the amount has not been collected -
// so we create an applied payment with a 0 amount. Once the payment has been "collected", another Applied Payment record will
// be created showing the full amount and the invoice status will be set to Paid.
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Debit, string.Format("To show promise of a {0} payment", PaymentMethod.Name), 0);
return(new PaymentResult(Attempt.Succeed(payment), invoice, false));
}
/// <summary>
/// The perform authorize capture payment.
/// </summary>
/// <param name="invoice">
/// The invoice.
/// </param>
/// <param name="amount">
/// The amount.
/// </param>
/// <param name="args">
/// The args.
/// </param>
/// <returns>
/// The <see cref="IPaymentResult"/>.
/// </returns>
protected override IPaymentResult PerformAuthorizeCapturePayment(IInvoice invoice, decimal amount, ProcessorArgumentCollection args)
{
var paymentMethodToken = args.GetPaymentMethodToken();
if (string.IsNullOrEmpty(paymentMethodToken))
{
var error = new InvalidOperationException("No payment method token was found in the ProcessorArgumentCollection");
LogHelper.Debug <BraintreeStandardTransactionPaymentGatewayMethod>(error.Message);
return(new PaymentResult(Attempt <IPayment> .Fail(error), invoice, false));
}
var attempt = ProcessPayment(invoice, TransactionOption.SubmitForSettlement, invoice.Total, paymentMethodToken);
var payment = attempt.Payment.Result;
GatewayProviderService.Save(payment);
if (!attempt.Payment.Success)
{
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Denied, attempt.Payment.Exception.Message, 0);
}
else
{
var customerKey = invoice.CustomerKey.GetValueOrDefault();
var last4 = string.Empty;
if (!Guid.Empty.Equals(customerKey))
{
var customer = BraintreeApiService.Customer.GetBraintreeCustomer(customerKey);
if (customer.CreditCards.Any())
{
var cc = customer.CreditCards.FirstOrDefault(x => x.Token == paymentMethodToken);
if (cc != null)
{
last4 += " - " + cc.CardType + " " + cc.LastFour;
}
}
}
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Debit, "Braintree Vault Transaction" + last4, payment.Amount);
}
return(attempt);
}
/// <summary>
/// Does the actual work of refunding a payment
/// </summary>
/// <param name="invoice">The <see cref="IInvoice"/></param>
/// <param name="payment">The previously Authorize payment to be captured</param>
/// <param name="amount">The amount to be refunded</param>
/// <param name="args">Any arguments required to process the payment.</param>
/// <returns>The <see cref="IPaymentResult"/></returns>
protected override IPaymentResult PerformRefundPayment(IInvoice invoice, IPayment payment, decimal amount, ProcessorArgumentCollection args)
{
foreach (var applied in payment.AppliedPayments())
{
applied.TransactionType = AppliedPaymentType.Refund;
applied.Amount = 0;
applied.Description += " - Refunded";
GatewayProviderService.Save(applied);
}
payment.Amount = payment.Amount - amount;
if (payment.Amount != 0)
{
GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Debit, "To show partial payment remaining after refund", payment.Amount);
}
GatewayProviderService.Save(payment);
return(new PaymentResult(Attempt <IPayment> .Succeed(payment), invoice, false));
}
