private PaymentProcessingResult SendFulfillRequest(IPurchaseOrder po, IOrderForm orderForm, IPayment payment)
{
try
{
var requestDoc = _requestDocumentCreation.CreateDocumentForFulfillRequest(payment, orderForm);
var responseDoc = DocumentHelpers.SendTransaction(requestDoc, _dataCashConfiguration.Config);
if (DocumentHelpers.IsSuccessful(responseDoc))
{
// Extract the response details.
// When doing capture, refund, etc... transactions, DataCase will return a new Reference Id. We need to store this to ProviderTransactionID
// instead of TransactionID, because TransactionID should be the Authorization reference Id, and ProviderTransactionID will be used when we want to refund.
payment.ProviderTransactionID = DocumentHelpers.GetResponseInfo(responseDoc, "Response.datacash_reference");
var message = string.Format("[{0}] [Capture payment-{1}] [Status: {2}] .Response: {3} at Time stamp={4}",
payment.PaymentMethodName,
DocumentHelpers.GetResponseInfo(responseDoc, "Response.merchantreference"),
DocumentHelpers.GetResponseInfo(responseDoc, "Response.status"),
DocumentHelpers.GetResponseInfo(responseDoc, "Response.reason"),
DocumentHelpers.GetResponseInfo(responseDoc, "Response.time")
);
// add a new order note about this capture
AddNoteToPurchaseOrder(po, po.CustomerId, "CAPTURE", message);
_orderRepository.Save(po);
return(PaymentProcessingResult.CreateSuccessfulResult(message));
}
return(PaymentProcessingResult.CreateUnsuccessfulResult(DocumentHelpers.GetErrorMessage(responseDoc)));
}
catch (System.Exception e)
{
return(PaymentProcessingResult.CreateUnsuccessfulResult(e.Message));
}
}
private PaymentProcessingResult SendRefundRequest(IPurchaseOrder po, IPayment payment)
{
try
{
var requestDoc = _requestDocumentCreation.CreateDocumentForRefundRequest(payment);
var responseDoc = DocumentHelpers.SendTransaction(requestDoc, _dataCashConfiguration.Config);
if (DocumentHelpers.IsSuccessful(responseDoc))
{
payment.ProviderTransactionID = DocumentHelpers.GetResponseInfo(responseDoc, "Response.datacash_reference");
var message = string.Format("[{0}] [RefundTransaction-{1}] [Status: {2}] Response: {3} at Time stamp={4}.",
payment.PaymentMethodName,
DocumentHelpers.GetResponseInfo(responseDoc, "Response.datacash_reference"),
DocumentHelpers.GetResponseInfo(responseDoc, "Response.status"),
DocumentHelpers.GetResponseInfo(responseDoc, "Response.reason"),
DocumentHelpers.GetResponseInfo(responseDoc, "Response.time")
);
// add a new order note about this refund
AddNoteToPurchaseOrder(po, po.CustomerId, "REFUND", message);
_orderRepository.Save(po);
return(PaymentProcessingResult.CreateSuccessfulResult(message));
}
return(PaymentProcessingResult.CreateUnsuccessfulResult(DocumentHelpers.GetErrorMessage(responseDoc)));
}
catch (System.Exception e)
{
return(PaymentProcessingResult.CreateUnsuccessfulResult(e.Message));
}
}
/// <summary>
/// Process payment when user checkout.
/// </summary>
/// <param name="cart">The current cart.</param>
/// <param name="payment">The payment to process.</param>
/// <returns>return false and set the message will make the WorkFlow activity raise PaymentExcetion(message)</returns>
private PaymentProcessingResult ProcessPaymentCheckout(ICart cart, IPayment payment)
{
var orderNumberId = _orderNumberGenerator.GenerateOrderNumber(cart);
if (string.IsNullOrEmpty(_paymentMethodConfiguration.ExpChkoutUrl) || string.IsNullOrEmpty(_paymentMethodConfiguration.PaymentAction))
{
return(PaymentProcessingResult.CreateUnsuccessfulResult(Utilities.Translate("PayPalSettingsError")));
}
var caller = PayPalApiHelper.GetPayPalApiCallerServices(_paymentMethodConfiguration);
var setExpressChkOutReqType = new SetExpressCheckoutRequestType(SetupExpressCheckoutReqDetailsType(cart, payment, orderNumberId));
var setChkOutResponse = caller.SetExpressCheckout(new SetExpressCheckoutReq {
SetExpressCheckoutRequest = setExpressChkOutReqType
});
var errorCheck = _payPalApiHelper.CheckErrors(setChkOutResponse);
if (!string.IsNullOrEmpty(errorCheck))
{
_logger.Error(errorCheck);
return(PaymentProcessingResult.CreateUnsuccessfulResult(string.Join("; ", setChkOutResponse.Errors.Select(e => e.LongMessage))));
}
payment.Properties[PayPalOrderNumberPropertyName] = orderNumberId;
payment.Properties[PayPalExpTokenPropertyName] = setChkOutResponse.Token;
_orderRepository.Save(cart);
// validation checking with PayPal OK (Server's PayPal API, Billing Address, Shipping Address, ... do redirect to PayPal.com
var redirectUrl = CreateRedirectUrl(_paymentMethodConfiguration.ExpChkoutUrl, setChkOutResponse.Token);
var message = $"---PayPal-SetExpressCheckout is successful. Redirect end user to {redirectUrl}";
_logger.Information(message);
return(PaymentProcessingResult.CreateSuccessfulResult(message, redirectUrl));
}
private PaymentProcessingResult ProcessPaymentCheckout(IPayment payment, ICart cart)
{
var merchRef = DateTime.Now.Ticks.ToString();
payment.Properties[DataCashMerchantReferencePropertyName] = merchRef; // A unique reference number for each transaction (Min 6, max 30 alphanumeric character)
var notifyUrl = UriSupport.AbsoluteUrlBySettings(Utilities.GetUrlFromStartPageReferenceProperty("DataCashPaymentPage"));
notifyUrl = UriUtil.AddQueryString(notifyUrl, "accept", "true");
notifyUrl = UriUtil.AddQueryString(notifyUrl, "hash", Utilities.GetSHA256Key(merchRef + "accepted"));
var requestDoc = _requestDocumentCreation.CreateDocumentForPaymentCheckout(cart, payment, notifyUrl);
var responseDoc = DocumentHelpers.SendTransaction(requestDoc, _dataCashConfiguration.Config);
string redirectUrl;
if (DocumentHelpers.IsSuccessful(responseDoc))
{
redirectUrl = $"{responseDoc.get("Response.HpsTxn.hps_url")}?HPS_SessionID={responseDoc.get("Response.HpsTxn.session_id")}";
payment.Properties[DataCashReferencePropertyName] = responseDoc.get("Response.datacash_reference");
}
else
{
return(PaymentProcessingResult.CreateUnsuccessfulResult(DocumentHelpers.GetErrorMessage(responseDoc)));
}
_orderRepository.Save(cart);
var message = $"---DataCash--. Redirect end user to {redirectUrl}";
_logger.Information(message);
return(PaymentProcessingResult.CreateSuccessfulResult(message, redirectUrl));
}
private PaymentProcessingResult ProcessPaymentCapture(IOrderGroup orderGroup,
ICreditCardPayment creditCardPayment,
IOrderAddress billingAddress)
{
if (string.IsNullOrEmpty(creditCardPayment.ProviderPaymentId))
{
return(Charge(orderGroup, creditCardPayment, billingAddress));
}
try
{
var capture = _stripeChargeService.Capture(creditCardPayment.ProviderPaymentId, new StripeChargeCaptureOptions());
if (!string.IsNullOrEmpty(capture.FailureCode))
{
return(PaymentProcessingResult.CreateUnsuccessfulResult(Translate(capture.Outcome.Reason)));
}
creditCardPayment.ProviderPaymentId = capture.Id;
creditCardPayment.ProviderTransactionID = capture.BalanceTransactionId;
return(PaymentProcessingResult.CreateSuccessfulResult(""));
}
catch (StripeException e)
{
switch (e.StripeError.ErrorType)
{
case "card_error":
return(PaymentProcessingResult.CreateUnsuccessfulResult(Translate(e.StripeError.Code)));
default:
return(PaymentProcessingResult.CreateUnsuccessfulResult(e.StripeError.Message));
}
}
}
/// <summary>
/// Processes the payment. Can be used for both positive and negative transactions.
/// </summary>
/// <param name="orderGroup">The order group.</param>
/// <param name="payment">The payment.</param>
/// <returns>The payment processing result.</returns>
public PaymentProcessingResult ProcessPayment(IOrderGroup orderGroup, IPayment payment)
{
var creditCardPayment = (ICreditCardPayment)payment;
return(creditCardPayment.CreditCardNumber.EndsWith("4")
? PaymentProcessingResult.CreateSuccessfulResult(string.Empty)
: PaymentProcessingResult.CreateUnsuccessfulResult("Invalid credit card number."));
}
public PaymentProcessingResult ProcessPayment(IOrderGroup orderGroup, IPayment payment)
{
OrderGroup = orderGroup;
_orderForm = orderGroup.GetFirstForm();
var message = string.Empty;
return(ProcessPayment(payment, ref message)
? PaymentProcessingResult.CreateSuccessfulResult(message)
: PaymentProcessingResult.CreateUnsuccessfulResult(message));
}
/// <summary>Process payment associated with shipment.</summary>
/// <param name="orderGroup">The order group.</param>
/// <param name="payment">The payment.</param>
/// <param name="shipment">The shipment.</param>
/// <returns><c>True</c> if process successful, otherwise <c>False</c>.</returns>
public PaymentProcessingResult ProcessPayment(IOrderGroup orderGroup, IPayment payment, IShipment shipment)
{
OrderGroup = orderGroup;
_orderForm = orderGroup.GetFirstForm();
var result = ProcessPayment(payment, shipment);
var message = result.Message;
return(result.Status
? PaymentProcessingResult.CreateSuccessfulResult(message)
: PaymentProcessingResult.CreateUnsuccessfulResult(message));
}
public PaymentProcessingResult ProcessPayment(IOrderGroup orderGroup, IPayment payment)
{
if (orderGroup == null)
{
return(PaymentProcessingResult.CreateUnsuccessfulResult("Failed to process your payment."));
}
else
{
GiftCardManager.PurchaseByGiftCard(payment);
return(PaymentProcessingResult.CreateSuccessfulResult("Gift card processed"));
}
}
/// <summary>
/// Captures an authorized payment.
/// </summary>
/// <para>
/// See API doc here https://developer.paypal.com/webapps/developer/docs/classic/api/merchant/DoCapture_API_Operation_SOAP/
/// </para>
/// <param name="orderGroup">The order group to process.</param>
/// <param name="payment">The payment to process</param>
/// <returns>return false and set the message will make the WorkFlow activity raise PaymentExcetion(message)</returns>
private PaymentProcessingResult ProcessPaymentCapture(IOrderGroup orderGroup, IPayment payment)
{
// Implement refund feature logic for current payment gateway
var captureAmount = payment.Amount;
var purchaseOrder = orderGroup as IPurchaseOrder;
if (purchaseOrder == null || captureAmount <= 0)
{
return(PaymentProcessingResult.CreateUnsuccessfulResult("Nothing to capture"));
}
var captureRequest = new DoCaptureRequestType
{
AuthorizationID = payment.TransactionID, // original transactionID (which PayPal gave us when DoExpressCheckoutPayment, DoDirectPayment, or CheckOut)
Amount = _payPalAPIHelper.ToPayPalAmount(captureAmount, orderGroup.Currency), // if refund with Partial, we have to set the Amount
CompleteType = payment.Amount >= purchaseOrder.GetTotal().Amount ? CompleteCodeType.COMPLETE : CompleteCodeType.NOTCOMPLETE,
InvoiceID = purchaseOrder.OrderNumber
};
captureRequest.Note = $"[{payment.PaymentMethodName}-{payment.TransactionID}] captured {captureAmount}{captureRequest.Amount.currencyID} for [PurchaseOrder-{purchaseOrder.OrderNumber}]";
var caller = PayPalAPIHelper.GetPayPalAPICallerServices(_paymentMethodConfiguration);
var doCaptureReq = new DoCaptureReq {
DoCaptureRequest = captureRequest
};
var captureResponse = caller.DoCapture(doCaptureReq);
var errorCheck = _payPalAPIHelper.CheckErrors(captureResponse);
if (!string.IsNullOrEmpty(errorCheck))
{
_logger.Error(errorCheck);
return(PaymentProcessingResult.CreateUnsuccessfulResult(PaymentTransactionFailedMessage));
}
var captureResponseDetails = captureResponse.DoCaptureResponseDetails;
var paymentInfo = captureResponseDetails.PaymentInfo;
// Extract the response details.
payment.ProviderTransactionID = paymentInfo.TransactionID;
payment.Status = paymentInfo.PaymentStatus.ToString();
var message = $"[{payment.PaymentMethodName}] [Capture payment-{paymentInfo.TransactionID}] [Status: {paymentInfo.PaymentStatus.ToString()}] " +
$".Response: {captureResponse.Ack.ToString()} at Timestamp={captureResponse.Timestamp.ToString()}: {paymentInfo.GrossAmount.value}{paymentInfo.GrossAmount.currencyID}";
// add a new order note about this capture
AddNoteToPurchaseOrder("CAPTURE", message, purchaseOrder.CustomerId, purchaseOrder);
_orderRepository.Save(purchaseOrder);
return(PaymentProcessingResult.CreateSuccessfulResult(message));
}
public PaymentProcessingResult ProcessPayment(IOrderGroup orderGroup, IPayment payment)
{
if (orderGroup == null)
{
return(PaymentProcessingResult.CreateUnsuccessfulResult("Failed to process your payment."));
}
var currentOrder = orderGroup;
var customer = _customerService.Service.GetContactViewModelById(currentOrder.CustomerId.ToString());
if (customer == null)
{
return(PaymentProcessingResult.CreateUnsuccessfulResult("Failed to process your payment."));
}
var isQuoteOrder = currentOrder.Properties[Constant.Quote.ParentOrderGroupId] != null &&
Convert.ToInt32(currentOrder.Properties[Constant.Quote.ParentOrderGroupId]) != 0;
if (isQuoteOrder && customer.Role != B2BUserRoles.Approver)
{
return(PaymentProcessingResult.CreateUnsuccessfulResult("Failed to process your payment."));
}
var purchaserCustomer = !isQuoteOrder ? customer : _ordersService.Service.GetPurchaserCustomer(currentOrder);
if (AreBudgetsOnHold(purchaserCustomer))
{
return(PaymentProcessingResult.CreateUnsuccessfulResult("Budget on hold."));
}
if (customer.Role == B2BUserRoles.Purchaser)
{
var budget =
_budgetService.Service.GetCustomerCurrentBudget(purchaserCustomer.Organization.OrganizationId,
purchaserCustomer.ContactId);
if (budget == null || budget.RemainingBudget < payment.Amount)
{
return(PaymentProcessingResult.CreateUnsuccessfulResult("Insufficient budget."));
}
}
if (payment.TransactionType == TransactionType.Capture.ToString())
{
UpdateUserBudgets(purchaserCustomer, payment.Amount);
payment.Status = PaymentStatus.Processed.ToString();
_orderRepository.Service.Save(currentOrder);
}
return(PaymentProcessingResult.CreateSuccessfulResult(""));
}
/// <summary>
/// Processes the payment.
/// </summary>
/// <param name="orderGroup">The order group.</param>
/// <param name="payment">The payment.</param>
public PaymentProcessingResult ProcessPayment(IOrderGroup orderGroup, IPayment payment)
{
if (HttpContext.Current == null)
{
return(PaymentProcessingResult.CreateSuccessfulResult(Utilities.Translate("ProcessPaymentNullHttpContext")));
}
if (payment == null)
{
return(PaymentProcessingResult.CreateUnsuccessfulResult(Utilities.Translate("PaymentNotSpecified")));
}
var orderForm = orderGroup.Forms.FirstOrDefault(f => f.Payments.Contains(payment));
if (orderForm == null)
{
return(PaymentProcessingResult.CreateUnsuccessfulResult(Utilities.Translate("PaymentNotAssociatedOrderForm")));
}
var purchaseOrder = orderGroup as IPurchaseOrder;
if (purchaseOrder != null)
{
// When a refund is created by return process,
// this method will be called again with the TransactionType is Credit
if (payment.TransactionType.Equals(TransactionType.Credit.ToString(), StringComparison.OrdinalIgnoreCase))
{
// process refund
// Using Transaction id as DataCash Reference to handle upgrade case. Assume that before upgrading to this version, our system has some authorized transactions that need to be captured.
// After upgrading, using Provider Transaction id instead.
return(SendRefundRequest(purchaseOrder, payment));
}
// active invoice when order is complete
// when user click complete order in commerce manager the transaction type will be Capture
if (payment.TransactionType.Equals(TransactionType.Capture.ToString(), StringComparison.OrdinalIgnoreCase))
{
var result = SendFulfillRequest(purchaseOrder, orderForm, payment);
var message = result.Message;
if (!result.IsSuccessful && !string.IsNullOrEmpty(result.Message))
{
_logger.Error(message);
message = $"{Utilities.Translate("GenericError")}:{message}";
}
return(result);
}
}
return(ProcessPaymentCheckout(payment, (ICart)orderGroup));
}
public virtual PaymentProcessingResult Refund(
IOrderGroup orderGroup,
IPayment payment)
{
var configuration = _configurationLoader.GetConfiguration(orderGroup.MarketId);
try
{
var orderId = payment.TransactionID;
var serviceApi = _vippsServiceApiFactory.Create(configuration);
var refundPaymentRequest =
_requestFactory.CreateUpdatePaymentRequest(payment, configuration);
var response = AsyncHelper.RunSync(() => serviceApi.Refund(orderId, refundPaymentRequest));
var creditTotal = orderGroup.GetFirstForm().Payments.Where(x => x.TransactionType == "Credit")
.Sum(x => x.Amount).FormatAmountToVipps();
if (response.TransactionSummary.RefundedAmount == creditTotal)
{
OrderNoteHelper.AddNoteAndSaveChanges(orderGroup, payment, payment.TransactionType,
$"{payment.Amount} kr refunded on vipps order {orderId}");
return(PaymentProcessingResult.CreateSuccessfulResult(
$"{payment.Amount} kr captured on refunded order {orderId}"));
}
OrderNoteHelper.AddNoteAndSaveChanges(orderGroup, payment, payment.TransactionType,
$"Vipps refund payment failed. Order status: {response.TransactionInfo.Status}");
return(PaymentProcessingResult.CreateUnsuccessfulResult(
$"Vipps refund payment failed. Order status: {response.TransactionInfo.Status}"));
}
catch (ApiException apiException)
{
var errorMessage = GetErrorMessage(apiException);
_logger.Log(Level.Error, $"Vipps Refund failed: {errorMessage}");
OrderNoteHelper.AddNoteAndSaveChanges(orderGroup, payment, payment.TransactionType,
$"Vipps refund payment failed. Error message: {errorMessage}, {apiException}");
return(PaymentProcessingResult.CreateUnsuccessfulResult(errorMessage));
}
catch (Exception ex)
{
_logger.Log(Level.Error, $"{ex.Message}, {ex.StackTrace}");
OrderNoteHelper.AddNoteAndSaveChanges(orderGroup, payment, payment.TransactionType,
$"Vipps refund payment failed. Error message: {ex.Message}");
return(PaymentProcessingResult.CreateUnsuccessfulResult(ex.Message));
}
}
public PaymentProcessingResult ProcessPayment(IOrderGroup orderGroup, IPayment payment)
{
payment.TransactionType = TransactionType.Sale.ToString();
var result = GiftCardService.DebitGiftCard(Settings["GiftCardMetaClassName"], (PrimaryKeyId)orderGroup.CustomerId, payment.ValidationCode, payment.Amount);
if (result)
{
return(PaymentProcessingResult.CreateSuccessfulResult($"Gift Card Applied for {payment.Amount}!"));
}
else
{
return(PaymentProcessingResult.CreateUnsuccessfulResult("Gift Card Declined!"));
}
}
public PaymentProcessingResult ProcessPayment(IOrderGroup orderGroup, IPayment payment)
{
var creditLimit = 500;
payment.TransactionType = TransactionType.Sale.ToString();
if (payment.Amount <= creditLimit)
{
return(PaymentProcessingResult.CreateSuccessfulResult($"godkendt betaling for {payment.Amount}, key {Settings["SecretKeyExample"]}"));
}
else
{
return(PaymentProcessingResult.CreateUnsuccessfulResult($"beklager du er over limit!!!!"));
}
}
public PaymentProcessingResult ProcessPayment(IOrderGroup orderGroup, IPayment payment)
{
decimal CreditLimit = 500;
string secretKey = Settings["SecretKeyExample"];
payment.TransactionType = TransactionType.Sale.ToString();
if (payment.Amount <= CreditLimit)
{
return(PaymentProcessingResult.CreateSuccessfulResult($"Acme credit approved payment for {payment.Amount}! Secret Code: {secretKey}"));
}
else
{
return(PaymentProcessingResult.CreateUnsuccessfulResult($"Sorry, you are over your limit! Secret Code: {secretKey}"));
}
}
public virtual async Task <PaymentProcessingResult> InitiateAsync(IOrderGroup orderGroup, IPayment payment)
{
var orderId = OrderNumberHelper.GenerateOrderNumber();
orderGroup.Properties[VippsConstants.VippsOrderIdField] = orderId;
payment.TransactionID = orderId;
_orderRepository.Save(orderGroup);
var configuration = _configurationLoader.GetConfiguration(orderGroup.MarketId);
var serviceApi = _vippsServiceApiFactory.Create(configuration);
try
{
var initiatePaymentRequest =
_requestFactory.CreateInitiatePaymentRequest(payment, orderGroup, configuration, orderId, orderGroup.CustomerId, orderGroup.MarketId.Value);
var response = await serviceApi.Initiate(initiatePaymentRequest).ConfigureAwait(false);
OrderNoteHelper.AddNoteAndSaveChanges(orderGroup, payment, payment.TransactionType,
$"Vipps payment initiated. Vipps reference: {initiatePaymentRequest.Transaction.OrderId}");
_vippsPollingService.Start(new VippsPollingEntity
{
OrderId = orderId,
CartName = orderGroup.Name,
ContactId = orderGroup.CustomerId,
MarketId = orderGroup.MarketId.Value
});
return(PaymentProcessingResult.CreateSuccessfulResult("", response.Url));
}
catch (ApiException apiException)
{
var errorMessage = GetErrorMessage(apiException);
_logger.Log(Level.Error, $"Vipps initiate failed: {errorMessage}");
OrderNoteHelper.AddNoteAndSaveChanges(orderGroup, payment, payment.TransactionType, $"Vipps payment initiation failed. Error message: {errorMessage}, {apiException}");
return(PaymentProcessingResult.CreateUnsuccessfulResult(errorMessage));
}
catch (Exception ex)
{
_logger.Log(Level.Error, $"{ex.Message}, {ex.StackTrace}");
OrderNoteHelper.AddNoteAndSaveChanges(orderGroup, payment, payment.TransactionType, $"Vipps payment initiation failed. Error message: {ex.Message}");
return(PaymentProcessingResult.CreateUnsuccessfulResult(ex.Message));
}
}
public virtual PaymentProcessingResult Capture(
IOrderGroup orderGroup,
IPayment payment)
{
var configuration = _configurationLoader.GetConfiguration(orderGroup.MarketId);
try
{
var orderId = payment.TransactionID;
var idempotencyKey = GetIdempotencyKey(orderGroup, payment, orderId);
var serviceApi = _vippsServiceApiFactory.Create(configuration);
var capturePaymentRequest =
_requestFactory.CreateUpdatePaymentRequest(payment, configuration);
var response = AsyncHelper.RunSync(() => serviceApi.Capture(orderId, capturePaymentRequest, idempotencyKey));
if (response.TransactionInfo.Status == VippsUpdatePaymentResponseStatus.Captured.ToString())
{
OrderNoteHelper.AddNoteAndSaveChanges(orderGroup, payment, payment.TransactionType,
$"{payment.Amount} kr captured on vipps order {orderId}");
return(PaymentProcessingResult.CreateSuccessfulResult(
$"{payment.Amount} kr captured on vipps order {orderId}"));
}
OrderNoteHelper.AddNoteAndSaveChanges(orderGroup, payment, payment.TransactionType,
$"Vipps capture payment failed. Order status: {response.TransactionInfo.Status}");
return(PaymentProcessingResult.CreateUnsuccessfulResult(
$"Vipps capture payment failed. Order status: {response.TransactionInfo.Status}"));
}
catch (ApiException apiException)
{
var errorMessage = GetErrorMessage(apiException);
_logger.Log(Level.Error, $"Vipps Capture failed: {errorMessage}");
OrderNoteHelper.AddNoteAndSaveChanges(orderGroup, payment, payment.TransactionType,
$"Vipps capture payment failed. Error message: {errorMessage}, {apiException}");
return(PaymentProcessingResult.CreateUnsuccessfulResult(errorMessage));
}
catch (Exception ex)
{
_logger.Log(Level.Error, $"{ex.Message}, {ex.StackTrace}");
OrderNoteHelper.AddNoteAndSaveChanges(orderGroup, payment, payment.TransactionType,
$"Vipps capture payment failed. Error message: {ex.Message}");
return(PaymentProcessingResult.CreateUnsuccessfulResult(ex.Message));
}
}
/// <summary>
/// Process payment when a refund request happens.
/// </summary>
/// <remarks>
/// <para>
/// See API doc here https://www.x.com/developers/paypal/documentation-tools/api/refundtransaction-api-operation-soap
/// </para>
/// <para>
/// You may offer a refund only for a limited time, usually 60 days. If you need to make a refund after that time, you will need to initiate a new PayPal payment to your buyer.
/// If you offer the buyer a partial refund, she has 10 days to decline it if she wishes. (Full refunds are automatically processed.)
/// </para>
/// </remarks>
/// <param name="payment">The payment to process.</param>
/// <param name="orderGroup">The order group to process.</param>
/// <returns>True if refund was completed, otherwise false and set the message will make the WorkFlow activity raise PaymentExcetion(message).</returns>
private PaymentProcessingResult ProcessPaymentRefund(IOrderGroup orderGroup, IPayment payment)
{
// Implement refund feature logic for current payment gateway
var refundAmount = payment.Amount;
var purchaseOrder = (orderGroup as IPurchaseOrder);
if (purchaseOrder == null || refundAmount <= 0)
{
return(PaymentProcessingResult.CreateUnsuccessfulResult(Utilities.Translate("PayPalRefundError")));
}
// Call payment gateway API to do refund business
// Create the Refund Request
var refundRequest = new RefundTransactionRequestType
{
TransactionID = payment.ProviderTransactionID, // original transactionID (which payPal gave us when do ExpressCheckout)
Memo = $"[{payment.PaymentMethodName}-{payment.TransactionID}] refunds {refundAmount}{purchaseOrder.Currency} for [PurchaseOrder-{purchaseOrder.OrderNumber}]",
// NOTE: If RefundType is Full, do not set the amount.
// refundRequest.RefundType = RefundType.Full; //refund a full or partial amount
RefundType = RefundType.PARTIAL, //refund a partial amount
Amount = _payPalAPIHelper.ToPayPalAmount(refundAmount, orderGroup.Currency) // if refund with Partial, we have to set the Amount
};
var caller = PayPalAPIHelper.GetPayPalAPICallerServices(_paymentMethodConfiguration);
var refundResponse = caller.RefundTransaction(new RefundTransactionReq {
RefundTransactionRequest = refundRequest
});
var errorCheck = _payPalAPIHelper.CheckErrors(refundResponse);
if (!string.IsNullOrEmpty(errorCheck))
{
_logger.Error(errorCheck);
return(PaymentProcessingResult.CreateUnsuccessfulResult(PaymentTransactionFailedMessage));
}
// Extract the response details.
payment.TransactionID = refundResponse.RefundTransactionID;
var message = $"[{payment.PaymentMethodName}] [RefundTransaction-{refundResponse.RefundTransactionID}] " +
$"Response: {refundResponse.Ack.ToString()} at Timestamp={refundResponse.Timestamp.ToString()}: {refundResponse.GrossRefundAmount.value}{refundResponse.GrossRefundAmount.currencyID}";
// add a new order note about this refund
AddNoteToPurchaseOrder("REFUND", message, purchaseOrder.CustomerId, purchaseOrder);
_orderRepository.Save(purchaseOrder);
return(PaymentProcessingResult.CreateSuccessfulResult(message));
}
public PaymentProcessingResult ProcessPayment(IOrderGroup orderGroup, IPayment payment)
{
if (!(payment is ICreditCardPayment creditCardPayment))
{
return(PaymentProcessingResult.CreateUnsuccessfulResult(Translate("PaymentNotSpecified")));
}
var billingAddress = creditCardPayment.BillingAddress;
if (billingAddress == null)
{
return(PaymentProcessingResult.CreateUnsuccessfulResult(Translate("PaymentNotSpecified")));
}
if (string.IsNullOrEmpty(billingAddress.Email))
{
return(PaymentProcessingResult.CreateUnsuccessfulResult(Translate("PaymentNotSpecified")));
}
if (_orderTaxTotal == 0)
{
_orderTaxTotal = _taxCalculator.Service.GetTaxTotal(orderGroup, orderGroup.Market, orderGroup.Currency).Amount;
}
if (orderGroup is ICart cart)
{
return(Charge(cart, creditCardPayment, billingAddress));
}
// the order which is created by Commerce Manager
if (!(orderGroup is IPurchaseOrder))
{
return(PaymentProcessingResult.CreateUnsuccessfulResult(Translate("UnsupportedPaymentType") + $". {orderGroup.GetType().AssemblyQualifiedName}"));
}
if (payment.TransactionType == TransactionType.Capture.ToString())
{
return(ProcessPaymentCapture(orderGroup, creditCardPayment, billingAddress));
}
// When "Refund" shipment in Commerce Manager, this method will be invoked with the TransactionType is Credit
return(payment.TransactionType == TransactionType.Credit.ToString() ?
ProcessPaymentRefund(orderGroup, creditCardPayment) :
PaymentProcessingResult.CreateUnsuccessfulResult(Translate("UnsupportedPaymentType") + $". {orderGroup.GetType().AssemblyQualifiedName}"));
}
private PaymentProcessingResult ProcessPaymentRefund(IOrderGroup orderGroup, ICreditCardPayment creditCardPayment)
{
var refundAmount = creditCardPayment.Amount;
var purchaseOrder = (IPurchaseOrder)orderGroup;
if (purchaseOrder == null || refundAmount <= 0 || string.IsNullOrEmpty(creditCardPayment.ProviderPaymentId))
{
return(PaymentProcessingResult.CreateUnsuccessfulResult(Translate("RefundError")));
}
try
{
var refundOptions = new StripeRefundCreateOptions()
{
Amount = (int)refundAmount * GetMultiplier(orderGroup.Currency),
Reason = StripeRefundReasons.RequestedByCustomer
};
var refund = _stripeRefundService.Create(creditCardPayment.ProviderPaymentId, refundOptions);
// Extract the response details.
creditCardPayment.TransactionID = refund.Id;
var message = $"[{creditCardPayment.PaymentMethodName}] [RefundTransaction-{refund.Id}] " +
$"Response: {refund.Status} at Timestamp={refund.Created.ToString()}: {refund.Amount}{refund.Currency}";
// add a new order note about this refund
AddNoteToPurchaseOrder("REFUND", message, purchaseOrder.CustomerId, purchaseOrder);
_orderRepository.Service.Save(purchaseOrder);
return(PaymentProcessingResult.CreateSuccessfulResult(message));
}
catch (StripeException e)
{
switch (e.StripeError.ErrorType)
{
case "card_error":
return(PaymentProcessingResult.CreateUnsuccessfulResult(Translate(e.StripeError.Code)));
default:
return(PaymentProcessingResult.CreateUnsuccessfulResult(e.StripeError.Message));
}
}
}
/// <summary>
/// Processes the payment.
/// </summary>
/// <param name="orderGroup">The order group.</param>
/// <param name="payment">The payment.</param>
public PaymentProcessingResult ProcessPayment(IOrderGroup orderGroup, IPayment payment)
{
if (HttpContext.Current == null)
{
return(PaymentProcessingResult.CreateSuccessfulResult("ProcessPaymentNullHttpContext"));
}
if (payment == null)
{
return(PaymentProcessingResult.CreateUnsuccessfulResult("PaymentNotSpecified"));
}
var orderForm = orderGroup.Forms.FirstOrDefault(f => f.Payments.Contains(payment));
if (orderForm == null)
{
return(PaymentProcessingResult.CreateUnsuccessfulResult("PaymentNotAssociatedOrderForm"));
}
_paymentMethodConfiguration = new PayooConfiguration(Settings);
var payooOrder = CreatePayooOrder(orderGroup, payment);
var checksum = CreatePayooChecksum(payooOrder);
//Call Payoo gateway here
var message = string.Empty;
var response = ExecuteCreatePayooPreOrderRequest(payooOrder, checksum, out message);
if (response == null || !response.IsSuccess)
{
return(PaymentProcessingResult.CreateUnsuccessfulResult(message));
}
UpdatePaymentPropertiesFromPayooResponse(orderGroup, payment, response);
var redirectUrl = response.order.payment_url;
message = $"---Payoo CreatePreOrder is successful. Redirect end user to {redirectUrl}";
return(PaymentProcessingResult.CreateSuccessfulResult(message, redirectUrl));
}
public virtual PaymentProcessingResult ProcessPayment(IOrderGroup orderGroup, IPayment payment)
{
PaymentStepResult stepResult;
try
{
Logger.Debug("Netaxept checkout gateway. Processing Payment ....");
if (_orderForm == null)
{
_orderForm = orderGroup.Forms.FirstOrDefault(form => form.Payments.Contains(payment));
}
var registerPaymentStep = new RegisterPaymentStep(payment);
var capturePaymentStep = new CapturePaymentStep(payment);
var creditPaymentStep = new CreditPaymentStep(payment);
var annulPaymentStep = new AnnulPaymentStep(payment);
registerPaymentStep.SetSuccessor(capturePaymentStep);
capturePaymentStep.SetSuccessor(creditPaymentStep);
creditPaymentStep.SetSuccessor(annulPaymentStep);
stepResult = registerPaymentStep.Process(payment, _orderForm, orderGroup);
}
catch (Exception exception)
{
Logger.Error("Process payment failed with error: " + exception.Message, exception);
stepResult = new PaymentStepResult {
IsSuccessful = false, Message = exception.Message
};
}
if (stepResult.IsSuccessful)
{
return(PaymentProcessingResult.CreateSuccessfulResult(stepResult.Message, stepResult.RedirectUrl));
}
return(PaymentProcessingResult.CreateUnsuccessfulResult(stepResult.Message));
}
public virtual async Task <PaymentProcessingResult> CancelAsync(IOrderGroup orderGroup, IPayment payment)
{
var configuration = _configurationLoader.GetConfiguration(orderGroup.MarketId);
try
{
var orderId = payment.TransactionID;
var serviceApi = _vippsServiceApiFactory.Create(configuration);
var cancelPaymentRequest =
_requestFactory.CreateUpdatePaymentRequest(payment, configuration);
var response = await serviceApi.Cancel(orderId, cancelPaymentRequest).ConfigureAwait(false);
if (response.TransactionInfo.Status == VippsUpdatePaymentResponseStatus.Cancelled.ToString())
{
OrderNoteHelper.AddNoteAndSaveChanges(orderGroup, payment, payment.TransactionType, $"Payment cancelled for vipps order {orderId}");
return(PaymentProcessingResult.CreateSuccessfulResult($"{payment.Amount} Payment cancelled vipps order {orderId}"));
}
OrderNoteHelper.AddNoteAndSaveChanges(orderGroup, payment, payment.TransactionType, $"Vipps cancel payment failed. Order status: {response.TransactionInfo.Status}");
return(PaymentProcessingResult.CreateUnsuccessfulResult($"Vipps cancel payment failed. Order status: {response.TransactionInfo.Status}"));
}
catch (ApiException apiException)
{
var errorMessage = GetErrorMessage(apiException);
_logger.Log(Level.Error, $"Vipps cancel failed: {errorMessage}");
OrderNoteHelper.AddNoteAndSaveChanges(orderGroup, payment, payment.TransactionType, $"Vipps cancel payment failed. Error message: {errorMessage}, {apiException}");
return(PaymentProcessingResult.CreateUnsuccessfulResult(errorMessage));
}
catch (Exception ex)
{
_logger.Log(Level.Error, $"{ex.Message}, {ex.StackTrace}");
OrderNoteHelper.AddNoteAndSaveChanges(orderGroup, payment, payment.TransactionType, $"Vipps cancel payment failed. Error message: {ex.Message}");
return(PaymentProcessingResult.CreateUnsuccessfulResult(ex.Message));
}
}
private PaymentProcessingResult PreAuthenticateRequest(IOrderGroup orderGroup, IOrderForm orderForm, IPayment payment, out string authenticateCode)
{
authenticateCode = string.Empty;
try
{
var requestDoc = _requestDocumentCreation.CreateDocumentForPreAuthenticateRequest(payment, orderForm, orderGroup.Currency);
var responseDoc = DocumentHelpers.SendTransaction(requestDoc, _dataCashConfiguration.Config);
if (DocumentHelpers.IsSuccessful(responseDoc))
{
authenticateCode = responseDoc.get("Response.CardTxn.authcode");
return(string.IsNullOrEmpty(authenticateCode) ?
PaymentProcessingResult.CreateUnsuccessfulResult(string.Empty) :
PaymentProcessingResult.CreateSuccessfulResult(string.Empty));
}
return(PaymentProcessingResult.CreateUnsuccessfulResult(DocumentHelpers.GetErrorMessage(responseDoc)));
}
catch (System.Exception e)
{
return(PaymentProcessingResult.CreateUnsuccessfulResult(e.Message));
}
}
/// <summary>
/// Processes the payment.
/// </summary>
/// <param name="orderGroup">The order group.</param>
/// <param name="payment">The payment.</param>
public PaymentProcessingResult ProcessPayment(IOrderGroup orderGroup, IPayment payment)
{
// checks
if (HttpContext.Current == null)
{
return(PaymentProcessingResult.CreateSuccessfulResult(Utilities.Translate("ProcessPaymentNullHttpContext")));
}
if (payment == null)
{
return(PaymentProcessingResult.CreateUnsuccessfulResult(Utilities.Translate("PaymentNotSpecified")));
}
var orderForm = orderGroup.Forms.FirstOrDefault(f => f.Payments.Contains(payment));
if (orderForm == null)
{
return(PaymentProcessingResult.CreateUnsuccessfulResult(Utilities.Translate("PaymentNotAssociatedOrderForm")));
}
// todo: not needed...
// bool isRegularTransaction = IsRegularTransaction(orderGroup);
// its a purchase order
var purchaseOrder = orderGroup as IPurchaseOrder;
if (purchaseOrder != null)
{
if (payment.TransactionType == TransactionType.Capture.ToString())
{
// return true meaning the capture request is done by epay
var result = _epayRequestHelper.PostCaptureRequest(payment, purchaseOrder);
if (result.Equals(false))
{
return(PaymentProcessingResult.CreateUnsuccessfulResult("There was an error while capturing payment with Epay"));
}
return(PaymentProcessingResult.CreateSuccessfulResult(string.Empty));
}
//todo: add credit
if (payment.TransactionType == TransactionType.Credit.ToString())
{
//return PaymentProcessingResult.CreateUnsuccessfulResult("The current payment method credit does not support this order type.");
var transactionID = payment.TransactionID;
if (string.IsNullOrEmpty(transactionID) || transactionID.Equals("0"))
{
return(PaymentProcessingResult.CreateUnsuccessfulResult("TransactionID is not valid or the current payment method does not support this order type."));
}
// The transact must be captured before refunding
string message = string.Empty;
if (_epayRequestHelper.PostRefundRequest(payment, purchaseOrder, ref message))
{
return(PaymentProcessingResult.CreateSuccessfulResult(string.Empty));
}
return(PaymentProcessingResult.CreateUnsuccessfulResult($"There was an error while refunding with epay. {message}"));
}
// right now we do not support processing the order which is created by Commerce Manager
return(PaymentProcessingResult.CreateUnsuccessfulResult("The current payment method does not support this order type."));
}
var cart = orderGroup as ICart;
if (cart != null && cart.OrderStatus == OrderStatus.Completed)
{
return(PaymentProcessingResult.CreateSuccessfulResult(string.Empty));
}
_orderRepository.Save(orderGroup);
var redirectUrl = Utilities.GetUrlFromStartPageReferenceProperty("EpayPaymentPage");
return(PaymentProcessingResult.CreateSuccessfulResult(string.Empty, redirectUrl));
}
private PaymentProcessingResult Charge(IOrderGroup cart,
ICreditCardPayment creditCardPayment,
IOrderAddress billingAddress)
{
var contact = CustomerContext.Current.GetContactById(cart.CustomerId);
StripeCustomer stripeCustomer = null;
try
{
if (contact != null)
{
if (!string.IsNullOrEmpty(contact?["StripeId"]?.ToString()))
{
stripeCustomer = _stripeCustomerService.Get(contact["StripeId"].ToString());
}
if (stripeCustomer == null)
{
stripeCustomer = _stripeCustomerService.Create(new StripeCustomerCreateOptions
{
Email = contact.Email,
SourceToken = creditCardPayment.CreditCardNumber
});
contact["StripeId"] = stripeCustomer.Id;
contact.SaveChanges();
}
}
Enum.TryParse(creditCardPayment.TransactionType, out TransactionType transactionType);
var options = new StripeChargeCreateOptions
{
Amount = (int)creditCardPayment.Amount * GetMultiplier(cart.Currency),
Description = "Ecommerce Charge",
Currency = cart.Currency.ToString().ToLower(),
Capture = transactionType == TransactionType.Capture ||
transactionType == TransactionType.CaptureOnly
};
if (stripeCustomer != null)
{
options.CustomerId = stripeCustomer.Id;
}
else
{
options.SourceTokenOrExistingSourceId = creditCardPayment.CreditCardNumber;
}
var charge = _stripeChargeService.Create(options);
if (!string.IsNullOrEmpty(charge.FailureCode))
{
return(PaymentProcessingResult.CreateUnsuccessfulResult(Translate(charge.Outcome.Reason)));
}
creditCardPayment.ProviderPaymentId = charge.Id;
creditCardPayment.ProviderTransactionID = charge.BalanceTransactionId;
creditCardPayment.Properties["stripe_CustomerId"] = stripeCustomer?.Id;
return(PaymentProcessingResult.CreateSuccessfulResult(""));
}
catch (StripeException e)
{
switch (e.StripeError.ErrorType)
{
case "card_error":
return(PaymentProcessingResult.CreateUnsuccessfulResult(Translate(e.StripeError.Code)));
default:
return(PaymentProcessingResult.CreateUnsuccessfulResult(e.StripeError.Message));
}
}
}
public void PlaceOrder_WhenProcessingPaymentNotSuccess_ShouldReturnNullAndAddModelError()
{
var cartTotal = new Money(1, Currency.USD);
_orderGroupCalculatorMock.Setup(x => x.GetTotal(It.IsAny <IOrderGroup>())).Returns(() => cartTotal);
_orderRepositoryMock.Setup(x => x.Load <IPurchaseOrder>(It.IsAny <int>())).Returns(new Mock <IPurchaseOrder>().Object);
_orderRepositoryMock.Setup(x => x.SaveAsPurchaseOrder(It.IsAny <ICart>()))
.Returns(() => new OrderReference(0, "", Guid.Empty, null));
var cart = new FakeCart(new MarketImpl(MarketId.Empty), Currency.SEK)
{
OrderLink = new OrderReference(1, "", Guid.Empty, null)
};
cart.GetFirstForm().Payments.Add(new FakePayment {
Status = PaymentStatus.Processed.ToString(), Amount = cartTotal.Amount
});
var modelState = new ModelStateDictionary();
var viewModel = new CheckoutViewModel
{
BillingAddress = new AddressModel {
AddressId = "billingAddress"
},
Payment = new Mock <CashOnDeliveryPaymentOption>(null, null, null, null, null).Object
};
_paymentProcessorMock.Setup(x => x.ProcessPayment(It.IsAny <IOrderGroup>(), It.IsAny <IPayment>(), It.IsAny <IShipment>()))
.Returns((IOrderGroup orderGroup, IPayment payment, IShipment shipment) => PaymentProcessingResult.CreateUnsuccessfulResult("Payment was failed."));
var result = _subject.PlaceOrder(cart, modelState, viewModel);
Assert.Null(result);
Assert.Equal(1, modelState.Count(x => x.Value.Errors.Count > 0));
}
/// <summary>
/// Processes the payment.
/// </summary>
/// <param name="orderGroup">The order group.</param>
/// <param name="payment">The payment.</param>
public PaymentProcessingResult ProcessPayment(IOrderGroup orderGroup, IPayment payment)
{
if (HttpContext.Current == null)
{
return(PaymentProcessingResult.CreateSuccessfulResult(Utilities.Translate("ProcessPaymentNullHttpContext")));
}
if (payment == null)
{
return(PaymentProcessingResult.CreateUnsuccessfulResult(Utilities.Translate("PaymentNotSpecified")));
}
var orderForm = orderGroup.Forms.FirstOrDefault(f => f.Payments.Contains(payment));
if (orderForm == null)
{
return(PaymentProcessingResult.CreateUnsuccessfulResult(Utilities.Translate("PaymentNotAssociatedOrderForm")));
}
var purchaseOrder = orderGroup as IPurchaseOrder;
if (purchaseOrder != null)
{
if (payment.TransactionType == TransactionType.Capture.ToString())
{
// return true meaning the capture request is done,
// actual capturing must be done on DIBS.
var result = _dibsRequestHelper.PostCaptureRequest(payment, purchaseOrder);
var status = result["status"];
if (status == "ACCEPT")
{
return(PaymentProcessingResult.CreateSuccessfulResult(string.Empty));
}
return(PaymentProcessingResult.CreateUnsuccessfulResult(
$@"There was an error while capturing payment with DIBS.
status: {status}
declineReason: {result["declineReason"]}"));
}
if (payment.TransactionType == TransactionType.Credit.ToString())
{
var transactionID = payment.TransactionID;
if (string.IsNullOrEmpty(transactionID) || transactionID.Equals("0"))
{
return(PaymentProcessingResult.CreateUnsuccessfulResult("TransactionID is not valid or the current payment method does not support this order type."));
}
// The transact must be captured before refunding
var result = _dibsRequestHelper.PostRefundRequest(payment, purchaseOrder);
var status = result["status"];
if (status == "ACCEPT")
{
return(PaymentProcessingResult.CreateSuccessfulResult(string.Empty));
}
return(PaymentProcessingResult.CreateUnsuccessfulResult(
$@"There was an error while capturing payment with DIBS.
status: {status}
declineReason: {result["declineReason"]}"));
}
// right now we do not support processing the order which is created by Commerce Manager
return(PaymentProcessingResult.CreateUnsuccessfulResult("The current payment method does not support this order type."));
}
var cart = orderGroup as ICart;
if (cart != null && cart.OrderStatus == OrderStatus.Completed)
{
return(PaymentProcessingResult.CreateSuccessfulResult(string.Empty));
}
_orderRepository.Save(orderGroup);
var redirectUrl = Utilities.GetUrlFromStartPageReferenceProperty("DIBSPaymentPage");
return(PaymentProcessingResult.CreateSuccessfulResult(string.Empty, redirectUrl));
}
/// <summary>
/// Processes the payment.
/// </summary>
/// <param name="orderGroup">The order group.</param>
/// <param name="payment">The payment.</param>
public PaymentProcessingResult ProcessPayment(IOrderGroup orderGroup, IPayment payment)
{
if (HttpContext.Current == null)
{
return(PaymentProcessingResult.CreateSuccessfulResult("Http context is null."));
}
if (payment == null)
{
return(PaymentProcessingResult.CreateUnsuccessfulResult("Payment was not specified."));
}
var orderForm = orderGroup.Forms.FirstOrDefault(f => f.Payments.Contains(payment));
if (orderForm == null)
{
return(PaymentProcessingResult.CreateUnsuccessfulResult(
"There is no order form associated with payment."));
}
if (orderGroup is IPurchaseOrder purchaseOrder)
{
if (payment.TransactionType == TransactionType.Capture.ToString())
{
// return true meaning the capture request is done,
// actual capturing must be done on Dintero.
var transaction = _requestsHelper.GetTransactionDetails(payment.TransactionID, _requestsHelper.GetAccessToken());
var skipItems = payment.Amount != 0 && payment.Amount < purchaseOrder.GetTotal().Amount&& !string.IsNullOrEmpty(transaction.PaymentProduct) &&
!transaction.PaymentProduct.Equals("instabank", StringComparison.InvariantCultureIgnoreCase);
var result = payment.Amount == 0? new TransactionResult {
Success = true
} : _requestsHelper.CaptureTransaction(payment, purchaseOrder, skipItems);
if (result.Success)
{
return(PaymentProcessingResult.CreateSuccessfulResult(string.Empty));
}
PostProcessPayment.PostCapture(result, payment);
return(PaymentProcessingResult.CreateUnsuccessfulResult(
$@"There was an error while capturing payment with Dintero:
code: {
result.ErrorCode
};
declineReason: {
result.Error
}"));
}
if (payment.TransactionType == TransactionType.Void.ToString())
{
var result = payment.Amount == 0 ? new TransactionResult {
Success = true
} : _requestsHelper.VoidTransaction(payment);
if (result.Success)
{
return(PaymentProcessingResult.CreateSuccessfulResult(string.Empty));
}
return(PaymentProcessingResult.CreateUnsuccessfulResult(
$@"There was an error while voiding payment with Dintero:
code: {
result.ErrorCode
};
declineReason: {
result.Error
}"));
}
if (payment.TransactionType == TransactionType.Credit.ToString())
{
if (!(purchaseOrder is PurchaseOrder refundOrder))
{
return(PaymentProcessingResult.CreateUnsuccessfulResult("Order has invalid type."));
}
var transactionId = payment.TransactionID;
if (string.IsNullOrEmpty(transactionId) || transactionId.Equals("0"))
{
return(PaymentProcessingResult.CreateUnsuccessfulResult(
"TransactionID is not valid or the current payment method does not support this order type."));
}
var returnForms = refundOrder.ReturnOrderForms.Where(rt =>
rt.Status == ReturnFormStatus.Complete.ToString() && rt.Total == payment.Amount).ToList();
if (!returnForms.Any())
{
return(PaymentProcessingResult.CreateUnsuccessfulResult("No items found for refunding."));
}
var result = payment.Amount == 0 ? new TransactionResult {
Success = true
} : _requestsHelper.RefundTransaction(payment, returnForms, purchaseOrder.Currency);
if (result.Success)
{
return(PaymentProcessingResult.CreateSuccessfulResult(string.Empty));
}
PostProcessPayment.PostCredit(result, payment);
return(PaymentProcessingResult.CreateUnsuccessfulResult(
$@"There was an error while refunding payment with Dintero: code: { result.ErrorCode }; declineReason: { result.Error }"));
}
// right now we do not support processing the order which is created by Commerce Manager
return(PaymentProcessingResult.CreateUnsuccessfulResult(
"The current payment method does not support this order type."));
}
if (orderGroup is ICart cart && cart.OrderStatus == OrderStatus.Completed)
{
return(PaymentProcessingResult.CreateSuccessfulResult(string.Empty));
}
_orderRepository.Save(orderGroup);
var redirectUrl = UriUtil.GetUrlFromStartPageReferenceProperty("DinteroPaymentPage");
return(PaymentProcessingResult.CreateSuccessfulResult(string.Empty, redirectUrl));
}