public async System.Threading.Tasks.Task <IActionResult> OrderCompleteAsync(string hash = "", int orderId = 0)
{
if (hash != "" && orderId > 0)
{
Order lastOrder = (await _orderService.GetOrderByIdAsync(orderId));
if (lastOrder != null)
{
if (lastOrder.PaymentMethodSystemName.ToLower().Equals("payments.param"))
{
if (lastOrder.OrderGuid.ToString() == hash)
{
if (lastOrder.PaymentStatus == PaymentStatus.Pending)
{
if (_orderProcessingService.CanCancelOrder(lastOrder))
{
if (_orderProcessingService.CanMarkOrderAsPaid(lastOrder))
{
await _orderProcessingService.MarkOrderAsPaidAsync(lastOrder);
return(RedirectToRoute("CheckoutCompleted", new { orderId = orderId }));
}
}
}
}
}
}
return(RedirectToRoute("OrderDetails", new { orderId = orderId }));
}
return(RedirectToRoute("Cart"));
}
/// <summary>
/// Execute task
/// </summary>
/// <returns>The <see cref="Task"/></returns>
public async Task ExecuteAsync()
{
var stores = await _storeService.GetAllStoresAsync();
foreach (var store in stores)
{
var validationResult = await _openPayService.ValidateAsync(store.Id);
if (!validationResult.IsValid)
{
await _logger.ErrorAsync($"{Defaults.SystemName}: Cannot update the status of the orders in the store '{store.Name}' when background task was processed.{Environment.NewLine}{string.Join(Environment.NewLine, validationResult.Errors)}");
continue;
}
// get all non-paid orders including previous month
var orders = (await _orderService.SearchOrdersAsync(
storeId: store.Id,
createdFromUtc: DateTime.UtcNow.AddMonths(-1),
psIds: new List <int>
{
(int)PaymentStatus.Pending,
(int)PaymentStatus.Authorized
}))?.Where(o => o.PaymentMethodSystemName == Defaults.SystemName);
if (orders?.Any() == true)
{
var openPayPaymentSettings = await _settingService.LoadSettingAsync <OpenPayPaymentSettings>(store.Id);
_openPayApi.ConfigureClient(openPayPaymentSettings);
foreach (var order in orders)
{
var result = await _openPayService.CaptureOrderAsync(order);
if (string.IsNullOrEmpty(result.OrderId))
{
await _logger.ErrorAsync($"{Defaults.SystemName}: Cannot update the status of the order '{order.CustomOrderNumber}' in the store '{store.Name}' when background task was processed.{Environment.NewLine}{string.Join(Environment.NewLine, result.Errors)}");
}
else if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
order.CaptureTransactionId = result.OrderId;
await _orderProcessingService.MarkOrderAsPaidAsync(order);
}
}
}
}
}
/// <returns>A task that represents the asynchronous operation</returns>
protected virtual async Task ProcessPaymentAsync(string orderNumber, string ipnInfo, PaymentStatus newPaymentStatus, decimal mcGross, string transactionId)
{
Guid orderNumberGuid;
try
{
orderNumberGuid = new Guid(orderNumber);
}
catch
{
orderNumberGuid = Guid.Empty;
}
var order = await _orderService.GetOrderByGuidAsync(orderNumberGuid);
if (order == null)
{
await _logger.ErrorAsync("Paytm IPN. Order is not found", new NopException(ipnInfo));
return;
}
//order note
await _orderService.InsertOrderNoteAsync(new OrderNote
{
OrderId = order.Id,
Note = ipnInfo,
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
//validate order total
if ((newPaymentStatus == PaymentStatus.Authorized || newPaymentStatus == PaymentStatus.Paid) && !Math.Round(mcGross, 2).Equals(Math.Round(order.OrderTotal, 2)))
{
var errorStr = $"Paytm IPN. Returned order total {mcGross} doesn't equal order total {order.OrderTotal}. Order# {order.Id}.";
//log
await _logger.ErrorAsync(errorStr);
//order note
await _orderService.InsertOrderNoteAsync(new OrderNote
{
OrderId = order.Id,
Note = errorStr,
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
return;
}
switch (newPaymentStatus)
{
case PaymentStatus.Authorized:
if (_orderProcessingService.CanMarkOrderAsAuthorized(order))
{
await _orderProcessingService.MarkAsAuthorizedAsync(order);
}
break;
case PaymentStatus.Paid:
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
order.AuthorizationTransactionId = transactionId;
await _orderService.UpdateOrderAsync(order);
await _orderProcessingService.MarkOrderAsPaidAsync(order);
}
break;
case PaymentStatus.Refunded:
var totalToRefund = Math.Abs(mcGross);
if (totalToRefund > 0 && Math.Round(totalToRefund, 2).Equals(Math.Round(order.OrderTotal, 2)))
{
//refund
if (_orderProcessingService.CanRefundOffline(order))
{
await _orderProcessingService.RefundOfflineAsync(order);
}
}
else
{
//partial refund
if (_orderProcessingService.CanPartiallyRefundOffline(order, totalToRefund))
{
await _orderProcessingService.PartiallyRefundOfflineAsync(order, totalToRefund);
}
}
break;
case PaymentStatus.Voided:
if (_orderProcessingService.CanVoidOffline(order))
{
await _orderProcessingService.VoidOfflineAsync(order);
}
break;
}
}
public async Task <IActionResult> PDTHandler()
{
var tx = _webHelper.QueryString <string>("tx");
if (await _paymentPluginManager.LoadPluginBySystemNameAsync("Payments.PayPalStandard") is not PayPalStandardPaymentProcessor processor || !_paymentPluginManager.IsPluginActive(processor))
{
throw new NopException("PayPal Standard module cannot be loaded");
}
var(result, values, response) = await processor.GetPdtDetailsAsync(tx);
if (result)
{
values.TryGetValue("custom", out var orderNumber);
var orderNumberGuid = Guid.Empty;
try
{
orderNumberGuid = new Guid(orderNumber);
}
catch
{
// ignored
}
var order = await _orderService.GetOrderByGuidAsync(orderNumberGuid);
if (order == null)
{
return(RedirectToAction("Index", "Home", new { area = string.Empty }));
}
var mcGross = decimal.Zero;
try
{
mcGross = decimal.Parse(values["mc_gross"], new CultureInfo("en-US"));
}
catch (Exception exc)
{
await _logger.ErrorAsync("PayPal PDT. Error getting mc_gross", exc);
}
values.TryGetValue("payer_status", out var payerStatus);
values.TryGetValue("payment_status", out var paymentStatus);
values.TryGetValue("pending_reason", out var pendingReason);
values.TryGetValue("mc_currency", out var mcCurrency);
values.TryGetValue("txn_id", out var txnId);
values.TryGetValue("payment_type", out var paymentType);
values.TryGetValue("payer_id", out var payerId);
values.TryGetValue("receiver_id", out var receiverId);
values.TryGetValue("invoice", out var invoice);
values.TryGetValue("mc_fee", out var mcFee);
var sb = new StringBuilder();
sb.AppendLine("PayPal PDT:");
sb.AppendLine("mc_gross: " + mcGross);
sb.AppendLine("Payer status: " + payerStatus);
sb.AppendLine("Payment status: " + paymentStatus);
sb.AppendLine("Pending reason: " + pendingReason);
sb.AppendLine("mc_currency: " + mcCurrency);
sb.AppendLine("txn_id: " + txnId);
sb.AppendLine("payment_type: " + paymentType);
sb.AppendLine("payer_id: " + payerId);
sb.AppendLine("receiver_id: " + receiverId);
sb.AppendLine("invoice: " + invoice);
sb.AppendLine("mc_fee: " + mcFee);
var newPaymentStatus = PayPalHelper.GetPaymentStatus(paymentStatus, string.Empty);
sb.AppendLine("New payment status: " + newPaymentStatus);
//order note
await _orderService.InsertOrderNoteAsync(new OrderNote
{
OrderId = order.Id,
Note = sb.ToString(),
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
//validate order total
var orderTotalSentToPayPal = await _genericAttributeService.GetAttributeAsync <decimal?>(order, PayPalHelper.OrderTotalSentToPayPal);
if (orderTotalSentToPayPal.HasValue && mcGross != orderTotalSentToPayPal.Value)
{
var errorStr = $"PayPal PDT. Returned order total {mcGross} doesn't equal order total {order.OrderTotal}. Order# {order.Id}.";
//log
await _logger.ErrorAsync(errorStr);
//order note
await _orderService.InsertOrderNoteAsync(new OrderNote
{
OrderId = order.Id,
Note = errorStr,
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
return(RedirectToAction("Index", "Home", new { area = string.Empty }));
}
//clear attribute
if (orderTotalSentToPayPal.HasValue)
{
await _genericAttributeService.SaveAttributeAsync <decimal?>(order, PayPalHelper.OrderTotalSentToPayPal, null);
}
if (newPaymentStatus != PaymentStatus.Paid)
{
return(RedirectToRoute("CheckoutCompleted", new { orderId = order.Id }));
}
if (!_orderProcessingService.CanMarkOrderAsPaid(order))
{
return(RedirectToRoute("CheckoutCompleted", new { orderId = order.Id }));
}
//mark order as paid
order.AuthorizationTransactionId = txnId;
await _orderService.UpdateOrderAsync(order);
await _orderProcessingService.MarkOrderAsPaidAsync(order);
return(RedirectToRoute("CheckoutCompleted", new { orderId = order.Id }));
}
else
{
if (!values.TryGetValue("custom", out var orderNumber))
{
orderNumber = _webHelper.QueryString <string>("cm");
}
var orderNumberGuid = Guid.Empty;
try
{
orderNumberGuid = new Guid(orderNumber);
}
catch
{
// ignored
}
var order = await _orderService.GetOrderByGuidAsync(orderNumberGuid);
if (order == null)
{
return(RedirectToAction("Index", "Home", new { area = string.Empty }));
}
//order note
await _orderService.InsertOrderNoteAsync(new OrderNote
{
OrderId = order.Id,
Note = "PayPal PDT failed. " + response,
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
return(RedirectToRoute("CheckoutCompleted", new { orderId = order.Id }));
}
}
public async Task <IActionResult> SuccessfulPayment(string status, string planId, int?orderId)
{
if (await _paymentPluginManager.LoadPluginBySystemNameAsync(Defaults.SystemName) is not OpenPayPaymentProcessor processor || !_paymentPluginManager.IsPluginActive(processor))
{
return(await ProduceErrorResponseAsync());
}
if (!orderId.HasValue || string.IsNullOrEmpty(planId) || string.IsNullOrEmpty(status))
{
return(await ProduceErrorResponseAsync());
}
var order = await _orderService.GetOrderByIdAsync(orderId.Value);
if (order == null || order.Deleted)
{
return(await ProduceErrorResponseAsync(null, $"Invalid processing payment after the order successfully placed on OpenPay. The order '{order.CustomOrderNumber}' not found or was deleted."));
}
var openPayOrder = await _openPayApi.GetOrderStatusByIdAsync(planId);
if (openPayOrder == null)
{
return(await ProduceErrorResponseAsync(order.Id, $"Invalid processing payment after the order successfully placed on OpenPay. Cannot get the OpenPay order by id '{planId}'."));
}
if (!openPayOrder.PlanStatus.Equals(status, StringComparison.InvariantCultureIgnoreCase))
{
return(await ProduceErrorResponseAsync(order.Id, $"Invalid processing payment after the order successfully placed on OpenPay. The OpenPay plan status '{status}' is invalid."));
}
if (!openPayOrder.OrderStatus.Equals("Pending", StringComparison.InvariantCultureIgnoreCase))
{
return(await ProduceErrorResponseAsync(order.Id, $"Invalid processing payment after the order successfully placed on OpenPay. The OpenPay order status '{openPayOrder.OrderStatus}' is invalid."));
}
if (!openPayOrder.PlanStatus.Equals("Lodged", StringComparison.InvariantCultureIgnoreCase))
{
return(await ProduceErrorResponseAsync(order.Id, "Invalid processing payment after the order successfully placed on OpenPay. The OpenPay plan status should be 'Lodged'."));
}
if (!_orderProcessingService.CanMarkOrderAsPaid(order))
{
return(await ProduceErrorResponseAsync(order.Id, $"Invalid processing payment after the order successfully placed on OpenPay. The order '{order.CustomOrderNumber}' already marked as paid."));
}
var result = await _openPayService.CaptureOrderAsync(order);
if (string.IsNullOrEmpty(result.OrderId))
{
return(await ProduceErrorResponseAsync(order.Id, string.Join(Environment.NewLine, result.Errors)));
}
order.CaptureTransactionId = result.OrderId;
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
await _orderProcessingService.MarkOrderAsPaidAsync(order);
}
_notificationService.SuccessNotification(
await _localizationService.GetResourceAsync("Plugins.Payments.OpenPay.SuccessfulPayment"));
return(RedirectToAction("Completed", "Checkout", new { orderId = order.Id }));
}
public ActionResult Return()
{
var processor = _paymentPluginManager.LoadPluginBySystemNameAsync("Payments.Paytm").Result as PaytmPaymentProcessor;
if (processor == null || !_paymentPluginManager.IsPluginActive(processor) || !processor.PluginDescriptor.Installed)
{
throw new NopException("Paytm module cannot be loaded");
}
var myUtility = new PaytmHelper();
string orderId, amount, authDesc, resCode;
bool checkSumMatch = false;
//Assign following values to send it to verifychecksum function.
if (String.IsNullOrWhiteSpace(_paytmPaymentSettings.MerchantKey))
{
throw new NopException("Paytm key is not set");
}
string workingKey = _paytmPaymentSettings.MerchantKey;
string paytmChecksum = null;
Dictionary <string, string> parameters = new Dictionary <string, string>();
if (Request.Form.Keys.Count > 0)
{
foreach (string key in Request.Form.Keys)
{
if (Request.Form[key].Contains("|"))
{
parameters.Add(key.Trim(), "");
}
else
{
parameters.Add(key.Trim(), Request.Form[key]);
}
}
if (parameters.ContainsKey("CHECKSUMHASH"))
{
paytmChecksum = parameters["CHECKSUMHASH"];
parameters.Remove("CHECKSUMHASH");
}
if (!string.IsNullOrEmpty(paytmChecksum) && Checksum.verifySignature(parameters, workingKey, paytmChecksum))
{
checkSumMatch = true;
}
}
orderId = parameters["ORDERID"];
amount = parameters["TXNAMOUNT"];
resCode = parameters["RESPCODE"];
authDesc = parameters["STATUS"];
var order = _orderService.GetOrderByCustomOrderNumberAsync(orderId).Result;
if (checkSumMatch == true)
{
if (resCode == "01" && authDesc == "TXN_SUCCESS")
{
if (TxnStatus(orderId, order.OrderTotal.ToString("0.00")))
{
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
_orderProcessingService.MarkOrderAsPaidAsync(order);
}
return(RedirectToRoute("CheckoutCompleted", new { orderId = order.Id }));
}
else
{
return(Content("Amount Mismatch"));
}
}
else if (authDesc == "TXN_FAILURE")
{
_orderProcessingService.CancelOrderAsync(order, false);
order.OrderStatus = OrderStatus.Cancelled;
_orderService.UpdateOrderAsync(order);
return(RedirectToRoute("OrderDetails", new { orderId = order.Id }));
}
else
{
return(Content("Security Error. Illegal access detected"));
}
}
else if (string.IsNullOrEmpty(paytmChecksum))
{
return(Content("Please Contact Customer Care"));
}
else
{
return(Content("Security Error. Illegal access detected, Checksum failed"));
}
}
//public IActionResult PayGateNotifyHandler(IFormCollection form)
public async void PayGateNotifyHandler(IFormCollection form)
{
/**
* Enable IPN if it is set
*/
await Response.WriteAsync("OK");
var reference = Request.Query["pgnopcommerce"];
bool isPaid;
await _logger.InformationAsync("PayGateNotifyHandler start. Order no.: " + reference);
//Order order = _orderService.GetOrderById(Int32.Parse(Request.Query["pgnopcommerce"]));
Order order = await _orderService.GetOrderByIdAsync(Int32.Parse(reference));
int orderId = 0;
if (order != null)
{
orderId = order.Id;
}
await _logger.InformationAsync("PayGateNotifyHandler: Order Payment Status: " + order.PaymentStatus);
isPaid = order.PaymentStatus == PaymentStatus.Paid ? true : false;
if (!isPaid)
{
var sBuilder = new StringBuilder();
var query_status = PaymentStatus.Pending;
var payrequestId = "";
var transactionStatus = "";
var testMode = _payGatePaymentSettings.TestMode;
var paygateId = "10011072130";
var encryptionKey = "secret";
if (!testMode)
{
paygateId = _payGatePaymentSettings.PayGateID;
encryptionKey = _payGatePaymentSettings.EncryptionKey;
}
//Validate checksum for the posted form fields
var formData = new NameValueCollection();
var formDataJS = "";
var checkstring = "";
foreach (var entry in form)
{
var key = entry.Key;
var val = entry.Value;
formData[key] = val;
if (key != "CHECKSUM")
{
checkstring += val;
formDataJS += key + "=" + val + "&";
}
}
await _logger.InformationAsync("PayGateNotifyHandler: POST: " + formDataJS);
var checksum = formData["CHECKSUM"];
checkstring += encryptionKey;
var ourChecksum = new PayGateHelper().CalculateMD5Hash(checkstring);
if (ourChecksum.Equals(checksum, StringComparison.OrdinalIgnoreCase))
{
var trans_status = formData["TRANSACTION_STATUS"];
transactionStatus = trans_status;
var query_status_desc = "";
payrequestId = formData["PAY_REQUEST_ID"];
switch (trans_status)
{
case "1":
query_status = PaymentStatus.Paid;
query_status_desc = "Approved";
break;
case "2":
query_status = PaymentStatus.Voided;
query_status_desc = "Declined";
break;
case "4":
query_status = PaymentStatus.Voided;
query_status_desc = "Cancelled By Customer with back button on payment page";
break;
case "0":
query_status = PaymentStatus.Voided;
query_status_desc = "Not Done";
break;
default:
break;
}
sBuilder.AppendLine("PayGate Notify Handler");
sBuilder.AppendLine("PayGate Query Data");
sBuilder.AppendLine("=======================");
sBuilder.AppendLine("PayGate Transaction_Id: " + formData["TRANSACTION_ID"]);
sBuilder.AppendLine("PayGate Status Desc: " + query_status_desc);
sBuilder.AppendLine("");
//order note
await _orderService.InsertOrderNoteAsync(new OrderNote
{
OrderId = orderId,
Note = sBuilder.ToString(),//sbbustring.Format("Order status has been changed to {0}", PaymentStatus.Paid),
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
await _orderService.UpdateOrderAsync(order);
//load settings for a chosen store scope
var storeScope = this.GetActiveStoreScopeConfiguration(_storeService, _workContext);
var payGatePaymentSettings = _settingService.LoadSettingAsync <PayGatePaymentSettings>(storeScope);
//mark order as paid
if (query_status == PaymentStatus.Paid)
{
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
order.AuthorizationTransactionId = payrequestId;
await _orderService.UpdateOrderAsync(order);
await _orderProcessingService.MarkOrderAsPaidAsync(order);
}
await _orderService.UpdateOrderAsync(order);
RedirectToRoute("CheckoutCompleted", new { orderId = order.Id });
}
else
{
order.AuthorizationTransactionId = payrequestId;
OrderNote note = new OrderNote();
note.OrderId = orderId;
note.CreatedOnUtc = DateTime.Now;
note.DisplayToCustomer = true;
note.Note = "Payment failed with the following description: " + transactionStatus;
if (_orderProcessingService.CanCancelOrder(order))
{
await _orderProcessingService.CancelOrderAsync(order, false);
}
await _orderService.InsertOrderNoteAsync(note);
await _orderService.UpdateOrderAsync(order);
RedirectToRoute("OrderDetails", new { orderId = order.Id.ToString().Trim() });
}
}
else
{
await _logger.ErrorAsync("PayGateNotifyHandler: Checksum mismatch: " + ourChecksum + " : " + checksum);
}
}
}
/*
*
* [NonAction]
* public override IList<string> ValidatePaymentForm(FormCollection form)
* {
* var warnings = new List<string>();
* return warnings;
* }
*
* [NonAction]
* public override ProcessPaymentRequest Ge tPaymentInfo(FormCollection form)
* {
* var paymentInfo = new ProcessPaymentRequest();
* return paymentInfo;
* }
*/
//[ValidateInput(false)]
public async Task <IActionResult> Return(IpnModel model)
{
try
{
/*
* var processor = _paymentService.LoadPaymentMethodBySystemName("Payments.Payu") as PayuPaymentProcessor;
* if (processor == null ||
* !processor.IsPaymentMethodActive(_paymentSettings) || !processor.PluginDescriptor.Installed)
* throw new NopException("Payu module cannot be loaded");
*
*/
var myUtility = new PayuHelper();
string orderId, merchantId, amount, productinfo, firstname, email, hash, status, checksum;
//Assign following values to send it to verifychecksum function.
if (String.IsNullOrWhiteSpace(_payuPaymentSettings.Key))
{
throw new NopException("Payu key is not set");
}
merchantId = _payuPaymentSettings.MerchantId.ToString();
orderId = model.Form["txnid"];
amount = model.Form["amount"];
productinfo = model.Form["productinfo"];
firstname = model.Form["firstname"];
email = model.Form["email"];
hash = model.Form["hash"];
status = model.Form["status"];
checksum = myUtility.verifychecksum(merchantId, orderId, amount, productinfo, firstname, email, status, _payuPaymentSettings.Key);
if (checksum == hash)
{
if (status == "success")
{
/*
* Here you need to put in the routines for a successful
* transaction such as sending an email to customer,
* setting database status, informing logistics etc etc
*/
var order = await _orderService.GetOrderByIdAsync(Convert.ToInt32(orderId));
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
await _orderProcessingService.MarkOrderAsPaidAsync(order);
var sb = new StringBuilder();
sb.AppendLine("PayU IPN:");
foreach (var v in model.Form)
{
sb.AppendLine(v.Key + ": " + v.Value);
}
//order note
//OrderNoteAdd
await _orderService.InsertOrderNoteAsync(new OrderNote
{
OrderId = order.Id,
Note = sb.ToString(),
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
await _orderService.UpdateOrderAsync(order);
}
//Thank you for shopping with us. Your credit card has been charged and your transaction is successful
return(RedirectToRoute("CheckoutCompleted", new { orderId = order.Id }));
}
else
{
/*
* Here you need to put in the routines for a failed
* transaction such as sending an email to customer
* setting database status etc etc
*/
return(RedirectToAction("Index", "Home", new { area = "" }));
}
}
else
{
/*
* Here you need to simply ignore this and dont need
* to perform any operation in this condition
*/
return(Content("Security Error. Illegal access detected"));
}
}
catch (Exception ex)
{
return(Content("Error Occured :" + ex.Message));
}
}
public async Task <ActionResult> ResultHandler(string status, string authority, string oGUID)
{
if (!(await _paymentPluginManager.LoadPluginBySystemNameAsync("Payments.Zarinpal") is ZarinPalPaymentProcessor processor) || !_paymentPluginManager.IsPluginActive(processor))
{
throw new NopException("ZarinPal module cannot be loaded");
}
var orderNumberGuid = Guid.Empty;
orderNumberGuid = new Guid(oGUID);
var order = await _orderService.GetOrderByGuidAsync(orderNumberGuid);
var total = Convert.ToInt32(Math.Round(order.OrderTotal, 2));
if (_zarinPalPaymentSettings.RialToToman)
{
total = total / 10;
}
if (string.IsNullOrEmpty(status) == false && string.IsNullOrEmpty(authority) == false)
{
var refId = "0";
System.Net.ServicePointManager.Expect100Continue = false;
var statusCode = -1;
var storeScope = await _storeContext.GetActiveStoreScopeConfigurationAsync();
var zarinPalSettings = await _settingService.LoadSettingAsync <ZarinpalPaymentSettings>(storeScope);
if (_zarinPalPaymentSettings.Method == EnumMethod.SOAP)
{
if (_zarinPalPaymentSettings.UseSandbox)
{
using (PaymentGatewayImplementationServicePortTypeClient zpalSr = new PaymentGatewayImplementationServicePortTypeClient())
{
var res = zpalSr.PaymentVerificationAsync
(
zarinPalSettings.MerchantID,
authority,
total
).Result; //test
statusCode = res.Body.Status;
refId = res.Body.RefID.ToString();
}
}
else
{
using (PaymentGatewayImplementationServicePortTypeClient zpalSr = new ServiceReferenceZarinpal.PaymentGatewayImplementationServicePortTypeClient())
{
var res = zpalSr.PaymentVerificationAsync(
zarinPalSettings.MerchantID,
authority,
total).Result;
statusCode = res.Body.Status;
refId = res.Body.RefID.ToString();
}
}
}
else if (_zarinPalPaymentSettings.Method == EnumMethod.REST)
{
var url = $"https://{(_zarinPalPaymentSettings.UseSandbox ? "sandbox" : "www")}.zarinpal.com/pg/rest/WebGate/PaymentVerification.json";
var values = new Dictionary <string, string>
{
{ "MerchantID", zarinPalSettings.MerchantID },
{ "Authority", authority },
{ "Amount", total.ToString() } //Toman
};
var paymenResponsetJsonValue = JsonConvert.SerializeObject(values);
var content = new StringContent(paymenResponsetJsonValue, Encoding.UTF8, "application/json");
var response = ZarinPalPaymentProcessor.ClientZarinPal.PostAsync(url, content).Result;
var responseString = response.Content.ReadAsStringAsync().Result;
var restVerifyModel =
JsonConvert.DeserializeObject <RestVerifyModel>(responseString);
statusCode = restVerifyModel.Status;
refId = restVerifyModel.RefID;
}
var result = ZarinpalHelper.StatusToMessage(statusCode);
var orderNote = new OrderNote()
{
OrderId = order.Id,
Note = string.Concat(
"پرداخت ",
(result.IsOk ? "" : "نا"), "موفق", " - ",
"پیغام درگاه : ", result.Message,
result.IsOk ? string.Concat(" - ", "کد پی گیری : ", refId) : ""
),
DisplayToCustomer = true,
CreatedOnUtc = DateTime.UtcNow
};
await _orderService.InsertOrderNoteAsync(orderNote);
if (result.IsOk && _orderProcessingService.CanMarkOrderAsPaid(order))
{
order.AuthorizationTransactionId = refId;
await _orderService.UpdateOrderAsync(order);
await _orderProcessingService.MarkOrderAsPaidAsync(order);
return(RedirectToRoute("CheckoutCompleted", new { orderId = order.Id }));
}
}
return(RedirectToRoute("orderdetails", new { orderId = order.Id }));
}