public PaymentRequest CreatePaymentRequest(OrderInfo orderInfo)
{
var paymentProvider = PaymentProvider.GetPaymentProvider(orderInfo.PaymentInfo.Id, orderInfo.StoreInfo.Alias);
var partnerId = paymentProvider.GetSetting("PartnerId");
var returnUrl = paymentProvider.SuccessUrl();
var reportUrl = paymentProvider.ReportUrl();
var testMode = paymentProvider.TestMode;
var idealFetch = new IdealFetch(partnerId, testMode, orderInfo.OrderNumber, reportUrl, returnUrl, orderInfo.PaymentInfo.MethodId, orderInfo.ChargedAmount);
if (idealFetch.Error)
{
Log.Instance.LogError("Mollie PaymentRequestHandler.CreatePaymentRequest: idealFetch.Error: " + idealFetch.ErrorMessage);
return(null);
}
var transactionId = idealFetch.TransactionId;
orderInfo.PaymentInfo.Url = idealFetch.Url;
PaymentProviderHelper.SetTransactionId(orderInfo, transactionId);
return(new PaymentRequest());
}
public async Task <IViewComponentResult> InvokeAsync()
{
var cashfreeProvider = await _paymentProviderRepository.Query().FirstOrDefaultAsync(x => x.Id == PaymentProviderHelper.CashfreeProviderId);
var cashfreeSetting = JsonConvert.DeserializeObject <CashfreeConfigForm>(cashfreeProvider.AdditionalSettings);
var currentUser = await _workContext.GetCurrentUser();
var cart = await _cartService.GetActiveCartDetails(currentUser.Id);
var amount = String.Format("{0:.##}", cart.OrderTotal);
var orderId = DateTime.Today.ToString("ddMMyyyy") + "_" + cart.Id;
var message = "appId=" + cashfreeSetting.AppId + "&orderId=" + orderId + "&orderAmount=" + amount + "&returnUrl=" + cashfreeSetting.ReturnURL + "&paymentModes=" + cashfreeSetting.PaymentModes;
var paymentToken = PaymentProviderHelper.GetToken(message, cashfreeSetting.SecretKey);
var model = new CashfreeCheckoutForm
{
AppId = cashfreeSetting.AppId,
PaymentToken = paymentToken,
OrderId = orderId,
OrderAmount = amount,
CustomerName = currentUser.FullName,
CustomerEmail = currentUser.Email,
CustomerPhone = string.IsNullOrWhiteSpace(currentUser.PhoneNumber) ? "1234567890" : currentUser.PhoneNumber, // Phone number is mandatory for Cashfree payment
Mode = cashfreeSetting.IsSandbox ? "TEST" : "PROD",
ReturnURL = cashfreeSetting.ReturnURL,
NotifyURL = cashfreeSetting.NotifyURL
};
return(View(this.GetViewPath(), model));
}
/// <summary>
/// Gets the payment providers.
/// </summary>
/// <param name="useZone">if set to <c>true</c> [use zone].</param>
/// <param name="storeAlias">The store alias.</param>
/// <param name="currencyCode">The currency code.</param>
/// <returns></returns>
public static IEnumerable <IBillingProvider> GetPaymentProviders(bool useZone = true, string storeAlias = null, string currencyCode = null)
{
var localization = StoreHelper.GetLocalizationOrCurrent(storeAlias, currencyCode);
var inclVat = IO.Container.Resolve <ISettingsService>().IncludingVat;
return(PaymentProviderHelper.GetBillingProvidersForOrder(OrderHelper.GetOrder(), useZone, storeAlias, currencyCode).Select(s => new BillingFulfillmentAdaptor(s, inclVat, localization)));
}
/// <summary>
/// Gets the payment providers for a given country
/// </summary>
/// <param name="countryCode">the code of the country</param>
/// <param name="storeAlias">The store alias.</param>
/// <param name="currencyCode">The currency code.</param>
/// <returns></returns>
public static IEnumerable <IBillingProvider> GetPaymentProvidersForCountry(string countryCode, string storeAlias = null, string currencyCode = null)
{
var localization = StoreHelper.GetLocalizationOrCurrent(storeAlias, currencyCode);
var inclVat = IO.Container.Resolve <ISettingsService>().IncludingVat;
return(PaymentProviderHelper.GetAllPaymentProviders(storeAlias, currencyCode).Where(x => x.Zones.Any(y => y.CountryCodes.Contains(countryCode))).Select(p => new BillingFulfillmentAdaptor(p, inclVat, localization)));
}
/// <summary>
/// Creates a payment request for this payment provider
/// </summary>
/// <param name="orderInfo"> </param>
/// <returns>Payment request</returns>
public PaymentRequest CreatePaymentRequest(OrderInfo orderInfo)
{
var paymentProvider = PaymentProvider.GetPaymentProvider(orderInfo.PaymentInfo.Id, orderInfo.StoreInfo.Alias);
#region build urls
var returnUrl = paymentProvider.SuccessUrl();
var reportUrl = paymentProvider.ReportUrl();
var testMode = paymentProvider.TestMode; //currently we don't have a testmode for easy-ideal this var is unused
#endregion
#region config helper
var merchantId = paymentProvider.GetSetting("merchantId");
var merchantKey = paymentProvider.GetSetting("merchantKey");
var merchantSecret = paymentProvider.GetSetting("merchantSecret");
var url = paymentProvider.GetSetting("url");
#endregion
var args = new SortedList <string, string>();
var ci = new CultureInfo("en-US");
args.Add("Amount", orderInfo.ChargedAmount.ToString("G", ci));
args.Add("Currency", "EUR");
args.Add("Bank", orderInfo.PaymentInfo.MethodId);
args.Add("Description", orderInfo.OrderNumber);
args.Add("Return", reportUrl);
var xmlRequest = GetXml(IDEAL_EXECUTE, args, merchantId, merchantKey, merchantSecret);
XDocument xmlResponse = XDocument.Parse(PostXml(xmlRequest, url));
var responseStatus = xmlResponse.Element("Response").Element("Status").FirstNode.ToString();
var transactionId = xmlResponse.Element("Response").Element("Response").Element("TransactionID").FirstNode.ToString();
var transactionCode = xmlResponse.Element("Response").Element("Response").Element("Code").FirstNode.ToString();
var bankUrl = HttpUtility.HtmlDecode(xmlResponse.Element("Response").Element("Response").Element("BankURL").FirstNode.ToString());
orderInfo.PaymentInfo.Url = bankUrl;
PaymentProviderHelper.SetTransactionId(orderInfo, transactionId); //transactionCode hierin verwerken??
//IO.Container.Resolve<IOrderUpdatingService>().AddCustomerFields(order, new Dictionary<string, string>({ "extraBilling", value }), CustomerDatatypes.Extra);
orderInfo.AddCustomerFields(new Dictionary <string, string> {
{ "extraTransactionCode", transactionCode }
}, Common.CustomerDatatypes.Extra);
orderInfo.Save();
return(new PaymentRequest());
}
/// <summary>
/// Gets the payment providers for the given basket
/// </summary>
/// <param name="order">the order to match the payment providers with</param>
/// <param name="useZone">if set to <c>true</c> [use zone].</param>
/// <param name="storeAlias">The store alias.</param>
/// <param name="currencyCode">The currency code.</param>
/// <returns></returns>
public static IEnumerable <IBillingProvider> GetPaymentProvidersForOrder(IBasket order, bool useZone = true,
string storeAlias = null, string currencyCode = null)
{
var orderInfo = Basket.GetOrderInfoFromOrderBasket(order);
var localization = StoreHelper.GetLocalizationOrCurrent(storeAlias, currencyCode);
return
(PaymentProviderHelper.GetBillingProvidersForOrder(orderInfo, useZone, storeAlias, currencyCode)
.Select(s => new BillingFulfillmentAdaptor(s, orderInfo.PricesAreIncludingVAT, localization)));
}
public List <OrderValidationError> ValidatePayment(OrderInfo orderInfo)
{
try
{
if (orderInfo == null)
{
throw new ArgumentNullException("orderInfo", "Geen order?!");
}
if (orderInfo.PaymentInfo == null)
{
throw new NullReferenceException("orderInfo.PaymentInfo");
}
var errors = new List <OrderValidationError>();
if (orderInfo.PaymentInfo.Id != 0)
{
var paymentProvider = PaymentProvider.GetPaymentProvider(orderInfo.PaymentInfo.Id);
if (paymentProvider == null)
{
throw new NullReferenceException("paymentProvider");
}
if (paymentProvider.Zones == null)
{
throw new NullReferenceException("paymentProvider.Zones");
}
if ((paymentProvider.Type != PaymentProviderType.OfflinePaymentAtCustomer && paymentProvider.Type != PaymentProviderType.OfflinePaymentInStore) && !paymentProvider.Zones.SelectMany(x => x.CountryCodes).Contains(orderInfo.CustomerInfo.CountryCode))
{
// country code for customer does not match zones for payment provider.
Log.Instance.LogWarning("ORDERVALIDATIONERROR: CUSTOMER COUNTRY DOES NOT MATCH PAYMENT PROVIDER");
errors.Add(new OrderValidationError {
Id = orderInfo.PaymentInfo.Id, Key = "ValidationCustomerCountryPaymentProviderMismatch", Value = "The Customer Country Does Not Match Countries Allowed For The Chosen Payment Provider"
});
}
errors.AddRange(PaymentProviderHelper.GetPaymentValidationResults(orderInfo).Where(e => e.Id == orderInfo.PaymentInfo.Id));
}
if (orderInfo.ConfirmValidationFailed && (orderInfo.PaymentInfo.Id == 0 && PaymentProviderHelper.GetPaymentProvidersForOrder(orderInfo).Count > 0))
{
Log.Instance.LogWarning("ORDERVALIDATIONERROR: PAYMENT PROVIDERS AVAILABLE BUT NOT CHOSEN");
errors.Add(new OrderValidationError {
Id = 0, Key = "ValidationNoPaymentProviderChosen", Value = "No Payment Provider Chosen"
});
}
return(errors);
}
catch (Exception)
{
return(new List <OrderValidationError>());
}
}
public ProviderActionResult AddPaymentProvider(OrderInfo order, int paymentProviderId, string paymentProviderMethodId, ILocalization store)
{
if (ChangeOrderToIncompleteAndReturnTrueIfNotAllowed(order))
{
return(ProviderActionResult.NotPermitted);
}
if (paymentProviderId == 0)
{
Log.Instance.LogError("AddPaymentProvider AddPaymentMethod ProviderActionResult.ProviderIdZero");
return(ProviderActionResult.ProviderIdZero);
}
var paymentProvider = PaymentProviderHelper.GetPaymentProvidersForOrder(order).SingleOrDefault(x => x.Id == paymentProviderId);
if (paymentProvider == null)
{
Log.Instance.LogError("AddPaymentProvider AddPaymentMethod paymentProvider == null");
return(ProviderActionResult.NoCorrectInput);
}
order.PaymentInfo.Id = paymentProviderId;
order.PaymentInfo.Title = paymentProvider.Title;
order.PaymentInfo.PaymentType = paymentProvider.Type;
var paymentMethod = paymentProvider.PaymentProviderMethods.SingleOrDefault(x => x.Id == paymentProviderMethodId);
if (paymentMethod == null)
{
Log.Instance.LogError("AddPaymentProvider AddPaymentMethod paymentMethod == null");
return(ProviderActionResult.NoCorrectInput);
}
order.PaymentInfo.MethodId = paymentProviderMethodId;
order.PaymentInfo.MethodTitle = paymentMethod.Title;
if (paymentMethod.AmountType == PaymentProviderAmountType.Amount)
{
order.PaymentProviderAmount = paymentMethod.PriceInCents;
}
else
{
order.PaymentProviderOrderPercentage = paymentMethod.PriceInCents;
}
order.ResetDiscounts();
return(ProviderActionResult.Success);
}
public PaymentRequest CreatePaymentRequest(OrderInfo orderInfo)
{
var paymentProvider = PaymentProvider.GetPaymentProvider(orderInfo.PaymentInfo.Id, orderInfo.StoreInfo.Alias);
var failedUrl = paymentProvider.ErrorUrl();
var reportUrl = paymentProvider.ReportUrl();
#region config helper
var merchantnumber = paymentProvider.GetSetting("merchantnumber");
var url = paymentProvider.GetSetting("url");
var uniqueId = orderInfo.OrderNumber + "x" + DateTime.Now.ToString("hhmmss");
Log.Instance.LogDebug("ePay uniqueId " + uniqueId + ", paymentProviderNodeId: " + paymentProvider.Id);
//<provider title="ePay">
// <merchantnumber>#YOUR Merchant Number#</accountId>
// <url>https://ssl.ditonlinebetalingssystem.dk/integration/ewindow/Default.aspx</url>
//</provider>
#endregion
var request = new PaymentRequest();
// retrieve Account ID
request.Parameters.Add("merchantnumber", merchantnumber);
request.Parameters.Add("amount", orderInfo.ChargedAmountInCents.ToString());
request.Parameters.Add("orderid", uniqueId);
request.Parameters.Add("callbackurl", reportUrl);
request.Parameters.Add("accepturl", reportUrl);
request.Parameters.Add("cancelurl", failedUrl);
request.Parameters.Add("currency", orderInfo.StoreInfo.Store.CurrencyCultureSymbol);
request.Parameters.Add("windowstate", "3");
request.PaymentUrlBase = url;
PaymentProviderHelper.SetTransactionId(orderInfo, uniqueId);
orderInfo.PaymentInfo.Url = request.PaymentUrl;
orderInfo.PaymentInfo.Parameters = request.ParametersAsString;
return(request);
}
public PaymentRequest CreatePaymentRequest(OrderInfo orderInfo)
{
var uniqueId = orderInfo.OrderNumber + "x" + DateTime.Now.ToString("hhmmss");
uniqueId = (uniqueId.Length > 12) ? uniqueId.Substring(0, 12) : uniqueId.PadRight(12, '0');
var request = new PaymentRequest();
PaymentProviderHelper.SetTransactionId(orderInfo, uniqueId);
HttpContext.Current.Session.Add("TransactionId", uniqueId);
orderInfo.PaymentInfo.Url = request.PaymentUrl;
orderInfo.PaymentInfo.Parameters = request.ParametersAsString;
orderInfo.Save();
return(request);
}
public PaymentRequest CreatePaymentRequest(OrderInfo orderInfo)
{
var paymentProvider = PaymentProvider.GetPaymentProvider(orderInfo.PaymentInfo.Id, orderInfo.StoreInfo.Alias);
var liveUrl = "https://checkout.buckaroo.nl/nvp/";
var testUrl = "https://testcheckout.buckaroo.nl/nvp/";
var configLiveUrl = paymentProvider.GetSetting("Url");
var configTestUrl = paymentProvider.GetSetting("testUrl");
var lowercaseUrls = paymentProvider.GetSetting("LowercaseUrls");
var trailingSlash = paymentProvider.GetSetting("AddTrailingSlash");
var lowercase = false;
var addslash = false;
if (!string.IsNullOrEmpty(lowercaseUrls))
{
if (lowercaseUrls == "true" || lowercaseUrls == "1" || lowercaseUrls == "on")
{
lowercase = true;
}
}
if (!string.IsNullOrEmpty(trailingSlash))
{
if (trailingSlash == "true" || trailingSlash == "1" || trailingSlash == "on")
{
addslash = true;
}
}
if (!string.IsNullOrEmpty(configLiveUrl))
{
liveUrl = configLiveUrl;
}
if (!string.IsNullOrEmpty(configTestUrl))
{
testUrl = configTestUrl;
}
var url = paymentProvider.TestMode ? testUrl : liveUrl;
var providerSettingsXML = paymentProvider.GetSettingsXML();
var service = orderInfo.PaymentInfo.MethodId;
string issuer = null;
var issuerElement = providerSettingsXML.Descendants().FirstOrDefault(x => x.Value.ToLowerInvariant() == orderInfo.PaymentInfo.MethodId.ToLowerInvariant());
if (issuerElement != null)
{
issuer = issuerElement.Value;
if (issuerElement.Name.LocalName.ToLowerInvariant() != "issuer")
{
var firstOrDefault = issuerElement.AncestorsAndSelf("Service").FirstOrDefault();
if (firstOrDefault != null)
{
service = firstOrDefault.Attribute("name").Value;
}
}
}
var reportUrl = paymentProvider.ReportUrl();
if (lowercase)
{
reportUrl = reportUrl.ToLowerInvariant();
}
if (!reportUrl.EndsWith("/") && addslash)
{
reportUrl = reportUrl + "/";
}
BuckarooRequestParameters requestParams = new BuckarooRequestParameters(paymentProvider.GetSetting("SecretKey"));
requestParams.Amount = orderInfo.ChargedAmountInCents / 100m;
requestParams.Culture = System.Threading.Thread.CurrentThread.CurrentCulture.Name;
requestParams.Currency = orderInfo.StoreInfo.Store.CurrencyCultureSymbol;
requestParams.InvoiceNumber = orderInfo.OrderNumber;
requestParams.PaymentMethod = service;
requestParams.ReturnUrl = reportUrl;
requestParams.ReturnCancelUrl = reportUrl;
requestParams.ReturnErrorUrl = reportUrl;
requestParams.ReturnReject = reportUrl;
requestParams.WebsiteKey = paymentProvider.GetSetting("Websitekey");
var transactionId = orderInfo.UniqueOrderId.ToString();
requestParams.TransactionId = transactionId;
string IssuersServiceKeyName = null;
string IssuerServiceKeyValue = null;
string IssuerActionKeyName = null;
string IssuerActionKeyValue = null;
if (!string.IsNullOrEmpty(issuer))
{
IssuersServiceKeyName = string.Format("brq_service_{0}_issuer", service);
IssuerServiceKeyValue = issuer;
IssuerActionKeyName = string.Format("brq_service_{0}_action", service);
IssuerActionKeyValue = "Pay";
requestParams.AddCustomParameter(IssuersServiceKeyName, IssuerServiceKeyValue);
requestParams.AddCustomParameter(IssuerActionKeyName, IssuerActionKeyValue);
}
if (service.Equals("transfer"))
{
requestParams.AddCustomParameter("brq_service_transfer_customeremail", orderInfo.CustomerEmail);
requestParams.AddCustomParameter("brq_service_transfer_customerfirstname", orderInfo.CustomerFirstName);
requestParams.AddCustomParameter("brq_service_transfer_customerlastname", orderInfo.CustomerLastName);
}
if (service.Equals("onlinegiro"))
{
requestParams.AddCustomParameter("brq_service_onlinegiro_customergender", "9");
requestParams.AddCustomParameter("brq_service_onlinegiro_customeremail", orderInfo.CustomerEmail);
requestParams.AddCustomParameter("brq_service_onlinegiro_customerfirstname", orderInfo.CustomerFirstName);
requestParams.AddCustomParameter("brq_service_onlinegiro_customerlastname", orderInfo.CustomerLastName);
}
requestParams.Sign();
var request = new PaymentRequest();
//request.Parameters.Add("add_transactionReference", Add_transactionReference);
//request.Parameters.Add("brq_amount", Brq_amount);
//request.Parameters.Add("brq_currency", Brq_currency);
//request.Parameters.Add("brq_invoicenumber", Brq_invoicenumber);
//request.Parameters.Add("brq_payment_method", Brq_payment_method);
//request.Parameters.Add("brq_return", Brq_return);
//request.Parameters.Add("brq_returncancel", Brq_returncancel);
//request.Parameters.Add("brq_returnerror", Brq_returnerror);
//request.Parameters.Add("brq_returnreject", Brq_returnreject);
//if (!string.IsNullOrEmpty(issuer))
//{
// request.Parameters.Add(IssuerActionKeyName, IssuerActionKeyValue);
// request.Parameters.Add(IssuersServiceKeyName, IssuerServiceKeyValue);
//}
//request.Parameters.Add("brq_websitekey", Brq_websitekey);
//request.Parameters.Add("brq_signature", Brq_signature);
request.Parameters = requestParams.GetParameters();
var uri = new Uri(url);
var webrequest = WebRequest.Create(uri);
var encoding = new UTF8Encoding();
var requestData = encoding.GetBytes(request.ParametersAsString);
webrequest.ContentType = "application/x-www-form-urlencoded";
webrequest.Method = "POST";
webrequest.ContentLength = requestData.Length;
using (var stream = webrequest.GetRequestStream())
{
stream.Write(requestData, 0, requestData.Length);
}
using (var response = webrequest.GetResponse())
{
var stream = response.GetResponseStream();
if (stream == null)
{
throw new Exception("No response from POST request to " + url);
}
using (var reader = new StreamReader(stream, Encoding.ASCII))
{
var value = reader.ReadToEnd();
var result = HttpUtility.ParseQueryString(value);
orderInfo.PaymentInfo.Url = result["brq_redirecturl"];
if (service == "onlinegiro" || service == "transfer")
{
orderInfo.PaymentInfo.Url = reportUrl + "?" + value;
}
}
}
PaymentProviderHelper.SetTransactionId(orderInfo, transactionId);
return(request);
}
public PaymentRequest CreatePaymentRequest(OrderInfo orderInfo)
{
var paymentProvider = PaymentProvider.GetPaymentProvider(orderInfo.PaymentInfo.Id, orderInfo.StoreInfo.Alias);
var returnUrl = paymentProvider.SuccessUrl();
var cancelUrl = paymentProvider.ErrorUrl();
var reportUrl = paymentProvider.ReportUrl();
#region config helper
var apiURL = "https://www.sisow.nl/Sisow/iDeal/RestHandler.ashx/TransactionRequest";
var transactionUrl = paymentProvider.GetSetting("TransactionRequestUrl");
if (!string.IsNullOrEmpty(transactionUrl))
{
apiURL = paymentProvider.GetSetting("TransactionRequestUrl");
}
var merchantId = paymentProvider.GetSetting("merchantid");
var merchantKey = paymentProvider.GetSetting("merchantkey");
#endregion
var request = new PaymentRequest();
var orderGuidAsString = orderInfo.UniqueOrderId.ToString();
var transactionId = orderGuidAsString.Substring(0, 16);
request.Parameters.Add("shopid", "001");
request.Parameters.Add("merchantid", merchantId);
request.Parameters.Add("payment", string.Empty);
// character purchase ID (max 16 characters)
request.Parameters.Add("purchaseid", transactionId);
var totalAmountInCents = orderInfo.ChargedAmountInCents;
request.Parameters.Add("amount", totalAmountInCents.ToString());
request.Parameters.Add("issuerid", orderInfo.PaymentInfo.MethodId);
request.Parameters.Add("testmode", paymentProvider.TestMode.ToString());
request.Parameters.Add("entrancecode", orderInfo.OrderNodeId.ToString());
request.Parameters.Add("description", orderInfo.OrderNumber);
request.Parameters.Add("returnurl", returnUrl);
request.Parameters.Add("cancelurl", cancelUrl);
request.Parameters.Add("callbackurl", reportUrl);
request.Parameters.Add("notifyurl", reportUrl);
#region esend
//request.Parameters.Add("shipping_firstname", "#todo - optional");
//request.Parameters.Add("shipping_lastname", "#todo");
//request.Parameters.Add("shipping_mail", "#todo - optional");
//request.Parameters.Add("shipping_company", "#todo - optional");
//request.Parameters.Add("shipping_address1", "#todo");
//request.Parameters.Add("shipping_address2", "#todo - optional");
//request.Parameters.Add("shipping_zip", "#todo");
//request.Parameters.Add("shipping_city", "#todo");
//request.Parameters.Add("shipping_country", "#todo");
//request.Parameters.Add("shipping_countrycode", "#todo");
//request.Parameters.Add("shipping_phone", "#todo -optional");
//request.Parameters.Add("weight", "#todo -optional");
//request.Parameters.Add("shipping", "#todo -optional");
//request.Parameters.Add("handling", "#todo -optional");
#endregion
//de SHA1 waarde van purchaseid/entrancecode/amount/shopid/merchantid/merchantkey
var sha1Hash = GetSHA1(transactionId + orderInfo.OrderNodeId.ToString() + totalAmountInCents.ToString() + "001" + merchantId + merchantKey);
request.Parameters.Add("sha1", sha1Hash);
request.PaymentUrlBase = apiURL;
var responseString = _requestSender.SendRequest(request.PaymentUrlBase, request.ParametersAsString);
XNamespace ns = "https://www.sisow.nl/Sisow/REST";
if (responseString == null)
{
Log.Instance.LogError("SiSow responseString == null orderInfo.UniqueOrderId: " + orderInfo.UniqueOrderId);
return(null);
}
Log.Instance.LogDebug("SiSow responseString: " + responseString + ", paymentProviderNodeId: " + paymentProvider.Id);
var issuerXml = XDocument.Parse(responseString);
var url = issuerXml.Descendants(ns + "issuerurl").FirstOrDefault();
var trxId = issuerXml.Descendants(ns + "trxid").FirstOrDefault();
var decodeUrl = Uri.UnescapeDataString(url.Value);
if (trxId == null)
{
Log.Instance.LogError("SiSow issuerXml: " + issuerXml + ", paymentProviderNodeId: " + paymentProvider.Id);
return(null);
}
var returnedTransactionId = trxId.Value;
orderInfo.PaymentInfo.Url = decodeUrl;
orderInfo.PaymentInfo.TransactionId = returnedTransactionId;
PaymentProviderHelper.SetTransactionId(orderInfo, returnedTransactionId);
orderInfo.Save();
return(null);
}
/// <summary>
/// Executes the transaction request to SagePay
/// </summary>
/// <param name="orderInfo"></param>
/// <returns></returns>
public PaymentRequest CreatePaymentRequest(OrderInfo orderInfo)
{
var paymentProvider = PaymentProvider.GetPaymentProvider(orderInfo.PaymentInfo.Id);
var sagePayDirectIntegration = new SagePayDirectIntegration();
var request = sagePayDirectIntegration.DirectPaymentRequest();
SetRequestData(request, orderInfo);
var result = sagePayDirectIntegration.ProcessDirectPaymentRequest(request, SagePaySettings.DirectPaymentUrl);
if (result.Status == ResponseStatus.OK || (SagePaySettings.DefaultTransactionType == TransactionType.AUTHENTICATE && result.Status == ResponseStatus.REGISTERED))
{
orderInfo.PaymentInfo.Parameters = result.Status + "&" + result.StatusDetail;
PaymentProviderHelper.SetTransactionId(orderInfo, result.VpsTxId);
//Response.Redirect(string.Format("Result.aspx?vendorTxCode={0}", request.VendorTxCode));
}
else if (result.Status == ResponseStatus.THREEDAUTH)
{
// todo: not supported yet! code below is work in progress
//var threeDSecureRequest = new PaymentRequest();
//threeDSecureRequest.Parameters.Add("paReq", result.PaReq.Replace(" ", "+"));
//threeDSecureRequest.Parameters.Add("acsUrl", result.AcsUrl);
//threeDSecureRequest.Parameters.Add("md", result.Md);
//threeDSecureRequest.Parameters.Add("vendorTxCode", request.VendorTxCode);
//// Save Order with Order status in 3D Process
//var threeDAuth = new NameValueCollection
//{
// {"paReq", result.PaReq.Replace(" ", "+")},
// {"acsUrl", result.AcsUrl},
// {"md", result.Md},
// {"vendorTxCode", request.VendorTxCode}
//};
//if (HttpContext.Current.Session["USER_3DAUTH"] != null)
//{
// HttpContext.Current.Session["USER_3DAUTH"] = null;
//}
//HttpContext.Current.Session.Add("USER_3DAUTH", threeDAuth);
////<form action="<%= ACSUrl %>" method="post">
////<input type="hidden" name="PaReq" value="<%= PaReq %>" />
////<input type="hidden" name="TermUrl" value="<%= TermUrl %>" />
////<input type="hidden" name="MD" value="<%= MD %>" />
////<input type="submit" value="Go" />
////</form>
//var responseString = _requestSender.SendRequest(result.AcsUrl, threeDSecureRequest.ParametersAsString);
//var threeDAuthRequest = sagePayDirectIntegration.ThreeDAuthRequest();
//threeDAuthRequest.Md = Request.Form["MD"];
//threeDAuthRequest.PaRes = Request.Form["PaRes"];
//var directPaymentResult = sagePayDirectIntegration.ProcessDirect3D(threeDAuthRequest);
//if (directPaymentResult.Status == ResponseStatus.OK)
//{
// orderInfo.Paid = true;
// orderInfo.Status = OrderStatus.ReadyForDispatch;
//}
//else
//{
// Log.Instance.LogError("SagePay Did not return a proper directPaymentResult status: " + directPaymentResult.StatusDetail);
// PaymentProviderHelper.AddValidationResult(orderInfo, orderInfo.PaymentInfo.Id, "SagePayReturnedError", directPaymentResult.StatusDetail);
//}
}
else
{
Log.Instance.LogError("SagePay Did not return a proper status: " + result.StatusDetail);
PaymentProviderHelper.AddValidationResult(orderInfo, orderInfo.PaymentInfo.Id, "SagePayReturnedError", result.StatusDetail);
}
orderInfo.Save();
return(new PaymentRequest());
}
public PaymentRequest CreatePaymentRequest(OrderInfo orderInfo)
{
var paymentProvider = PaymentProvider.GetPaymentProvider(orderInfo.PaymentInfo.Id, orderInfo.StoreInfo.Alias);
var reportUrl = paymentProvider.ReportUrl();
var pspId = paymentProvider.GetSetting("PSPID");
var shaInSignature = paymentProvider.GetSetting("SHAInSignature");
var secureHashAlgorithm = paymentProvider.GetSetting("SecureHashAlgorithm");
var liveUrl = "https://secure.ogone.com/ncol/prod/orderstandard.asp";
var testUrl = "https://secure.ogone.com/ncol/test/orderstandard.asp";
var configLiveUrl = paymentProvider.GetSetting("Url");
var configTestUrl = paymentProvider.GetSetting("testUrl");
if (!string.IsNullOrEmpty(configLiveUrl))
{
liveUrl = configLiveUrl;
}
if (!string.IsNullOrEmpty(configTestUrl))
{
testUrl = configTestUrl;
}
var url = paymentProvider.TestMode ? testUrl : liveUrl;
var request = new PaymentRequest();
request.Parameters.Add("PSPID", pspId);
request.Parameters.Add("ORDERID", orderInfo.OrderNumber);
var amount = orderInfo.ChargedAmountInCents;
request.Parameters.Add("AMOUNT", amount.ToString());
request.Parameters.Add("CURRENCY", orderInfo.StoreInfo.Store.CurrencyCultureSymbol);
request.Parameters.Add("LANGUAGE", orderInfo.StoreInfo.LanguageCode + "_" + orderInfo.StoreInfo.CountryCode);
request.Parameters.Add("EMAIL", OrderHelper.CustomerInformationValue(orderInfo, "customerEmail"));
request.Parameters.Add("ACCEPTURL", reportUrl);
request.Parameters.Add("DECLINEURL", reportUrl);
request.Parameters.Add("EXCEPTIONURL", reportUrl);
request.Parameters.Add("CANCELURL", reportUrl);
//action => 'Normal Authorization' (with operation => 'SAL' (default))
//action => 'Authorization Only' (with operation => 'RES' (default)) then action => 'Post Authorization' (with operation => 'SAS' (default))
request.Parameters.Add("OPERATION", "SAL");
var transactionId = orderInfo.UniqueOrderId.ToString().Replace("-", "");
request.Parameters.Add("PARAMPLUS", string.Format("TransactionId={0}", transactionId));
if (orderInfo.PaymentInfo.MethodId.Contains('-'))
{
var splitarray = orderInfo.PaymentInfo.MethodId.Split('-');
var pm = splitarray[0];
var brand = splitarray[1];
request.Parameters.Add("PM", pm);
request.Parameters.Add("BRAND", brand);
}
else
{
request.Parameters.Add("PM", orderInfo.PaymentInfo.MethodTitle);
}
var stringToHash = string.Empty;
var sortedParameters = request.Parameters.OrderBy(x => x.Key);
foreach (var parameter in sortedParameters)
{
stringToHash += string.Format("{0}={1}{2}", parameter.Key, parameter.Value, shaInSignature);
}
switch (secureHashAlgorithm)
{
case "SHA1":
request.Parameters.Add("SHASIGN", GetSHA1Hash(stringToHash).ToUpper());
break;
case "SHA256":
request.Parameters.Add("SHASIGN", GetSHA256Hash(stringToHash).ToUpper());
break;
case "SHA512":
request.Parameters.Add("SHASIGN", GetSHA512Hash(stringToHash).ToUpper());
break;
}
request.PaymentUrlBase = url;
orderInfo.PaymentInfo.Url = request.PaymentUrl;
orderInfo.PaymentInfo.Parameters = request.ParametersAsString;
PaymentProviderHelper.SetTransactionId(orderInfo, transactionId);
return(request);
}
/// <summary>
/// Creates a payment request for this payment provider
/// </summary>
/// <param name="orderInfo"> </param>
/// <returns>Payment request</returns>
public PaymentRequest CreatePaymentRequest(OrderInfo orderInfo)
{
var paymentProvider = PaymentProvider.GetPaymentProvider(orderInfo.PaymentInfo.Id, orderInfo.StoreInfo.Alias);
#region build urls
var baseUrl = PaymentProviderHelper.GenerateBaseUrl();
var returnUrl = paymentProvider.SuccessUrl();
var reportUrl = paymentProvider.ReportUrl();
#endregion
#region config helper
var accountId = paymentProvider.GetSetting("AccountId");
var liveUrl = "https://www.paypal.com/cgi-bin/webscr";
var testUrl = "https://www.sandbox.paypal.com/us/cgi-bin/webscr";
var configLiveUrl = paymentProvider.GetSetting("Url");
var configTestUrl = paymentProvider.GetSetting("testUrl");
if (!string.IsNullOrEmpty(configLiveUrl))
{
liveUrl = configLiveUrl;
}
if (!string.IsNullOrEmpty(configTestUrl))
{
testUrl = configTestUrl;
}
#endregion
var trasactionId = orderInfo.OrderNumber + "x" + DateTime.Now.ToString("hhmmss");
var request = new PaymentRequest();
request.Parameters.Add("cmd", "_xclick");
// retrieve Account ID
request.Parameters.Add("business", accountId);
//request.Parameters.Add("invoice", order.OrderInfo.OrderNumber.ToString());
request.Parameters.Add("invoice", orderInfo.OrderNumber);
var ci = new CultureInfo("en-US");
var totalAmountAsString = orderInfo.ChargedAmount.ToString("N", ci);
request.Parameters.Add("amount", totalAmountAsString);
request.Parameters.Add("tax_cart", totalAmountAsString);
request.Parameters.Add("no_note", "0");
var ri = new RegionInfo(orderInfo.StoreInfo.Store.CurrencyCultureInfo.LCID);
request.Parameters.Add("currency_code", ri.ISOCurrencySymbol);
request.Parameters.Add("lc", orderInfo.StoreInfo.CultureInfo.TwoLetterISOLanguageName);
request.Parameters.Add("return", returnUrl);
request.Parameters.Add("shopping_url", baseUrl);
request.Parameters.Add("notify_url", reportUrl);
#region testmode
if (paymentProvider.TestMode)
{
request.Parameters.Add("cn", "Test");
}
#endregion
// Order as shown with PayPal
request.Parameters.Add("item_name", orderInfo.OrderNumber);
// Set GUID to identify order in SSWS
// Sent GUID for identification to PayPal
// PayPal will return custom value to validate order
request.Parameters.Add("custom", trasactionId);
// check if provider is in testmode to send request to right URL
request.PaymentUrlBase = paymentProvider.TestMode ? testUrl : liveUrl;
PaymentProviderHelper.SetTransactionId(orderInfo, trasactionId);
orderInfo.PaymentInfo.Url = request.PaymentUrl;
orderInfo.PaymentInfo.Parameters = request.ParametersAsString;
return(request);
}
public PaymentRequest CreatePaymentRequest(OrderInfo orderInfo)
{
// reportUrl - is a server-to-server call, changes order state, sends out e-mail
// successUrl - is a browser redirect, page is shown to card holder after payment success, this is where you show a receipt
// errorUrl - is a browser redirect, page is shown to card holder if a payment error occured
//
// parameters http://tech.epay.dk/da/betalingsvindue-parametre
//
// payment provider configuration is made in ~\App_Plugins\uWebshop\config\PaymentProviders.config
// example:
// <provider title="ePay">
// <merchantnumber>12345678</merchantnumber>
// <url>https://ssl.ditonlinebetalingssystem.dk/integration/ewindow/Default.aspx</url>
// ..
// <secret>xc78ekjY3H!K</secret>
// <language>0</language>
// </provider>
var paymentProvider = PaymentProvider.GetPaymentProvider(orderInfo.PaymentInfo.Id, orderInfo.StoreInfo.Alias);
var request = new PaymentRequest();
request.Parameters.Add("currency", orderInfo.StoreInfo.Store.CurrencyCultureSymbol);
request.Parameters.Add("amount", orderInfo.ChargedAmountInCents.ToString());
request.Parameters.Add("orderid", orderInfo.OrderNumber);
request.Parameters.Add("windowstate", "3");
request.Parameters.Add("instantcallback", "1");
request.Parameters.Add("callbackurl", paymentProvider.ReportUrl()); // server-to-server GET http://host/payment-providers/payment-providers/ePay?txnid=12345678&orderid=W0061..
request.Parameters.Add("accepturl", paymentProvider.SuccessUrl()); // browser redirect GET http://host/receipt/?txnid=12345678&orderid=W0061..
request.Parameters.Add("cancelurl", paymentProvider.ErrorUrl());
//filter params
var filter = new List <string> {
"hash", "secret", "url"
};
var settings = paymentProvider.GetSettingsXML();
foreach (var setting in settings.Descendants())
{
var key = setting.Name.LocalName.ToLowerInvariant();
if (!string.IsNullOrEmpty(setting.Value) && !request.Parameters.ContainsKey(key) && !filter.Contains(key))
{
request.Parameters.Add(key, setting.Value);
}
}
request.PaymentUrlBase = settings.Element("url").Value;
//build MD5 if secret present
if (settings.Element("secret") != null)
{
var sb = new StringBuilder();
foreach (var parameter in request.Parameters)
{
sb.Append(parameter.Value);
}
request.Parameters.Add("hash", ePayPaymentBase.MD5(sb.ToString() + settings.Element("secret").Value));
}
PaymentProviderHelper.SetTransactionId(orderInfo, orderInfo.OrderNumber);
orderInfo.PaymentInfo.Url = request.PaymentUrl;
orderInfo.PaymentInfo.Parameters = request.ParametersAsString;
return(request);
}
/// <summary>
/// Returns Payment Providers for this order
/// </summary>
/// <returns></returns>
public static List <PaymentProvider> GetPaymentProvidersForOrder(bool useCountry = true)
{
return(PaymentProviderHelper.GetPaymentProvidersForOrder(useCountry));
}
public static void OrderStatusChanged(OrderInfo orderInfo, AfterOrderStatusChangedEventArgs e)
{
Log.Instance.LogDebug("AfterOrderStatusChanged Start");
if (orderInfo == null || orderInfo.OrderLines.Count == 0)
{
return;
}
Log.Instance.LogDebug("AfterOrderStatusChanged e.OrderStatus: " + e.OrderStatus);
Log.Instance.LogDebug("AfterOrderStatusChanged e.SendEmails: " + e.SendEmails);
switch (e.OrderStatus)
{
case OrderStatus.Incomplete:
break;
case OrderStatus.Confirmed:
// copy customerdata to shipping data if there is no shippingdata on the order
OrderHelper.CopyCustomerToShipping(orderInfo);
if (orderInfo.OrderNodeId == 0)
{
if (orderInfo.CustomerInfo.CustomerInformation != null)
{
string customerEmail = null, customerFirstName = null, customerLastName = null;
foreach (var customerProperty in IO.Container.Resolve <ICMSDocumentTypeService>().GetByAlias(Order.NodeAlias).Properties.Where(x => x.Alias.StartsWith("customer")))
{
var element = orderInfo.CustomerInfo.CustomerInformation.Element(customerProperty.Alias);
if (element != null)
{
if (element.Name == "customerEmail")
{
customerEmail = element.Value;
}
else if (element.Name == "customerFirstName")
{
customerFirstName = element.Value;
}
else if (element.Name == "customerLastName")
{
customerLastName = element.Value;
}
}
}
IO.Container.Resolve <IOrderRepository>().SetCustomerInfo(orderInfo.UniqueOrderId, customerEmail, customerFirstName, customerLastName);
}
// remove guid from cookie and expire it immediately
//OrderHelper.RemoveOrderCookie(orderInfo);
// set completed order id cookie to have access to old order after payment
OrderHelper.SetCompletedOrderCookie(orderInfo);
// update stock when no payment provider is chosen
if (orderInfo.PaymentInfo.Id == 0 || orderInfo.PaymentInfo.PaymentType == PaymentProviderType.OfflinePaymentInStore || orderInfo.PaymentInfo.PaymentType == PaymentProviderType.OfflinePaymentAtCustomer || orderInfo.PaymentInfo.PaymentType == PaymentProviderType.Unknown)
{
OrderHelper.UpdateStock(orderInfo);
}
}
#region send emails
if (e.SendEmails)
{
int customerEmailNodeId;
int.TryParse(orderInfo.StoreInfo.Store.ConfirmationEmailCustomer, out customerEmailNodeId);
if (customerEmailNodeId != 0)
{
EmailHelper.SendOrderEmailCustomer(customerEmailNodeId, orderInfo);
}
int storeEmailNodeId;
int.TryParse(orderInfo.StoreInfo.Store.ConfirmationEmailStore, out storeEmailNodeId);
if (storeEmailNodeId != 0)
{
EmailHelper.SendOrderEmailStore(storeEmailNodeId, orderInfo);
}
}
else
{
Log.Instance.LogDebug("AfterOrderStatusChanged Confirmed e.SendEmails == false");
}
if (orderInfo.PaymentInfo.Id == 0 && orderInfo.Status != OrderStatus.Confirmed)
{
orderInfo.Status = OrderStatus.Confirmed;
}
if (orderInfo.PaymentInfo.PaymentType == PaymentProviderType.OfflinePaymentAtCustomer || orderInfo.PaymentInfo.PaymentType == PaymentProviderType.OfflinePaymentInStore)
{
orderInfo.Status = OrderStatus.OfflinePayment;
}
// if online payment set status to waiting for payment
if (orderInfo.PaymentInfo.PaymentType == PaymentProviderType.OnlinePayment)
{
orderInfo.Status = OrderStatus.WaitingForPayment;
if (orderInfo.PaymentInfo.TransactionMethod == PaymentTransactionMethod.Inline)
{
var paymentProvider =
PaymentProviderHelper.GetAllPaymentProviders()
.FirstOrDefault(x => x.Id == orderInfo.PaymentInfo.Id);
orderInfo = new PaymentRequestHandler().HandleuWebshopPaymentResponse(paymentProvider, orderInfo);
}
}
orderInfo.Save();
#endregion
break;
case OrderStatus.Cancelled:
// return stock
OrderHelper.ReturnStock(orderInfo);
if (e.SendEmails)
{
int customerEmailNodeId;
int.TryParse(orderInfo.StoreInfo.Store.CancelEmailCustomer, out customerEmailNodeId);
int storeEmailNodeId;
int.TryParse(orderInfo.StoreInfo.Store.CancelEmailStore, out storeEmailNodeId);
if (customerEmailNodeId != 0)
{
EmailHelper.SendOrderEmailCustomer(customerEmailNodeId, orderInfo);
}
if (storeEmailNodeId != 0)
{
EmailHelper.SendOrderEmailStore(storeEmailNodeId, orderInfo);
}
}
else
{
Log.Instance.LogDebug("AfterOrderStatusChanged Cancelled e.SendEmails == false");
}
break;
case OrderStatus.Closed:
if (e.SendEmails)
{
int customerEmailNodeId;
int.TryParse(orderInfo.StoreInfo.Store.ClosedEmailCustomer, out customerEmailNodeId);
int storeEmailNodeId;
int.TryParse(orderInfo.StoreInfo.Store.ClosedEmailStore, out storeEmailNodeId);
if (customerEmailNodeId != 0)
{
EmailHelper.SendOrderEmailCustomer(customerEmailNodeId, orderInfo);
}
if (storeEmailNodeId != 0)
{
EmailHelper.SendOrderEmailStore(storeEmailNodeId, orderInfo);
}
}
else
{
Log.Instance.LogDebug("AfterOrderStatusChanged Closed e.SendEmails == false");
}
break;
case OrderStatus.PaymentFailed:
if (e.SendEmails)
{
int customerEmailNodeId;
int.TryParse(orderInfo.StoreInfo.Store.PaymentFailedEmailCustomer, out customerEmailNodeId);
int storeEmailNodeId;
int.TryParse(orderInfo.StoreInfo.Store.PaymentFailedEmailStore, out storeEmailNodeId);
if (customerEmailNodeId != 0)
{
EmailHelper.SendOrderEmailCustomer(customerEmailNodeId, orderInfo);
}
if (storeEmailNodeId != 0)
{
EmailHelper.SendOrderEmailStore(storeEmailNodeId, orderInfo);
}
}
else
{
Log.Instance.LogDebug("AfterOrderStatusChanged PaymentFailed e.SendEmails == false");
}
break;
case OrderStatus.OfflinePayment:
OrderHelper.UpdateStock(orderInfo);
if (e.SendEmails)
{
int customerEmailNodeId;
int.TryParse(orderInfo.StoreInfo.Store.OfflinePaymentEmailCustomer, out customerEmailNodeId);
int storeEmailNodeId;
int.TryParse(orderInfo.StoreInfo.Store.OfflinePaymentEmailStore, out storeEmailNodeId);
if (customerEmailNodeId != 0)
{
EmailHelper.SendOrderEmailCustomer(customerEmailNodeId, orderInfo);
}
if (storeEmailNodeId != 0)
{
EmailHelper.SendOrderEmailStore(storeEmailNodeId, orderInfo);
}
}
else
{
Log.Instance.LogDebug("AfterOrderStatusChanged OfflinePayment e.SendEmails == false");
}
break;
case OrderStatus.Pending:
if (e.SendEmails)
{
int customerEmailNodeId;
int.TryParse(orderInfo.StoreInfo.Store.PendingEmailCustomer, out customerEmailNodeId);
int storeEmailNodeId;
int.TryParse(orderInfo.StoreInfo.Store.PendingEmailStore, out storeEmailNodeId);
if (customerEmailNodeId != 0)
{
EmailHelper.SendOrderEmailCustomer(customerEmailNodeId, orderInfo);
}
if (storeEmailNodeId != 0)
{
EmailHelper.SendOrderEmailStore(storeEmailNodeId, orderInfo);
}
}
else
{
Log.Instance.LogDebug("AfterOrderStatusChanged Pending e.SendEmails == false");
}
break;
case OrderStatus.ReadyForDispatch:
Log.Instance.LogDebug("AfterOrderStatusChanged ReadyForDispatch orderInfo.PaymentInfo.PaymentType: " + orderInfo.PaymentInfo.PaymentType);
if (orderInfo.PaymentInfo.PaymentType == PaymentProviderType.OnlinePayment)
{
OrderHelper.UpdateStock(orderInfo);
Log.Instance.LogDebug("AfterOrderStatusChanged ReadyForDispatch after update stock");
}
Log.Instance.LogDebug("AfterOrderStatusChanged ReadyForDispatch before send emails");
if (e.SendEmails)
{
int customerEmailNodeId;
int.TryParse(orderInfo.StoreInfo.Store.OnlinePaymentEmailCustomer, out customerEmailNodeId);
int storeEmailNodeId;
int.TryParse(orderInfo.StoreInfo.Store.OnlinePaymentEmailStore, out storeEmailNodeId);
if (customerEmailNodeId != 0)
{
EmailHelper.SendOrderEmailCustomer(customerEmailNodeId, orderInfo);
}
if (storeEmailNodeId != 0)
{
EmailHelper.SendOrderEmailStore(storeEmailNodeId, orderInfo);
}
}
else
{
Log.Instance.LogDebug("AfterOrderStatusChanged ReadyForDispatch e.SendEmails == false");
}
Log.Instance.LogDebug("AfterOrderStatusChanged ReadyForDispatch after send emails");
break;
case OrderStatus.ReadyForDispatchWhenStockArrives:
if (e.SendEmails)
{
int customerEmailNodeId;
int.TryParse(orderInfo.StoreInfo.Store.TemporaryOutOfStockEmailCustomer, out customerEmailNodeId);
int storeEmailNodeId;
int.TryParse(orderInfo.StoreInfo.Store.TemporaryOutOfStockEmailStore, out storeEmailNodeId);
if (customerEmailNodeId != 0)
{
EmailHelper.SendOrderEmailCustomer(customerEmailNodeId, orderInfo);
}
if (storeEmailNodeId != 0)
{
EmailHelper.SendOrderEmailStore(storeEmailNodeId, orderInfo);
}
}
else
{
Log.Instance.LogDebug("AfterOrderStatusChanged ReadyForDispatchWhenStockArrives e.SendEmails == false");
}
break;
case OrderStatus.Dispatched:
if (e.SendEmails)
{
int customerEmailNodeId;
int.TryParse(orderInfo.StoreInfo.Store.DispatchEmailCustomer, out customerEmailNodeId);
int storeEmailNodeId;
int.TryParse(orderInfo.StoreInfo.Store.DispatchedEmailStore, out storeEmailNodeId);
if (customerEmailNodeId != 0)
{
EmailHelper.SendOrderEmailCustomer(customerEmailNodeId, orderInfo);
}
if (storeEmailNodeId != 0)
{
EmailHelper.SendOrderEmailStore(storeEmailNodeId, orderInfo);
}
}
else
{
Log.Instance.LogDebug("AfterOrderStatusChanged Dispatched e.SendEmails == false");
}
break;
case OrderStatus.Undeliverable:
if (e.SendEmails)
{
int customerEmailNodeId;
int.TryParse(orderInfo.StoreInfo.Store.UndeliverableEmailCustomer, out customerEmailNodeId);
int storeEmailNodeId;
int.TryParse(orderInfo.StoreInfo.Store.UndeliverableEmailStore, out storeEmailNodeId);
if (customerEmailNodeId != 0)
{
EmailHelper.SendOrderEmailCustomer(customerEmailNodeId, orderInfo);
}
if (storeEmailNodeId != 0)
{
EmailHelper.SendOrderEmailStore(storeEmailNodeId, orderInfo);
}
}
else
{
Log.Instance.LogDebug("AfterOrderStatusChanged Undeliverable e.SendEmails == false");
}
break;
case OrderStatus.WaitingForPayment:
break;
case OrderStatus.Returned:
// return stock
OrderHelper.ReturnStock(orderInfo);
if (e.SendEmails)
{
int customerEmailNodeId;
int.TryParse(orderInfo.StoreInfo.Store.ReturnedEmailCustomer, out customerEmailNodeId);
int storeEmailNodeId;
int.TryParse(orderInfo.StoreInfo.Store.ReturnedEmailStore, out storeEmailNodeId);
if (customerEmailNodeId != 0)
{
EmailHelper.SendOrderEmailCustomer(customerEmailNodeId, orderInfo);
}
if (storeEmailNodeId != 0)
{
EmailHelper.SendOrderEmailStore(storeEmailNodeId, orderInfo);
}
}
else
{
Log.Instance.LogDebug("AfterOrderStatusChanged Returned e.SendEmails == false");
}
break;
}
}
public async Task <IActionResult> Charge([FromForm] CashfreeResponse cashfreeResponse)
{
var cashfreeProvider = await _paymentProviderRepository.Query().FirstOrDefaultAsync(x => x.Id == PaymentProviderHelper.CashfreeProviderId);
var cashfreeSetting = JsonConvert.DeserializeObject <CashfreeConfigForm>(cashfreeProvider.AdditionalSettings);
// Check the response signature
string data = "";
data = data + cashfreeResponse.OrderId;
data = data + cashfreeResponse.OrderAmount;
data = data + cashfreeResponse.ReferenceId;
data = data + cashfreeResponse.TxStatus;
data = data + cashfreeResponse.PaymentMode;
data = data + cashfreeResponse.TxMsg;
data = data + cashfreeResponse.TxTime;
var responseToken = PaymentProviderHelper.GetToken(data, cashfreeSetting.SecretKey);
if (responseToken.Equals(cashfreeResponse.Signature))
{
var curentUser = await _workContext.GetCurrentUser();
var cart = await _cartService.GetActiveCart(curentUser.Id);
if (cart == null)
{
return(NotFound());
}
var orderCreateResult = await _orderService.CreateOrder(cart.Id, cashfreeResponse.PaymentMode, 0, OrderStatus.PendingPayment);
if (!orderCreateResult.Success)
{
TempData["Error"] = orderCreateResult.Error;
return(Redirect("~/checkout/payment"));
}
var order = orderCreateResult.Value;
var payment = new Payment()
{
OrderId = order.Id,
Amount = order.OrderTotal,
PaymentMethod = PaymentProviderHelper.CashfreeProviderId + " - " + cashfreeResponse.PaymentMode,
CreatedOn = DateTimeOffset.UtcNow
};
if (cashfreeResponse.TxStatus == "SUCCESS")
{
payment.GatewayTransactionId = cashfreeResponse.ReferenceId;
payment.Status = PaymentStatus.Succeeded;
order.OrderStatus = OrderStatus.PaymentReceived;
_paymentRepository.Add(payment);
await _paymentRepository.SaveChangesAsync();
return(Ok(new { Status = "success", OrderId = order.Id }));
}
else
{
payment.GatewayTransactionId = cashfreeResponse.ReferenceId;
payment.Status = PaymentStatus.Failed;
payment.FailureMessage = cashfreeResponse.TxMsg;
order.OrderStatus = OrderStatus.PaymentFailed;
_paymentRepository.Add(payment);
await _paymentRepository.SaveChangesAsync();
var error = "Error: " + cashfreeResponse.TxStatus + " - " + cashfreeResponse.TxMsg;
return(BadRequest(error));
}
}
else
{
return(BadRequest("PaymentTampered"));
}
}
/// <summary>
/// returns a list of payment providers
/// </summary>
/// <returns>
/// All list of all the Payment Providers in uWebshop
/// </returns>
public static List <PaymentProvider> GetAllPaymentProviders()
{
return(PaymentProviderHelper.GetAllPaymentProviders().ToList());
}
public PaymentRequest CreatePaymentRequest(OrderInfo orderInfo)
{
try
{
var paymentProvider = PaymentProvider.GetPaymentProvider(orderInfo.PaymentInfo.Id);
var reportUrl = paymentProvider.ReportUrl();
//Use https://idealtest.secure-ing.com/ideal/iDEALv3 during integration/test
//Use https://ideal.secure-ing.com/ideal/iDEALv3 only for production
// <provider title="IngAdvanced">
// <IssuerId>1111111</IssuerId>
// <MerchantId>1111111</MerchantId>
// <EntranceCode>22222222</EntranceCode>
// </provider>
var issuerId = orderInfo.PaymentInfo.MethodId;
var merchantId = paymentProvider.GetSetting("MerchantId");
var entranceCode = paymentProvider.GetSetting("EntranceCode");
var transaction = new Transaction
{
Amount = orderInfo.ChargedAmount,
Description = orderInfo.OrderNumber,
PurchaseId = orderInfo.OrderNumber,
IssuerId = issuerId,
EntranceCode = entranceCode
};
var connector = new Connector
{
MerchantReturnUrl = new Uri(reportUrl),
MerchantId = merchantId,
SubId = "0",
ExpirationPeriod = "PT10M"
};
transaction = connector.RequestTransaction(transaction);
if (transaction.Status == Transaction.TransactionStatus.Success)
{
var transactionId = transaction.Id;
var authenticateUrl = transaction.IssuerAuthenticationUrl.ToString();
var acquirerId = transaction.AcquirerId;
PaymentProviderHelper.SetTransactionId(orderInfo, transactionId);
orderInfo.PaymentInfo.Url = authenticateUrl;
orderInfo.PaymentInfo.Parameters = acquirerId;
orderInfo.Save();
}
else
{
// todo: failure handling, so don't change anything, user will not be redirected
}
}
catch (IDealException ex)
{
Log.Instance.LogError("ING Advanced PaymentRequestHander: " + ex);
}
var request = new PaymentRequest();
return(request);
}
/// <summary>
/// Executes the transaction request to SagePay
/// </summary>
/// <param name="orderInfo"></param>
/// <returns></returns>
public PaymentRequest CreatePaymentRequest(OrderInfo orderInfo)
{
// new API Call for easier access to date (but not able to write to)
var orderAPI = API.Basket.GetBasket(orderInfo.UniqueOrderId);
var paymentProvider = PaymentProvider.GetPaymentProvider(orderInfo.PaymentInfo.Id);
#region config helper
var vendorName = paymentProvider.GetSetting("VendorName");
var liveUrl = "https://live.sagepay.com/gateway/service/vspdirect-register.vsp";
var testUrl = "https://test.sagepay.com/Simulator/VSPDirectGateway.asp";
var configLiveUrl = paymentProvider.GetSetting("Url");
var configTestUrl = paymentProvider.GetSetting("testUrl");
if (!string.IsNullOrEmpty(configLiveUrl))
{
liveUrl = configLiveUrl;
}
if (!string.IsNullOrEmpty(configTestUrl))
{
testUrl = configTestUrl;
}
#endregion
var reportUrl = paymentProvider.ReportUrl();
var request = new PaymentRequest();
var cardTypeMethod = orderInfo.PaymentInfo.MethodId;
// Get the fields from the current request, this way they won't be stored in the order or in uWebshop
var creditCardHolderName = HttpContext.Current.Request["CardHolder"];
var creditCardNumber = HttpContext.Current.Request["CardNumber"];
var creditCardCV2 = HttpContext.Current.Request["CV2"];
var creditCardExpiryDate = HttpContext.Current.Request["ExpiryDate"];
if (string.IsNullOrEmpty(creditCardHolderName))
{
// if no creditCardHolder field is posted, try to see if the order contains an holder field
creditCardHolderName = orderAPI.Customer.GetValue <string>("customerCardHolder");
if (string.IsNullOrEmpty(creditCardHolderName))
{
// if that is not present, use first letter of firstName and full last name
creditCardHolderName = orderInfo.CustomerFirstName.Substring(0, 1) + " " +
orderInfo.CustomerLastName;
}
}
if (string.IsNullOrEmpty(creditCardNumber))
{
// if no creditCardNumber field is posted, try to see if the order contains an creditcardnumber
creditCardNumber = orderAPI.Customer.GetValue <string>("customerCardNumber");
if (cardTypeMethod.ToLowerInvariant() != "paypal" &&
(string.IsNullOrEmpty(creditCardNumber) && !paymentProvider.TestMode))
{
Log.Instance.LogError("Sagepay CreatePaymentRequest: No Creditcardnumber Given");
PaymentProviderHelper.AddValidationResult(orderInfo, paymentProvider.Id, "CreditCardError", "No Creditcardnumber Entered");
return(null);
}
}
if (string.IsNullOrEmpty(creditCardCV2))
{
// if no creditCardNumber field is posted, try to see if the order contains an creditcardnumber
creditCardCV2 = orderAPI.Customer.GetValue <string>("customerCardCV2");
if (cardTypeMethod.ToLowerInvariant() != "paypal" && string.IsNullOrEmpty(creditCardCV2) && !paymentProvider.TestMode)
{
Log.Instance.LogError("Sagepay CreatePaymentRequest: No CV2 Given");
PaymentProviderHelper.AddValidationResult(orderInfo, paymentProvider.Id, "CV2Error", "No CV2 Entered");
return(null);
}
}
if (string.IsNullOrEmpty(creditCardExpiryDate))
{
// if no ExpiryDate field is posted, try to see if the order contains an expirydate
creditCardExpiryDate = orderAPI.Customer.GetValue <string>("customerCardExpiryDate");
if (cardTypeMethod.ToLowerInvariant() != "paypal" && string.IsNullOrEmpty(creditCardExpiryDate) && !paymentProvider.TestMode)
{
Log.Instance.LogError("Sagepay CreatePaymentRequest: No creditCardExpiryDate Given");
PaymentProviderHelper.AddValidationResult(orderInfo, paymentProvider.Id, "CardExpiryDateError", "No CardExpiryDate Entered");
return(null);
}
}
// Preset Valid test creditcardnumbers for testmode
if (paymentProvider.TestMode)
{
switch (cardTypeMethod.ToUpperInvariant())
{
case "VISA":
creditCardNumber = "4929000000006";
break;
case "MC":
creditCardNumber = "5404000000000001";
break;
case "MCDEBIT":
creditCardNumber = "5573470000000001";
break;
case "DELTA":
creditCardNumber = "4462000000000003";
break;
case "MAESTRO":
creditCardNumber = "5641820000000005";
break;
case "UKE":
creditCardNumber = "4917300000000008";
break;
case "AMEX":
creditCardNumber = "374200000000004";
break;
case "DINERS":
creditCardNumber = "36000000000008";
break;
case "DC":
creditCardNumber = "4929000000006";
break;
case "JCB":
creditCardNumber = "3569990000000009";
break;
case "LASER":
creditCardNumber = "6304990000000000044";
break;
}
}
request.Parameters.Add("CardType", cardTypeMethod);
request.Parameters.Add("CardHolder", paymentProvider.TestMode ? "T.Ester" : creditCardHolderName);
request.Parameters.Add("CardNumber", creditCardNumber);
request.Parameters.Add("CV2", paymentProvider.TestMode ? "123" : creditCardCV2);
request.Parameters.Add("ExpiryDate", paymentProvider.TestMode ? DateTime.Now.AddMonths(6).ToString("MMyy") : creditCardExpiryDate);
request.Parameters.Add("VPSProtocol", "2.23");
request.Parameters.Add("TxType", "PAYMENT");
request.Parameters.Add("Vendor", vendorName);
var trasactionId = orderInfo.OrderNumber + "x" + DateTime.Now.ToString("hhmmss");
request.Parameters.Add("VendorTxCode", trasactionId);
request.Parameters.Add("Amount", orderInfo.ChargedAmount.ToString(new CultureInfo("en-GB").NumberFormat));
request.Parameters.Add("Currency", new RegionInfo(orderInfo.StoreInfo.Store.CurrencyCultureInfo.LCID).ISOCurrencySymbol);
request.Parameters.Add("Description", orderInfo.OrderNumber);
request.Parameters.Add("NotificationURL", reportUrl);
request.Parameters.Add("BillingSurname", GetSagePaySafeCustomerInfo(orderAPI.Customer.LastName));
request.Parameters.Add("BillingFirstnames", GetSagePaySafeCustomerInfo(orderAPI.Customer.FirstName));
request.Parameters.Add("BillingAddress1", GetSagePaySafeCustomerInfo(orderAPI.Customer.Address1));
request.Parameters.Add("BillingCity", GetSagePaySafeCustomerInfo(orderAPI.Customer.City));
request.Parameters.Add("BillingPostCode", GetSagePaySafeCustomerInfo(orderAPI.Customer.ZipCode));
request.Parameters.Add("BillingCountry", GetSagePaySafeCustomerInfo(orderInfo.CustomerInfo.CountryCode));
var deliverySurName = string.IsNullOrEmpty(orderAPI.Customer.Shipping.LastName) ? orderAPI.Customer.LastName : orderAPI.Customer.Shipping.LastName;
var deliveryFirstName = string.IsNullOrEmpty(orderAPI.Customer.Shipping.FirstName) ? orderAPI.Customer.FirstName : orderAPI.Customer.Shipping.FirstName;
var deliveryAddress1 = string.IsNullOrEmpty(orderAPI.Customer.Shipping.Address1) ? orderAPI.Customer.Address1 : orderAPI.Customer.Shipping.Address1;
var deliveryPostcode = string.IsNullOrEmpty(orderAPI.Customer.Shipping.ZipCode) ? orderAPI.Customer.ZipCode : orderAPI.Customer.Shipping.ZipCode;
var deliveryCity = string.IsNullOrEmpty(orderAPI.Customer.Shipping.City) ? orderAPI.Customer.City : orderAPI.Customer.Shipping.City;
var deliveryCountry = string.IsNullOrEmpty(orderAPI.Customer.Shipping.CountryCode) ? orderAPI.Customer.CountryCode : orderAPI.Customer.Shipping.CountryCode;
request.Parameters.Add("DeliverySurname", GetSagePaySafeCustomerInfo(deliverySurName));
request.Parameters.Add("DeliveryFirstnames", GetSagePaySafeCustomerInfo(deliveryFirstName));
request.Parameters.Add("DeliveryAddress1", GetSagePaySafeCustomerInfo(deliveryAddress1));
request.Parameters.Add("DeliveryCity", GetSagePaySafeCustomerInfo(deliveryCity));
request.Parameters.Add("DeliveryPostCode", GetSagePaySafeCustomerInfo(deliveryPostcode));
request.Parameters.Add("DeliveryCountry", GetSagePaySafeCustomerInfo(deliveryCountry));
// optionele parameters:
//request.Parameters.Add("BillingAddress2", "");
//request.Parameters.Add("BillingState", "");
//request.Parameters.Add("BillingPhone", "");
//request.Parameters.Add("DeliveryAddress2", "");
//request.Parameters.Add("DeliveryState", "");
//request.Parameters.Add("DeliveryPhone", "");
//request.Parameters.Add("CustomerEMail", "");
//request.Parameters.Add("Basket", ""); // optioneel info over basket
//request.Parameters.Add("AllowGiftAid", "0");
//request.Parameters.Add("Apply3DSecure", "0");
var sagePayUrl = paymentProvider.TestMode ? testUrl : liveUrl;
var responseString = _requestSender.SendRequest(sagePayUrl, request.ParametersAsString);
var deserializer = new ResponseSerializer();
var response = deserializer.Deserialize <TransactionRegistrationResponse>(responseString);
if (!string.IsNullOrEmpty(response.VPSTxId) && response.Status == ResponseType.Ok)
{
orderInfo.PaymentInfo.Parameters = response.Status + "&" + response.StatusDetail;
PaymentProviderHelper.SetTransactionId(orderInfo, response.VPSTxId);
}
else
{
Log.Instance.LogError("SagePay Did not return a proper status: " + response.Status + " detail: " + response.StatusDetail);
PaymentProviderHelper.AddValidationResult(orderInfo, paymentProvider.Id, "SagePayReturnedError", response.StatusDetail);
}
orderInfo.Save();
return(request);
}
public PaymentRequest CreatePaymentRequest(OrderInfo orderInfo)
{
var paymentProvider = PaymentProvider.GetPaymentProvider(orderInfo.PaymentInfo.Id, orderInfo.StoreInfo.Alias);
var returnUrl = paymentProvider.SuccessUrl();
var cancelUrl = paymentProvider.ErrorUrl();
var reportUrl = paymentProvider.ReportUrl();
var accountId = paymentProvider.GetSetting("accountId");
var siteId = paymentProvider.GetSetting("siteId");
var siteSecureId = paymentProvider.GetSetting("siteSecureId");
var testURL = paymentProvider.GetSetting("testURL");
var liveUrl = paymentProvider.GetSetting("url");
#region fill transactionrequest object
var transactionRequest = new TransactionRequest
{
AccountId = long.Parse(accountId),
SiteId = long.Parse(siteId),
SiteSecureId = long.Parse(siteSecureId),
NotificationUrl = reportUrl,
CancelUrl = cancelUrl,
RedirectUrl = returnUrl,
Locale = orderInfo.StoreInfo.CultureInfo.TwoLetterISOLanguageName + "_" + orderInfo.CustomerInfo.CountryCode,
IPAddress = HttpContext.Current.Request.ServerVariables["REMOTE_ADDR"],
ForwardedIP = HttpContext.Current.Request.ServerVariables["HTTP_X_FORWARDED_FOR"],
FirstName = OrderHelper.CustomerInformationValue(orderInfo, "customerFirstName"),
LastName = OrderHelper.CustomerInformationValue(orderInfo, "customerLastName"),
Country = OrderHelper.CustomerInformationValue(orderInfo, "customerCountry"),
Email = OrderHelper.CustomerInformationValue(orderInfo, "customerEmail")
};
var amount = orderInfo.ChargedAmountInCents;
transactionRequest.TransactionId = orderInfo.UniqueOrderId.ToString();
transactionRequest.Currency = orderInfo.StoreInfo.Store.CurrencyCultureSymbol;
transactionRequest.Amount = amount;
transactionRequest.Decription = orderInfo.OrderNumber;
transactionRequest.Gateway = orderInfo.PaymentInfo.MethodId;
var stringToHash = amount + transactionRequest.Currency + transactionRequest.AccountId + transactionRequest.SiteId + transactionRequest.TransactionId;
transactionRequest.Signature = GetMd5Sum(stringToHash);
#endregion
var apiURL = paymentProvider.TestMode ? testURL : liveUrl;
var httpWebRequest = (HttpWebRequest)WebRequest.Create(apiURL);
httpWebRequest.Method = "POST";
httpWebRequest.ContentLength = Encoding.UTF8.GetByteCount(transactionRequest.GetXml());
httpWebRequest.ContentType = "application/x-www-form-urlencoded";
Log.Instance.LogDebug("MultiSafePay GetAllPaymentMethods transactionRequest GetXml: " + HttpUtility.HtmlEncode(transactionRequest.GetXml()));
var streamWriter = new StreamWriter(httpWebRequest.GetRequestStream());
streamWriter.Write(transactionRequest.GetXml());
streamWriter.Close();
var httpWebResponse = (HttpWebResponse)httpWebRequest.GetResponse();
var streamReader = new StreamReader(httpWebResponse.GetResponseStream());
//<?xml version="1.0" encoding="UTF-8" ?>
//<redirecttransaction result="ok">
// <transaction>
// <id>4084044</id>
// <payment_url>https://user.multisafepay.com/pay/?trans...</payment_url>
// </transaction>
//</redirecttransaction>
var xmlDoc = XDocument.Parse(streamReader.ReadToEnd());
Log.Instance.LogDebug("MultiSafePay xmlDoc: " + xmlDoc);
if (xmlDoc.Root == null)
{
return(null);
}
var transaction = xmlDoc.Root.Element("transaction");
if (transaction == null)
{
Log.Instance.LogError("MultiSafePay transaction == null");
return(null);
}
var paymentUrl = transaction.Element("payment_url");
if (paymentUrl == null)
{
Log.Instance.LogError("MultiSafePay paymentUrl == null");
return(null);
}
orderInfo.PaymentInfo.Url = paymentUrl.Value;
PaymentProviderHelper.SetTransactionId(orderInfo, orderInfo.UniqueOrderId.ToString());
return(new PaymentRequest());
}
public PaymentRequest CreatePaymentRequest(OrderInfo orderInfo)
{
var paymentProvider = PaymentProvider.GetPaymentProvider(orderInfo.PaymentInfo.Id);
var reportUrl = paymentProvider.ReportUrl();
// <provider title="OmniKassa">
// <MerchantId>002020000000001</MerchantId>
// <CurrencyCode>978</CurrencyCode>
// <normalReturnUrl>http://www.hetanker.tv</normalReturnUrl>
// <KeyVersion>1</KeyVersion>
// <TestAmount>56</TestAmount>
// </provider>
var merchantId = paymentProvider.GetSetting("MerchantId");
var keyVersion = paymentProvider.GetSetting("KeyVersion");
var currencyCode = paymentProvider.GetSetting("CurrencyCode");
var testAmount = paymentProvider.GetSetting("testAmount");
var liveUrl = "https://payment-webinit.omnikassa.rabobank.nl/paymentServlet";
var testUrl = "https://payment-webinit.simu.omnikassa.rabobank.nl/paymentServlet";
var configLiveUrl = paymentProvider.GetSetting("Url");
var configTestUrl = paymentProvider.GetSetting("testUrl");
if (!string.IsNullOrEmpty(configLiveUrl))
{
liveUrl = configLiveUrl;
}
if (!string.IsNullOrEmpty(configTestUrl))
{
testUrl = configTestUrl;
}
var liveForwardUrl = "https://payment-web.omnikassa.rabobank.nl/payment";
var testForwardUrl = "https://payment-web.simu.omnikassa.rabobank.nl/payment";
var configForwardLiveUrl = paymentProvider.GetSetting("forwardUrl");
var configForwardTestUrl = paymentProvider.GetSetting("testForwardUrl");
if (!string.IsNullOrEmpty(configForwardLiveUrl))
{
liveForwardUrl = configForwardLiveUrl;
}
if (!string.IsNullOrEmpty(configForwardTestUrl))
{
testForwardUrl = configForwardTestUrl;
}
var securityKey = paymentProvider.GetSetting("SecurityKey");
var postUrl = paymentProvider.TestMode ? testUrl : liveUrl;
var forwardUrl = paymentProvider.TestMode ? testForwardUrl : liveForwardUrl;
var amount = paymentProvider.TestMode ? testAmount : orderInfo.ChargedAmountInCents.ToString();
var orderId = orderInfo.OrderNumber;
if (orderId.Length > 32)
{
Log.Instance.LogError("OmniKassa: orderInfo.OrderNumber: Too Long, Max 32 Characters! orderInfo.OrderNumber: " + orderInfo.OrderNumber);
orderId = orderInfo.OrderNumber.Substring(0, 31);
}
var transactionId = orderId + "x" + DateTime.Now.ToString("hhmmss");
var rgx = new Regex("[^a-zA-Z0-9]");
transactionId = rgx.Replace(transactionId, "");
if (transactionId.Length > 35)
{
Log.Instance.LogError("OmniKassa: uniqueId (orderId + 'x' + DateTime.Now.ToString('hhmmss')): Too Long, Max 35 Characters! uniqueId: " + transactionId);
transactionId = transactionId.Substring(0, 34);
}
if (reportUrl.Length > 512)
{
Log.Instance.LogError("OmniKassa: reportUrl: Too Long, Max 512 Characters! reportUrl: " + reportUrl);
}
// Data-veld samenstellen
var data = string.Format("merchantId={0}", merchantId) + string.Format("|orderId={0}", orderId) + string.Format("|amount={0}", amount) + string.Format("|customerLanguage={0}", "NL") + string.Format("|keyVersion={0}", keyVersion) + string.Format("|currencyCode={0}", currencyCode) // + string.Format("|PaymentMeanBrandList={0}", "IDEAL")
+ string.Format("|normalReturnUrl={0}", reportUrl) + string.Format("|automaticResponseUrl={0}", reportUrl) + string.Format("|transactionReference={0}", transactionId);
// Seal-veld berekenen
var sha256 = SHA256.Create();
var hashValue = sha256.ComputeHash(new UTF8Encoding().GetBytes(data + securityKey));
// POST data samenstellen
var postData = new NameValueCollection {
{ "Data", data }, { "Seal", ByteArrayToHexString(hashValue) }, { "InterfaceVersion", "HP_1.0" }
};
//// Posten van data
byte[] response;
using (var client = new WebClient())
response = client.UploadValues(postUrl, postData);
try
{
var responseData = Encoding.UTF8.GetString(response);
var trimmedResponse = responseData.Trim();
var matchedHiddenfield = Regex.Matches(trimmedResponse, "<input type=HIDDEN.+/>", RegexOptions.IgnoreCase | RegexOptions.Multiline);
var postValueFromHiddenField = Regex.Matches(matchedHiddenfield[0].Value, "(?<=\\bvalue=\")[^\"]*", RegexOptions.IgnoreCase | RegexOptions.Multiline);
var redirectionDataField = string.Format("redirectionData={0}", postValueFromHiddenField[0].Value);
PaymentProviderHelper.SetTransactionId(orderInfo, transactionId);
orderInfo.PaymentInfo.Url = forwardUrl;
orderInfo.PaymentInfo.Parameters = redirectionDataField;
orderInfo.Save();
var request = new PaymentRequest();
return(request);
}
catch
{
var responseResult = Encoding.UTF8.GetString(response);
Log.Instance.LogError("Omnikassa: " + responseResult);
throw new Exception("OmniKassa Issue Please Notice Shopowner");
}
}
/// <summary>
/// Returns Payment Providers for this order
/// </summary>
/// <returns></returns>
public static List <PaymentProvider> PaymentProviders()
{
return(PaymentProviderHelper.GetPaymentProvidersForOrder());
}
