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); }
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> /// 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> /// Processes the payment. /// </summary> /// <param name="invoice"> /// The invoice. /// </param> /// <param name="option"> /// The option. /// </param> /// <param name="amount"> /// The amount. /// </param> /// <param name="token"> /// The token. /// </param> /// <param name="email"> /// The email. /// </param> /// <returns> /// The <see cref="IPaymentResult"/>. /// </returns> protected override IPaymentResult ProcessPayment(IInvoice invoice, TransactionOption option, decimal amount, string token, string email = "") { var payment = GatewayProviderService.CreatePayment(PaymentMethodType.CreditCard, amount, PaymentMethod.Key); payment.CustomerKey = invoice.CustomerKey; payment.Authorized = false; payment.Collected = false; payment.PaymentMethodName = "Braintree Vault Transaction"; payment.ExtendedData.SetValue(Braintree.Constants.ProcessorArguments.PaymentMethodNonce, token); var result = BraintreeApiService.Transaction.VaultSale(invoice, token, option); if (result.IsSuccess()) { payment.ExtendedData.SetBraintreeTransaction(result.Target); if (option == TransactionOption.Authorize) { payment.Authorized = true; } if (option == TransactionOption.SubmitForSettlement) { payment.Authorized = true; payment.Collected = true; } return(new PaymentResult(Attempt <IPayment> .Succeed(payment), invoice, true)); } var error = new BraintreeApiException(result.Errors, result.Message); return(new PaymentResult(Attempt <IPayment> .Fail(payment, error), 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); }
/// <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 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 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)); }
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> /// 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> /// 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 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)); }
protected override IPaymentResult ProcessPayment(IInvoice invoice, TransactionOption option, decimal amount, string paymentMethodNonce) { var payment = GatewayProviderService.CreatePayment(PaymentMethodType.CreditCard, amount, PaymentMethod.Key); payment.CustomerKey = invoice.CustomerKey; payment.Authorized = false; payment.Collected = false; payment.PaymentMethodName = "Braintree Transaction"; payment.ExtendedData.SetValue(Braintree.Constants.ProcessorArguments.PaymentMethodNonce, paymentMethodNonce); var merchCustomer = invoice.Customer(); if (merchCustomer == null) { var customerError = new NullReferenceException("A customer is not associated with the invoice. Braintree vault transactions require a customer reference."); return(new PaymentResult(Attempt <IPayment> .Fail(payment, customerError), invoice, false)); } var result = BraintreeApiService.Transaction.Sale(invoice, paymentMethodNonce, merchCustomer, invoice.GetBillingAddress(), option); if (result.IsSuccess()) { payment.ExtendedData.SetBraintreeTransaction(result.Target); if (option == TransactionOption.Authorize) { payment.Authorized = true; } if (option == TransactionOption.SubmitForSettlement) { payment.Authorized = true; payment.Collected = true; } return(new PaymentResult(Attempt <IPayment> .Succeed(payment), invoice, true)); } var error = new BraintreeApiException(result.Errors, result.Message); return(new PaymentResult(Attempt <IPayment> .Fail(payment, error), invoice, false)); }
private IPaymentResult ProcessPayment(IInvoice invoice) { var payment = GatewayProviderService.CreatePayment(PaymentMethodType.CreditCard, invoice.Total, PaymentMethod.Key); payment.CustomerKey = invoice.CustomerKey; payment.Authorized = false; payment.Collected = false; payment.PaymentMethodName = "PayPal"; GatewayProviderService.Save(payment); var result = _processor.ExpressCheckout(invoice, 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, string.Format("To show promise of a {0} payment", PaymentMethod.Name), 0); } return(result); }
private IPaymentResult InitializePayment(IInvoice invoice, ProcessorArgumentCollection args) { var payment = GatewayProviderService.CreatePayment(PaymentMethodType.CreditCard, invoice.Total, PaymentMethod.Key); payment.CustomerKey = invoice.CustomerKey; payment.Authorized = false; payment.Collected = false; payment.PaymentMethodName = "SagePay"; GatewayProviderService.Save(payment); var result = ((SagePayFormPaymentProcessor)_processor).InitializePayment(invoice, payment, args); if (!result.Payment.Success) { GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Denied, "SagePay: request initialization error: " + result.Payment.Exception.Message, 0); } else { GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Debit, "SagePay: initialized", 0); } return(result); }
/// <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 + " " + PaymentMethod.PaymentCode; payment.ReferenceNumber = PaymentMethod.PaymentCode + "-" + invoice.PrefixedInvoiceNumber(); 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)); }