public override ApiResult CancelPayment(OrderReadOnly order, YourpayCheckoutSettings settings)
{
// Release payment: https://yourpay.docs.apiary.io/#/reference/0/payment-release/payment-release
try
{
var clientConfig = GetYourpayClientConfig(settings);
var client = new YourpayClient(clientConfig);
var transactionId = order.TransactionInfo.TransactionId;
var result = client.ReleasePayment(transactionId);
if (result != null && result.Success)
{
return(new ApiResult()
{
TransactionInfo = new TransactionInfoUpdate()
{
TransactionId = transactionId,
PaymentStatus = PaymentStatus.Cancelled
}
});
}
}
catch (Exception ex)
{
Vendr.Log.Error <YourpayCheckoutPaymentProvider>(ex, "Yourpay - CancelPayment");
}
return(ApiResult.Empty);
}
public override ApiResult RefundPayment(OrderReadOnly order, YourpayCheckoutSettings settings)
{
// Refund payment: https://yourpay.docs.apiary.io/#/reference/0/payment-actions/refund-payment
try
{
var clientConfig = GetYourpayClientConfig(settings);
var client = new YourpayClient(clientConfig);
var transactionId = order.TransactionInfo.TransactionId;
var amount = -Math.Abs(AmountToMinorUnits(order.TransactionInfo.AmountAuthorized.Value));
var result = client.RefundPayment(transactionId, amount);
if (result != null && result.Success)
{
return(new ApiResult()
{
TransactionInfo = new TransactionInfoUpdate()
{
TransactionId = transactionId,
PaymentStatus = GetPaymentStatus(result)
}
});
}
}
catch (Exception ex)
{
Vendr.Log.Error <YourpayCheckoutPaymentProvider>(ex, "Yourpay - RefundPayment");
}
return(ApiResult.Empty);
}
public CallbackResult HandleCallback(OrderReadOnly order, CallbackRequestModel request, OpayoSettings settings)
{
switch (request.Status)
{
case OpayoConstants.CallbackRequest.Status.Abort:
return(GenerateAbortedCallbackResponse(order, request, settings));
case OpayoConstants.CallbackRequest.Status.Rejected:
return(GenerateRejectedCallbackResponse(order, request, settings));
case OpayoConstants.CallbackRequest.Status.Registered:
case OpayoConstants.CallbackRequest.Status.Error:
return(GenerateErrorCallbackResponse(order, request, settings));
case OpayoConstants.CallbackRequest.Status.Pending:
return(GeneratePendingCallbackResponse(order, request, settings));
case OpayoConstants.CallbackRequest.Status.Ok:
return(GenerateOkCallbackResponse(order, request, settings));
case OpayoConstants.CallbackRequest.Status.NotAuthorised:
return(GenerateNotAuthorisedCallbackResponse(order, request, settings));
case OpayoConstants.CallbackRequest.Status.Authenticated:
return(GenerateAuthenticatedCallbackResponse(order, request, settings));
default:
return(CallbackResult.Empty);
}
}
public override string GetCancelUrl(OrderReadOnly order, DibsSettings settings)
{
settings.MustNotBeNull("settings");
settings.CancelUrl.MustNotBeNull("settings.CancelUrl");
return(settings.CancelUrl);
}
private CallbackResult GeneratePendingCallbackResponse(OrderReadOnly order, CallbackRequestModel request, OpayoSettings settings)
{
logger.Warn <OpayoServerClient>("Payment transaction pending:\n\tOpayoTx: {VPSTxId}", request.VPSTxId);
var validSig = ValidateVpsSigniture(order, request, settings);
return(new CallbackResult
{
TransactionInfo = validSig
? new TransactionInfo
{
TransactionId = request.VPSTxId,
AmountAuthorized = order.TotalPrice.Value.WithTax,
TransactionFee = request.Surcharge,
PaymentStatus = PaymentStatus.PendingExternalSystem
}
: null,
HttpResponse = new HttpResponseMessage(System.Net.HttpStatusCode.OK)
{
Content = validSig
? GenerateOkCallbackResponseBody()
: GenerateInvalidCallbackResponseBody()
}
});
}
private bool ValidateVpsSigniture(OrderReadOnly order, CallbackRequestModel callbackRequest, OpayoSettings settings)
{
var md5Values = new List <string>
{
callbackRequest.VPSTxId,
callbackRequest.VendorTxCode,
callbackRequest.Status,
callbackRequest.TxAuthNo,
settings.VendorName.ToLowerInvariant(),
callbackRequest.AVSCV2,
order.Properties[OpayoConstants.OrderProperties.SecurityKey]?.Value,
callbackRequest.AddressResult,
callbackRequest.PostCodeResult,
callbackRequest.CV2Result,
callbackRequest.GiftAid,
callbackRequest.SecureStatus,
callbackRequest.CAVV,
callbackRequest.AddressStatus,
callbackRequest.PayerStatus,
callbackRequest.CardType,
callbackRequest.Last4Digits,
callbackRequest.DeclineCode,
callbackRequest.ExpiryDate,
callbackRequest.FraudResponse,
callbackRequest.BankAuthCode
};
string calcedMd5Hash = string.Join("", md5Values.Where(v => string.IsNullOrEmpty(v) == false)).ToMD5Hash().ToUpperInvariant();
return(callbackRequest.VPSSignature == calcedMd5Hash);
}
public override PaymentFormResult GenerateForm(OrderReadOnly order, string continueUrl, string cancelUrl, string callbackUrl, InvoicingSettings settings)
{
return(new PaymentFormResult()
{
Form = new PaymentForm(continueUrl, FormMethod.Post)
});
}
private CallbackResult GenerateNotAuthorisedCallbackResponse(OrderReadOnly order, CallbackRequestModel request, OpayoSettings settings)
{
logger.Warn <OpayoServerClient>("Payment transaction not authorised:\n\tOpayoTx: {VPSTxId}", request.VPSTxId);
var validSig = ValidateVpsSigniture(order, request, settings);
return(new CallbackResult
{
TransactionInfo = validSig
? new TransactionInfo
{
TransactionId = request.VPSTxId,
AmountAuthorized = 0,
TransactionFee = request.Surcharge,
PaymentStatus = PaymentStatus.Error
}
: null,
HttpResponse = new HttpResponseMessage(System.Net.HttpStatusCode.OK)
{
Content = validSig
? GenerateRejectedCallbackResponseBody()
: GenerateInvalidCallbackResponseBody()
},
MetaData = validSig
? new Dictionary <string, string>
{
{ OpayoConstants.OrderProperties.TransDetails, string.Join(":", request.TxAuthNo, request.CardType, request.Last4Digits) },
{ OpayoConstants.OrderProperties.TransDetailsHash, string.Join(":", request.TxAuthNo, request.CardType, request.Last4Digits).ToMD5Hash() }
}
: null
});
}
public override string GetCancelUrl(OrderReadOnly order, PayNlPaymentProviderSettings settings)
{
settings.MustNotBeNull("settings");
settings.ErrorUrl.MustNotBeNull("settings.ErrorUrl");
return(settings.CancelUrl);
}
public CallbackResult HandleCallback(OrderReadOnly order, CallbackRequestModel request, OpayoSettings settings)
{
switch (request.Status)
{
case OpayoConstants.CallbackRequest.Status.Abort:
return(GenerateAbortedCallbackResponse(order, request, settings));
case OpayoConstants.CallbackRequest.Status.Rejected:
return(GenerateRejectedCallbackResponse(order, request, settings));
case OpayoConstants.CallbackRequest.Status.Registered:
case OpayoConstants.CallbackRequest.Status.Error:
return(GenerateErrorCallbackResponse(order, request, settings));
case OpayoConstants.CallbackRequest.Status.Pending:
return(GeneratePendingCallbackResponse(order, request, settings));
case OpayoConstants.CallbackRequest.Status.Ok:
return(GenerateOkCallbackResponse(order, request, settings));
case OpayoConstants.CallbackRequest.Status.NotAuthorised:
return(GenerateNotAuthorisedCallbackResponse(order, request, settings));
case OpayoConstants.CallbackRequest.Status.Authenticated:
return(GenerateAuthenticatedCallbackResponse(order, request, settings));
default:
logger.Warn <SagePayServerClient>("Unknown callback response status recieved: {status}", request.Status);
return(CallbackResult.Empty);
}
}
public override string GetContinueUrl(OrderReadOnly order, InvoicingSettings settings)
{
settings.MustNotBeNull("settings");
settings.ContinueUrl.MustNotBeNull("settings.ContinueUrl");
return(settings.ContinueUrl);
}
public override PaymentFormResult GenerateForm(OrderReadOnly order, string continueUrl, string cancelUrl, string callbackUrl, StripeCheckoutSettings settings)
{
var session = CreateSession(order, continueUrl, cancelUrl, settings);
var publicKey = settings.TestMode ? settings.TestPublicKey : settings.LivePublicKey;
return(new PaymentFormResult()
{
MetaData = new Dictionary <string, string>
{
{ "stripeSessionId", session.Id },
{ "stripeCustomerId", session.CustomerId }
},
Form = new PaymentForm(continueUrl, FormMethod.Post)
.WithAttribute("onsubmit", "return handleStripeCheckout(event)")
.WithJsFile("https://js.stripe.com/v3/")
.WithJs(@"
var stripe = Stripe('" + publicKey + @"');
window.handleStripeCheckout = function (e) {
e.preventDefault();
stripe.redirectToCheckout({
sessionId: '" + session.Id + @"'
}).then(function (result) {
// If `redirectToCheckout` fails due to a browser or network
// error, display the localized error message to your customer
// using `result.error.message`.
});
return false;
}
")
});
}
public override string GetErrorUrl(OrderReadOnly order, TSettings settings)
{
settings.MustNotBeNull("settings");
settings.ErrorUrl.MustNotBeNull("settings.ErrorUrl");
return(settings.ErrorUrl);
}
public override PaymentForm GenerateForm(OrderReadOnly order, string continueUrl, string cancelUrl, string callbackUrl, DibsSettings settings)
{
var currency = Vendr.Services.CurrencyService.GetCurrency(order.CurrencyId);
// Ensure currency has valid ISO 4217 code
if (!ISO4217.Codes.ContainsKey(currency.Code.ToUpperInvariant()))
{
throw new Exception("Currency must a valid ISO 4217 currency code: " + currency.Name);
}
var strCurrency = ISO4217.Codes[currency.Code.ToUpperInvariant()].ToString(CultureInfo.InvariantCulture);
var orderAmount = (order.TotalPrice.Value.WithTax * 100M).ToString("0", CultureInfo.InvariantCulture);
// MD5(key2 + MD5(key1 + "merchant=<merchant>&orderid=<orderid> ¤cy=<cur>&amount=<amount>"))
var md5Check = $"merchant={settings.MerchantId}&orderid={order.OrderNumber}¤cy={strCurrency}&amount={orderAmount}";
var md5Hash = GetMD5Hash(settings.MD5Key2 + GetMD5Hash(settings.MD5Key1 + md5Check));
return(new PaymentForm("https://payment.architrade.com/paymentweb/start.action", FormMethod.Post)
.WithInput("orderid", order.OrderNumber)
.WithInput("merchant", settings.MerchantId)
.WithInput("amount", orderAmount)
.WithInput("currency", strCurrency)
.WithInput("accepturl", continueUrl)
.WithInput("cancelurl", cancelUrl)
.WithInput("callbackurl", callbackUrl)
.WithInputIf("capturenow", settings.Capture, "yes")
.WithInputIf("calcfee", settings.CalcFee, "yes")
.WithInputIf("test", settings.Mode == DibsMode.Test, "yes")
.WithInput("md5key", md5Hash));
}
public override ApiResult CancelPayment(OrderReadOnly order, PayPalCheckoutOneTimeSettings settings)
{
try
{
if (order.TransactionInfo.PaymentStatus == PaymentStatus.Authorized)
{
var clientConfig = GetPayPalClientConfig(settings);
var client = new PayPalClient(clientConfig);
client.CancelPayment(order.TransactionInfo.TransactionId);
// Cancel payment enpoint doesn't return a result so if the request is successfull
// then we'll deem it as successfull and directly set the payment status to Cancelled
return(new ApiResult()
{
TransactionInfo = new TransactionInfoUpdate()
{
TransactionId = order.TransactionInfo.TransactionId,
PaymentStatus = PaymentStatus.Cancelled
}
});
}
}
catch (Exception ex)
{
Vendr.Log.Error <PayPalCheckoutOneTimePaymentProvider>(ex, "PayPal - CancelPayment");
}
return(ApiResult.Empty);
}
public override bool CanProcessOrder(OrderReadOnly order, StripeCheckoutSettings settings, ref string errorMessage)
{
long recurringTotalPrice = 0;
bool hasRecurringItems = false;
long orderTotalPriceWithPaymentMethodFee = AmountToMinorUnits(order.TransactionAmount.Value - order.PaymentInfo.TotalPrice.Value.WithTax);
var lineItems = new List <SessionLineItemOptions>();
foreach (var orderLine in order.OrderLines.Where(IsRecurringOrderLine))
{
recurringTotalPrice += AmountToMinorUnits(orderLine.TotalPrice.Value.WithTax);
hasRecurringItems = true;
}
// If we don't have any recurring items then we can process the order fine
if (!hasRecurringItems)
{
return(true);
}
// If we do have recurring items, make sure the total price of the order
// is greater than the value of all recurring order items
if (recurringTotalPrice <= orderTotalPriceWithPaymentMethodFee)
{
return(true);
}
errorMessage = "Cannot process orders where the total value of recurring order items is greater than the order total";
return(false);
}
public override ApiResult RefundPayment(OrderReadOnly order, PayPalCheckoutOneTimeSettings settings)
{
try
{
if (order.TransactionInfo.PaymentStatus == PaymentStatus.Captured)
{
var clientConfig = GetPayPalClientConfig(settings);
var client = new PayPalClient(clientConfig);
var payPalPayment = client.RefundPayment(order.TransactionInfo.TransactionId);
return(new ApiResult()
{
TransactionInfo = new TransactionInfoUpdate()
{
TransactionId = payPalPayment.Id,
PaymentStatus = GetPaymentStatus(payPalPayment)
}
});
}
}
catch (Exception ex)
{
Vendr.Log.Error <PayPalCheckoutOneTimePaymentProvider>(ex, "PayPal - RefundPayment");
}
return(ApiResult.Empty);
}
public override ApiResult FetchPaymentStatus(OrderReadOnly order, PayPalCheckoutOneTimeSettings settings)
{
try
{
if (order.Properties.ContainsKey("PayPalOrderId"))
{
var payPalOrderId = order.Properties["PayPalOrderId"].Value;
var clientConfig = GetPayPalClientConfig(settings);
var client = new PayPalClient(clientConfig);
var payPalOrder = client.GetOrder(payPalOrderId);
var paymentStatus = GetPaymentStatus(payPalOrder, out PayPalPayment payPalPayment);
return(new ApiResult()
{
TransactionInfo = new TransactionInfoUpdate()
{
TransactionId = payPalPayment.Id,
PaymentStatus = paymentStatus
}
});
}
}
catch (Exception ex)
{
Vendr.Log.Error <PayPalCheckoutOneTimePaymentProvider>(ex, "PayPal - FetchPaymentStatus");
}
return(ApiResult.Empty);
}
public override CallbackResult ProcessCallback(OrderReadOnly order, HttpRequestBase request, PayPalCheckoutOneTimeSettings settings)
{
try
{
var clientConfig = GetPayPalClientConfig(settings);
var client = new PayPalClient(clientConfig);
var payPalWebhookEvent = GetPayPalWebhookEvent(client, request);
if (payPalWebhookEvent != null && payPalWebhookEvent.EventType.StartsWith("CHECKOUT.ORDER.APPROVED"))
{
var webhookPayPalOrder = payPalWebhookEvent.Resource.ToObject <PayPalOrder>();
// Fetch persisted order as it may have changed since the webhook
// was initially sent (it could be a webhook resend)
var persistedPayPalOrder = client.GetOrder(webhookPayPalOrder.Id);
PayPalOrder payPalOrder;
PayPalPayment payPalPayment;
if (persistedPayPalOrder.Intent == PayPalOrder.Intents.AUTHORIZE)
{
// Authorize
payPalOrder = persistedPayPalOrder.Status != PayPalOrder.Statuses.APPROVED
? persistedPayPalOrder
: client.AuthorizeOrder(persistedPayPalOrder.Id);
payPalPayment = payPalOrder.PurchaseUnits[0].Payments?.Authorizations?.FirstOrDefault();
}
else
{
// Capture
payPalOrder = persistedPayPalOrder.Status != PayPalOrder.Statuses.APPROVED
? persistedPayPalOrder
: client.CaptureOrder(persistedPayPalOrder.Id);
payPalPayment = payPalOrder.PurchaseUnits[0].Payments?.Captures?.FirstOrDefault();
}
return(CallbackResult.Ok(new TransactionInfo
{
AmountAuthorized = decimal.Parse(payPalPayment?.Amount.Value ?? "0.00"),
TransactionId = payPalPayment?.Id ?? "",
PaymentStatus = GetPaymentStatus(payPalOrder)
},
new Dictionary <string, string>
{
{ "PayPalOrderId", payPalOrder.Id }
}));
}
}
catch (Exception ex)
{
Vendr.Log.Error <PayPalCheckoutOneTimePaymentProvider>(ex, "PayPal - ProcessCallback");
}
return(CallbackResult.BadRequest());
}
public static Dictionary <string, string> LoadInputs(OrderReadOnly order, OpayoSettings settings, VendrContext context, string callbackUrl)
{
var inputFields = new Dictionary <string, string>();
LoadBasicSettings(inputFields, settings, callbackUrl);
LoadOrderValues(inputFields, order, settings, context);
return(inputFields);
}
public override ApiResult RefundPayment(OrderReadOnly order, StripeCheckoutSettings settings)
{
try
{
// We can only refund a captured charge, so make sure we have one
// otherwise there is nothing we can do
var chargeId = order.Properties["stripeChargeId"];
if (string.IsNullOrWhiteSpace(chargeId))
{
return(null);
}
var secretKey = settings.TestMode ? settings.TestSecretKey : settings.LiveSecretKey;
ConfigureStripe(secretKey);
var refundService = new RefundService();
var refundCreateOptions = new RefundCreateOptions()
{
Charge = chargeId
};
var refund = refundService.Create(refundCreateOptions);
var charge = refund.Charge ?? new ChargeService().Get(refund.ChargeId);
// If we have a subscription then we'll cancel it as refunding an order
// should effecitvely undo any purchase
if (!string.IsNullOrWhiteSpace(order.Properties["stripeSubscriptionId"]))
{
var subscriptionService = new SubscriptionService();
var subscription = subscriptionService.Get(order.Properties["stripeSubscriptionId"]);
if (subscription != null)
{
subscriptionService.Cancel(order.Properties["stripeSubscriptionId"], new SubscriptionCancelOptions
{
InvoiceNow = false,
Prorate = false
});
}
}
return(new ApiResult()
{
TransactionInfo = new TransactionInfoUpdate()
{
TransactionId = GetTransactionId(charge),
PaymentStatus = GetPaymentStatus(charge)
}
});
}
catch (Exception ex)
{
Vendr.Log.Error <StripeCheckoutOneTimePaymentProvider>(ex, "Stripe - RefundPayment");
}
return(ApiResult.Empty);
}
public override ApiResult CapturePayment(OrderReadOnly order, InvoicingSettings settings)
{
return(new ApiResult()
{
TransactionInfo = new TransactionInfoUpdate()
{
TransactionId = order.TransactionInfo.TransactionId,
PaymentStatus = PaymentStatus.Captured
}
});
}
private static void LoadOrderLines(Dictionary <string, string> inputFields, OrderReadOnly order)
{
var orderLines = new List <string>();
foreach (var item in order.OrderLines)
{
orderLines.Add($"{item.ProductReference}:{item.Quantity}:{item.UnitPrice.Value.WithoutTax:0.00}:{item.UnitPrice.Value.Tax:0.00}:{item.UnitPrice.Value.WithTax:0.00}:{item.TotalPrice.Value.WithTax:0.00}");
}
orderLines.Insert(0, orderLines.Count.ToString());
inputFields.Add(OpayoConstants.TransactionRequestFields.Basket, string.Join(":", orderLines));
}
public override CallbackResponse ProcessCallback(OrderReadOnly order, HttpRequestBase request, TemplateSettings settings)
{
return(new CallbackResponse
{
TransactionInfo = new TransactionInfo
{
AmountAuthorized = order.TotalPrice.Value.WithTax,
TransactionFee = 0m,
TransactionId = Guid.NewGuid().ToString("N"),
PaymentStatus = PaymentStatus.Authorized
}
});
}
public override CallbackResult ProcessCallback(OrderReadOnly order, HttpRequestBase request, InvoicingSettings settings)
{
return(new CallbackResult
{
TransactionInfo = new TransactionInfo
{
AmountAuthorized = order.TransactionAmount.Value,
TransactionFee = 0m,
TransactionId = Guid.NewGuid().ToString("N"),
PaymentStatus = PaymentStatus.Authorized
}
});
}
public override ApiResponse RefundPayment(OrderReadOnly order, DibsSettings settings)
{
try
{
var currency = Vendr.Services.CurrencyService.GetCurrency(order.CurrencyId);
// Ensure currency has valid ISO 4217 code
if (!ISO4217.Codes.ContainsKey(currency.Code.ToUpperInvariant()))
{
throw new Exception("Currency must a valid ISO 4217 currency code: " + currency.Name);
}
var strCurrency = ISO4217.Codes[currency.Code.ToUpperInvariant()].ToString(CultureInfo.InvariantCulture);
var strAmount = (order.TransactionInfo.AmountAuthorized.Value * 100M).ToString("0", CultureInfo.InvariantCulture);
// MD5(key2 + MD5(key1 + "merchant=<merchant>&orderid=<orderid>&transact=<transact>&amount=<amount>"))
var md5Check = $"merchant={settings.MerchantId}&orderid={order.OrderNumber}&transact={order.TransactionInfo.TransactionId}&amount={strAmount}";
var response = $"https://payment.architrade.com/cgi-adm/refund.cgi"
.WithBasicAuth(settings.ApiUsername, settings.ApiPassword)
.PostUrlEncodedAsync(new
{
merchant = settings.MerchantId,
orderid = order.OrderNumber,
transact = order.TransactionInfo.TransactionId,
amount = strAmount,
currency = strCurrency,
textreply = "yes",
md5key = GetMD5Hash(settings.MD5Key2 + GetMD5Hash(settings.MD5Key1 + md5Check))
})
.ReceiveString();
var responseParams = HttpUtility.ParseQueryString(response.Result);
var result = responseParams["result"];
if (result == "0") // 0 == Accepted
{
return(new ApiResponse(order.TransactionInfo.TransactionId, PaymentStatus.Cancelled));
}
else
{
Vendr.Log.Warn <DibsPaymentProvider>($"Dibs [{order.OrderNumber}] - Error making API request - error message: {result}");
}
}
catch (Exception ex)
{
Vendr.Log.Error <DibsPaymentProvider>(ex, "Dibs - CapturePayment");
}
return(null);
}
private static void LoadOrderLines(Dictionary <string, string> inputFields, OrderReadOnly order, OpayoSettings settings)
{
var orderLines = new List <string>();
foreach (var item in order.OrderLines)
{
var itemDescription = GetItemDescriptionByOrderPropertyDescriptionAlias(item, settings.OrderLinePropertyDescription);
orderLines.Add($"{itemDescription}:{item.Quantity}:{item.UnitPrice.Value.WithoutTax:0.00}:{item.UnitPrice.Value.Tax:0.00}:{item.UnitPrice.Value.WithTax:0.00}:{item.TotalPrice.Value.WithTax:0.00}");
}
orderLines.Insert(0, orderLines.Count.ToString());
inputFields.Add(OpayoConstants.TransactionRequestFields.Basket, string.Join(":", orderLines));
}
public override CallbackResult ProcessCallback(OrderReadOnly order, HttpRequestBase request, OpayoSettings settings)
{
var callbackRequestModel = CallbackRequestModel.FromRequest(request);
var client = new OpayoServerClient(
logger,
new OpayoServerClientConfig {
ProviderAlias = Alias,
ContinueUrl = paymentProviderUriResolver.GetContinueUrl(Alias, order.GenerateOrderReference(), hashProvider),
CancelUrl = paymentProviderUriResolver.GetCancelUrl(Alias, order.GenerateOrderReference(), hashProvider),
ErrorUrl = GetErrorUrl(order, settings)
});
return(client.HandleCallback(order, callbackRequestModel, settings));
}
public override OrderReference GetOrderReference(HttpRequestBase request, SquareSettings settings)
{
var accessToken = settings.SandboxMode ? settings.SandboxAccessToken : settings.LiveAccessToken;
var environment = settings.SandboxMode ? SquareSdk.Environment.Sandbox : SquareSdk.Environment.Production;
var client = new SquareSdk.SquareClient.Builder()
.Environment(environment)
.AccessToken(accessToken)
.Build();
var orderApi = client.OrdersApi;
SquareSdk.Models.Order squareOrder = null;
var squareEvent = GetSquareWebhookEvent(request, settings);
if (squareEvent != null && squareEvent.IsValid)
{
try
{
var referenceId = "";
var orderId = GetOrderId(squareEvent);
if (!string.IsNullOrWhiteSpace(orderId))
{
var result = orderApi.BatchRetrieveOrders(
new BatchRetrieveOrdersRequest(new List <string>()
{
orderId
}));
squareOrder = result.Orders.FirstOrDefault();
referenceId = squareOrder.ReferenceId;
if (!string.IsNullOrWhiteSpace(referenceId) && Guid.TryParse(referenceId, out var vendrOrderId))
{
OrderReadOnly vendrOrder = Vendr.Services.OrderService.GetOrder(vendrOrderId);
return(vendrOrder.GenerateOrderReference());
}
}
}
catch (Exception ex)
{
Vendr.Log.Error <SquareCheckoutOnetimePaymentProvider>(ex, "Square - GetOrderReference");
}
}
return(base.GetOrderReference(request, settings));
}
public override ApiResult FetchPaymentStatus(OrderReadOnly order, StripeCheckoutOneTimeSettings settings)
{
try
{
var secretKey = settings.TestMode ? settings.TestSecretKey : settings.LiveSecretKey;
ConfigureStripe(secretKey);
// See if we have a payment intent to work from
var paymentIntentId = order.Properties["stripePaymentIntentId"];
if (!string.IsNullOrWhiteSpace(paymentIntentId))
{
var paymentIntentService = new PaymentIntentService();
var paymentIntent = paymentIntentService.Get(paymentIntentId);
return(new ApiResult()
{
TransactionInfo = new TransactionInfoUpdate()
{
TransactionId = GetTransactionId(paymentIntent),
PaymentStatus = GetPaymentStatus(paymentIntent)
}
});
}
// No payment intent, so look for a charge
var chargeId = order.Properties["stripeChargeId"];
if (!string.IsNullOrWhiteSpace(chargeId))
{
var chargeService = new ChargeService();
var charge = chargeService.Get(chargeId);
return(new ApiResult()
{
TransactionInfo = new TransactionInfoUpdate()
{
TransactionId = GetTransactionId(charge),
PaymentStatus = GetPaymentStatus(charge)
}
});
}
}
catch (Exception ex)
{
Vendr.Log.Error <StripeCheckoutOneTimePaymentProvider>(ex, "Stripe - FetchPaymentStatus");
}
return(ApiResult.Empty);
}
