public IActionResult PDTHandler()
{
if (_webHelper.QueryString <string>("FawryRefNo") != null)
{
var MerchantRefNo = Convert.ToInt16(_webHelper.QueryString <string>("MerchantRefNo"));
var order = _orderService.GetOrderById(MerchantRefNo);
var OrderStatus = _webHelper.QueryString <string>("OrderStatus");
var FawryRefNo = _webHelper.QueryString <string>("FawryRefNo");
if (order != null && OrderStatus != null && FawryRefNo != null)
{
if (OrderStatus == "NEW")
{
return(RedirectToRoute("CheckoutCompleted", new { orderId = order.Id }));
}
else if (OrderStatus == "EXPIRED")
{
_orderProcessingService.CancelOrder(order, false);
}
else if (OrderStatus == "PAID")
{
_orderProcessingService.MarkOrderAsPaid(order);
}
}
}
else
{
var MerchantRefNo = Convert.ToInt16(_webHelper.QueryString <string>("merchantRefNum"));
var order = _orderService.GetOrderById(MerchantRefNo);
_orderProcessingService.CancelOrder(order, false);
}
return(RedirectToAction("Index", "Home", new { area = "" }));
}
public List <OrderError> SetOrdersStatusCanceled(int[] ordersId, string usernameOrEmail, string userPassword)
{
CheckAccess(usernameOrEmail, userPassword);
if (!_permissionSettings.Authorize(StandardPermissionProvider.ManageOrders))
{
throw new ApplicationException("Not allowed to manage orders");
}
var errors = new List <OrderError>();
foreach (var order in GetOrderCollection(ordersId))
{
try
{
_orderProcessingService.CancelOrder(order, true);
}
catch (Exception ex)
{
throw new ApplicationException(ex.Message);
}
}
return(errors);
}
/// <summary>
/// Cancel Order
/// </summary>
/// <returns>Return to either homepage or order details page</returns>
public IActionResult CancelOrder()
{
var orderReferenceId = _webHelper.QueryString <string>("reference_id");
if (!(_paymentPluginManager.LoadPluginBySystemName("Payments.Sezzle") is SezzlePaymentProcessor processor) || !_paymentPluginManager.IsPluginActive(processor))
{
throw new NopException("Sezzle Standard module cannot be loaded");
}
Guid orderNumberGuid = Guid.Empty;
try
{
orderNumberGuid = new Guid(orderReferenceId);
}
catch
{
return(RedirectToAction("Index", "Home", new { area = string.Empty }));
}
var order = _orderService.GetOrderByGuid(orderNumberGuid);
if (order == null)
{
return(RedirectToAction("Index", "Home", new { area = string.Empty }));
}
else if (_orderProcessingService.CanCancelOrder(order))
{
_orderProcessingService.CancelOrder(order, true);
return(RedirectToRoute("OrderDetails", new { orderId = order.Id }));
}
return(RedirectToAction("Index", "Home", new { area = string.Empty }));
}
private void UpdateOrderStatus(Order order, string status)
{
status = status.ToLower();
switch (status)
{
case "failed":
case "revoked":
{
//mark order as canceled
if ((order.PaymentStatus == PaymentStatus.Paid || order.PaymentStatus == PaymentStatus.Authorized) &&
_orderProcessingService.CanCancelOrder(order))
{
_orderProcessingService.CancelOrder(order, true);
}
}
break;
case "ok":
{
//mark order as paid
if (_orderProcessingService.CanMarkOrderAsPaid(order) && status.ToUpper() == "PAID")
{
_orderProcessingService.MarkOrderAsPaid(order);
}
}
break;
}
}
public IActionResult CancelOrder(int id)
{
if (!IsRequestAuthorized())
{
return(Unauthorized());
}
if (id <= 0)
{
return(Error(HttpStatusCode.BadRequest, "id", "invalid id"));
}
var orderToCancel = _orderApiService.GetOrderById(id);
if (orderToCancel == null)
{
return(Error(HttpStatusCode.NotFound, "order", "not found"));
}
_orderProcessingService.CancelOrder(orderToCancel, false);
var ordersRootObject = new OrdersRootObject();
var cancelledOrderDto = _dtoHelper.PrepareOrderDTO(orderToCancel);
ordersRootObject.Orders.Add(cancelledOrderDto);
var json = _jsonFieldsSerializer.Serialize(ordersRootObject, string.Empty);
return(new RawJsonActionResult(json));
}
/// <summary>
/// Cancel
/// </summary>
/// <param name="order">Order</param>
private void MarkOrderAsCancelled(Core.Domain.Orders.Order order)
{
if (_orderProcessingService.CanCancelOrder(order))
{
_orderProcessingService.CancelOrder(order, true);
}
}
public IActionResult CancelOrder()
{
var order = _orderService.SearchOrders(storeId: _storeContext.CurrentStore.Id,
customerId: _workContext.CurrentCustomer.Id, pageSize: 1).FirstOrDefault();
Order cancelOrder = null;
if (order != null)
{
cancelOrder = _orderService.GetOrderByGuid(order.OrderGuid);
/*if (Guid.TryParse(order.Id, out Guid orderGuid))
* {
* cancelOrder = _orderService.GetOrderByGuid(orderGuid);
* }*/
if (cancelOrder != null)
{
if (_orderProcessingService.CanCancelOrder(cancelOrder))
{
_orderProcessingService.CancelOrder(cancelOrder, false);
}
}
return(RedirectToRoute("OrderDetails", new { orderId = order.Id }));
}
return(RedirectToRoute("HomePage"));
}
public virtual void Execute()
{
try
{
var orderList = _orderService.SearchOrders();
foreach (var item in orderList)
{
if (item.OrderStatus == OrderStatus.Pending && DateTime.UtcNow.AddDays(-7) > item.CreatedOnUtc)
{
var order = _orderService.GetOrderById(item.Id);
if (order != null)
{
_orderProcessingService.CancelOrder(order, true);
}
}
}
}
catch (Exception exc)
{
_logger.Error(string.Format("Error cancleorder. {0}", exc.Message), exc);
}
finally
{
//queuedEmail.SentTries = queuedEmail.SentTries + 1;
//_queuedEmailService.UpdateQueuedEmail(queuedEmail);
}
}
public ActionResult IPNHandler(FormCollection form)
{
var processor = GetPaymentProcessor();
TransactionStatus txnStatus;
if (processor.VerifyIpn(form, out txnStatus))
{
var val = GetValue(Constants.OK_INVOICE_KEY, form);
int orderId;
if (!String.IsNullOrEmpty(val) && Int32.TryParse(val, out orderId))
{
var order = _orderService.GetOrderById(orderId);
if (_orderProcessingService.CanMarkOrderAsPaid(order) && txnStatus == TransactionStatus.Completed)
{
_orderProcessingService.MarkOrderAsPaid(order);
}
else if ((order.PaymentStatus == PaymentStatus.Paid ||
order.PaymentStatus == PaymentStatus.Authorized) &&
_orderProcessingService.CanCancelOrder(order) && txnStatus != TransactionStatus.Completed)
{
_orderProcessingService.CancelOrder(order, true);
}
var sb = new StringBuilder();
sb.AppendLine("OkPay IPN:");
sb.Append(PreparationOrderNote(form));
sb.AppendLine("New transaction status: " + txnStatus);
order.OrderNotes.Add(new OrderNote
{
Note = sb.ToString(),
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
_orderService.UpdateOrder(order);
}
else
{
var sb = new StringBuilder();
sb.AppendLine("OkPay error: failed order identifier");
sb.AppendLine("Transaction status: " + txnStatus);
sb.Append(PreparationOrderNote(form));
_logger.Error("OkPay IPN failed.", new NopException(sb.ToString()));
}
}
else
{
var sb = new StringBuilder();
sb.AppendLine("Transaction status: " + txnStatus);
sb.Append(PreparationOrderNote(form));
_logger.Error("OkPay IPN failed.", new NopException(sb.ToString()));
}
return(Content(""));
}
public async Task <IActionResult> CancelOrder([FromBody] OrderModel model)
{
IAccessToken accessToken = await m_token_service.GetToken(model.Token);
if (accessToken == null || accessToken.HasExpired)
{
return(Forbid());
}
model.Customer = accessToken.User;
await m_order_processing.CancelOrder(model);
return(Ok());
}
private ActionResult UpdateOrderStatus(Order order, string status)
{
status = status.ToUpper();
var textToResponse = "Your order has been paid";
switch (status)
{
case "CANCELED":
{
//mark order as canceled
if ((order.PaymentStatus == PaymentStatus.Paid || order.PaymentStatus == PaymentStatus.Authorized) &&
_orderProcessingService.CanCancelOrder(order))
{
_orderProcessingService.CancelOrder(order, true);
}
textToResponse = "Your order has been canceled";
}
break;
case "AUTHORIZED":
{
//mark order as authorized
if (_orderProcessingService.CanMarkOrderAsAuthorized(order))
{
_orderProcessingService.MarkAsAuthorized(order);
}
textToResponse = "Your order has been authorized";
}
break;
case "PAID":
{
//mark order as paid
if (_orderProcessingService.CanMarkOrderAsPaid(order) && status.ToUpper() == "PAID")
{
_orderProcessingService.MarkOrderAsPaid(order);
}
}
break;
default:
{
return(GetResponse("Unsupported status"));
}
}
return(GetResponse(textToResponse, true));
}
//NOP 3.823
public ActionResult Cancel(int orderId)
{
var order = _orderService.GetOrderById(orderId);
if (order == null || order.Deleted || _workContext.CurrentCustomer.Id != order.CustomerId)
{
return(new HttpUnauthorizedResult());
}
//Add some more validation check
if (_orderProcessingService.CanCancelOrder(order))
{
_orderProcessingService.CancelOrder(order, true);
}
return(RedirectToRoute("CustomerOrders"));
}
public ActionResult CancelOrder(FormCollection form)
{
if (_monerisStandardPaymentSettings.ReturnFromMonerisWithoutPaymentRedirectsToOrderDetailsPage)
{
var order = _orderService.SearchOrders(storeId: _storeContext.CurrentStore.Id,
customerId: _workContext.CurrentCustomer.Id, pageSize: 1)
.FirstOrDefault();
if (order != null)
{
_orderProcessingService.CancelOrder(order, false);
return(RedirectToRoute("OrderDetails", new { orderId = order.Id }));
}
}
return(RedirectToAction("Index", "Home", new { area = "" }));
}
private void OrderCanceled(Order order)
{
if (_orderProcessingService.CanCancelOrder(order))
{
_orderProcessingService.CancelOrder(order, false);
}
order.OrderNotes.Add(new OrderNote
{
Note = $"Order id {order.Id}. PayU order canceled.",
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
_orderService.UpdateOrder(order);
}
// customer can cancel order from his account 11-6-2018
public ActionResult Cancel(int orderId)
{
var order = _orderService.GetOrderById(orderId);
//I comment this two lines
if (order == null || order.Deleted || _workContext.CurrentCustomer.Id != order.CustomerId)
{
return(Challenge());
}
//Add some more validation check
if (_orderProcessingService.CanCancelOrder(order))
{
_orderProcessingService.CancelOrder(order, true);
}
return(RedirectToRoute("CustomerOrders"));
}
//My account / Order details page / Cancel Unpaid Order
public virtual async Task <IActionResult> CancelOrder(string orderId)
{
var order = await _orderService.GetOrderById(orderId);
if (order == null || order.PaymentStatus != Core.Domain.Payments.PaymentStatus.Pending ||
(order.ShippingStatus != ShippingStatus.ShippingNotRequired && order.ShippingStatus != ShippingStatus.NotYetShipped) ||
order.OrderStatus != OrderStatus.Pending ||
order.Deleted || _workContext.CurrentCustomer.Id != order.CustomerId ||
!_orderSettings.UserCanCancelUnpaidOrder)
{
return(Challenge());
}
await _orderProcessingService.CancelOrder(order, true, true);
return(RedirectToRoute("OrderDetails", new { orderId = orderId }));
}
private void ProcessOrderStateChangeNotification(string xmlData)
{
try
{
var changeOrder = (OrderStateChangeNotification)EncodeHelper.Deserialize(xmlData, typeof(OrderStateChangeNotification));
FinancialOrderState orderState = changeOrder.newfinancialorderstate;
Order order = GetMerchantOrderByGoogleOrderId(changeOrder.googleordernumber);
if (order != null)
{
string message = string.Format("Order status {0} from Google: Order Number {1}", orderState, changeOrder.googleordernumber);
LogMessage(message);
//add a note
order.OrderNotes.Add(new OrderNote()
{
Note = message,
CreatedOnUtc = DateTime.UtcNow
});
_orderService.UpdateOrder(order);
if (orderState == FinancialOrderState.CHARGING ||
orderState == FinancialOrderState.REVIEWING)
{
}
if (orderState == FinancialOrderState.CHARGEABLE)
{
_orderProcessingService.MarkAsAuthorized(order);
}
if (orderState == FinancialOrderState.CHARGED)
{
_orderProcessingService.MarkOrderAsPaid(order);
}
if (orderState == FinancialOrderState.CANCELLED || orderState == FinancialOrderState.CANCELLED_BY_GOOGLE)
{
_orderProcessingService.CancelOrder(order, true);
}
}
}
catch (Exception exc)
{
LogMessage("processOrderStateChangeNotification Exception: " + exc.Message + ": " + exc.StackTrace);
}
}
public void ProcessPostBackModel(PostBackModel model)
{
if (model == null)
{
return;
}
var orderId = GetOrderId(model.ORDERID);
var requestFields = new SortedDictionary <string, string>();
var keyValueCollection = (Request.RequestType == "POST") ? Request.Form : Request.QueryString;
var sb = new StringBuilder("Ogone Postback Fields:\r\n");
foreach (string key in keyValueCollection)
{
if (!key.ToUpper().Equals("SHASIGN"))
{
requestFields.Add(key, keyValueCollection[key]);
}
sb.AppendFormat("{0}={1};\r\n", key, keyValueCollection[key]);
}
var order = _orderService.GetOrderById(orderId);
if (order == null)
{
_logger.InsertLog(LogLevel.Error, "Invalid order id", string.Format("Ogone Postback Error. Order id {0} not found.", orderId));
return;
}
AddOrderNote(order, sb.ToString(), false);
var processor =
_paymentService.LoadPaymentMethodBySystemName("Payments.Ogone") as OgonePaymentProcessor;
if (processor == null || !processor.IsPaymentMethodActive(_paymentSettings) || !processor.PluginDescriptor.Installed)
{
throw new NopException("Ogone Payment module cannot be loaded");
}
if (processor.VerifyHashDigest(requestFields, model.SHASIGN) == false)
{
AddOrderNote(order, "Ogone Postback Error. SHA-digest verification failed", false);
return;
}
var paymentStatus = OgoneHelper.GetPaymentStatus(model.STATUS.ToString(), model.NCERROR);
switch (paymentStatus)
{
case PaymentStatus.Authorized:
if (_orderProcessingService.CanMarkOrderAsAuthorized(order))
{
_orderProcessingService.MarkAsAuthorized(order);
}
break;
case PaymentStatus.Paid:
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
_orderProcessingService.MarkOrderAsPaid(order);
}
break;
case PaymentStatus.Pending:
break;
case PaymentStatus.Voided:
if (_orderProcessingService.CanCancelOrder(order))
{
_orderProcessingService.CancelOrder(order, notifyCustomer: true);
}
break;
}
}
public IActionResult s2sHandler()
{
string errorCode = "", errorDesc = "";
string strRequest = Request.QueryString.ToString().Replace("?", "");
Dictionary <string, string> values;
var processor = _paymentPluginManager.LoadPluginBySystemName("Payments.GestPay") as GestPayPaymentProcessor;
if (processor == null ||
!_paymentPluginManager.IsPluginActive(processor))
{
throw new NopException("GestPay module cannot be loaded");
}
processor.GetResponseDetails(strRequest, out values);
if (values != null && values.Count > 0)
{
if (values.Count == 4)
{
return(RedirectToRoute("Plugin.Payments.GestPay.AcceptPaymenyByLink", new { a = values["a"], status = values["Status"], paymentId = values["paymentID"], paymentToken = values["paymentToken"] }));
}
var shopLogin = values["a"];
var encString = values["b"];
string shopTransactionId = "", authorizationCode = "", bankTransactionId = "";
string transactionResult = "", buyerName = "", buyerEmail = "", riskified = "", authorizationcode = "", threeDSAuthenticationLevel = "";
var acceptedThreeDSAuthLevels = new List <string> {
"1H", "1F", "2F", "2C", "2E"
};
var checkAmount = decimal.Zero;
var sb = new StringBuilder();
sb.AppendLine("GestPay s2s:");
if (processor.IsShopLoginChecked(shopLogin) && encString != null)
{
var endpoint = _gestPayPaymentSettings.UseSandbox ? WSCryptDecryptSoapClient.EndpointConfiguration.WSCryptDecryptSoap12Test : WSCryptDecryptSoapClient.EndpointConfiguration.WSCryptDecryptSoap12;
var objDecrypt = new WSCryptDecryptSoapClient(endpoint);
string xmlResponse = objDecrypt.DecryptAsync(shopLogin, encString, _gestPayPaymentSettings.ApiKey).Result.OuterXml;
XmlDocument XMLReturn = new XmlDocument();
XMLReturn.LoadXml(xmlResponse.ToLower());
//_logger.Information(xmlResponse.ToLower());
//Id transazione inviato
errorCode = XMLReturn.SelectSingleNode("/gestpaycryptdecrypt/errorcode")?.InnerText;
errorDesc = XMLReturn.SelectSingleNode("/gestpaycryptdecrypt/errordescription")?.InnerText;
//authorizationCode = XMLReturn.SelectSingleNode("/gestpaycryptdecrypt/authorizationcode")?.InnerText;
shopTransactionId = XMLReturn.SelectSingleNode("/gestpaycryptdecrypt/shoptransactionid")?.InnerText;
//_____ Messaggio OK _____//
if (errorCode == "0")
{
//Codice autorizzazione
authorizationCode = XMLReturn.SelectSingleNode("/gestpaycryptdecrypt/authorizationcode")?.InnerText;
//Codice transazione
bankTransactionId = XMLReturn.SelectSingleNode("/gestpaycryptdecrypt/banktransactionid")?.InnerText;
//Ammontare della transazione
var amount = XMLReturn.SelectSingleNode("/gestpaycryptdecrypt/amount")?.InnerText;
//Risultato transazione
transactionResult = XMLReturn.SelectSingleNode("/gestpaycryptdecrypt/transactionresult")?.InnerText;
//Nome dell'utente
buyerName = XMLReturn.SelectSingleNode("/gestpaycryptdecrypt/buyer/buyername")?.InnerText;
//Email utilizzata nella transazione
buyerEmail = XMLReturn.SelectSingleNode("/gestpaycryptdecrypt/buyer/buyeremail")?.InnerText;
//__________ ?validare il totale? __________//
riskified = XMLReturn.SelectSingleNode("/gestpaycryptdecrypt/riskresponsedescription")?.InnerText;
// 3DS authentication level (1H,1F,2F,2C,2E)
threeDSAuthenticationLevel = XMLReturn.SelectSingleNode("/gestpaycryptdecrypt/threeds/authenticationresult/authenticationlevel")?.InnerText?.ToUpper();
try
{
checkAmount = decimal.Parse(amount, new CultureInfo("en-US"));
}
catch (Exception exc)
{
_logger.Error("GestPay s2s. Error getting Amount", exc);
}
sb.AppendLine("GestPay success.");
}
else
{
sb.AppendLine("GestPay failed.");
_logger.Error("GestPay S2S. Transaction not found", new NopException(sb.ToString()));
}
}
//________ Inizio composizione messaggio dal server _________//
foreach (var kvp in values)
{
sb.AppendLine(kvp.Key + ": " + kvp.Value);
}
//Recupero lo stato del pagamento
var newPaymentStatus = GestPayHelper.GetPaymentStatus(transactionResult, "");
sb.AppendLine("New payment status: " + newPaymentStatus);
sb.AppendLine("Riskified = " + riskified);
sb.AppendLine("3DS Level = " + threeDSAuthenticationLevel);
//Cerco di recuperare l'ordine
var orderNumberGuid = Guid.Empty;
try
{
orderNumberGuid = new Guid(shopTransactionId);
}
catch { }
var order = _orderService.GetOrderByGuid(orderNumberGuid);
//_________ aggiorno lo stato dell'ordine _________//
if (order != null)
{
switch (newPaymentStatus)
{
case PaymentStatus.Pending:
{
}
break;
case PaymentStatus.Authorized:
{
if (_orderProcessingService.CanMarkOrderAsAuthorized(order))
{
_orderProcessingService.MarkAsAuthorized(order);
}
}
break;
case PaymentStatus.Paid:
{
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
order.AuthorizationTransactionId = bankTransactionId;
order.AuthorizationTransactionCode = authorizationCode;
_orderService.UpdateOrder(order);
if (!_gestPayPaymentSettings.EnableGuaranteedPayment || acceptedThreeDSAuthLevels.Contains(threeDSAuthenticationLevel))
{
_orderProcessingService.MarkOrderAsPaid(order);
}
}
}
break;
case PaymentStatus.Refunded:
{
if (_orderProcessingService.CanRefundOffline(order))
{
_orderProcessingService.RefundOffline(order);
}
}
break;
case PaymentStatus.Voided:
{
/*_ Visto che non si può impostare il pagamento ad Annullato
* _orderProcessingService.CanVoidOffline allora cancello l'ordine.
* C'è da decidere se avvisare o meno l'utente _*/
if (_orderProcessingService.CanCancelOrder(order))
{
_orderProcessingService.CancelOrder(order, true);
}
}
break;
}
//__________________ salvo i valori restituiti __________________//
sb.AppendLine("GestPay response:");
//Codice Errore
sb.AppendLine("ErrorCode: " + errorCode);
//Descrizione Errore
sb.AppendLine("ErrorDesc: " + errorDesc);
sb.AppendLine("TrxResult: " + transactionResult);
sb.AppendLine("BankTrxID: " + bankTransactionId);
sb.AppendLine("AuthCode: " + authorizationCode);
sb.AppendLine("Amount: " + checkAmount);
if (!Math.Round(checkAmount, 2).Equals(Math.Round(order.OrderTotal, 2)))
{
//__________ ?validare il totale? __________//
sb.AppendLine(String.Format("Amount difference: {0}-{1}", Math.Round(checkAmount, 2), Math.Round(order.OrderTotal, 2)));
}
sb.AppendLine("BuyerName: " + buyerName);
sb.AppendLine("BuyerEmail: " + buyerEmail);
//Inserisco la nota sull'ordine
var orderNote = new OrderNote
{
OrderId = order.Id,
Note = sb.ToString(),
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
};
_orderService.InsertOrderNote(orderNote);
}
else
{
_logger.Error("GestPay S2S. Order is not found", new NopException(sb.ToString()));
}
}
else
{
_logger.Error("GestPay S2S failed.", new NopException(strRequest));
}
//_________ Imposto il risultato __________//
var s2SResponse = "KO";
if (errorCode == "0")
{
s2SResponse = "OK";
}
//nothing should be rendered to visitor
return(Content(String.Format("<html>{0}</html>", s2SResponse)));
}
public ActionResult PayGateReturnHandler(FormCollection form)
{
string[] keys = Request.Form.AllKeys;
String transaction_status = "";
String pay_request_id = "";
String transaction_status_desc = "";
Order order = _orderService.GetOrderById(Int32.Parse(Request.QueryString["pgnopcommerce"]));
var sBuilder = new StringBuilder();
var query_status = PaymentStatus.Pending;
for (int i = 0; i < keys.Length; i++)
{
if (keys[i] == "TRANSACTION_STATUS")
{
transaction_status = Request.Form[keys[i]];
}
if (keys[i] == "PAY_REQUEST_ID")
{
pay_request_id = Request.Form[keys[i]];
}
}
using (var client = new System.Net.WebClient())
{
var queryData = new NameValueCollection();
queryData["PAYGATE_ID"] = _payGatePaymentSettings.PayGateID;
queryData["PAY_REQUEST_ID"] = pay_request_id;
queryData["REFERENCE"] = Request.QueryString["pgnopcommerce"];
string queryValues = string.Join("", queryData.AllKeys.Select(key => queryData[key]));
queryData["CHECKSUM"] = new PayGateHelper().CalculateMD5Hash(queryValues + _payGatePaymentSettings.EncryptionKey);
var response = client.UploadValues("https://secure.paygate.co.za/payweb3/query.trans", queryData);
var responseString = Encoding.Default.GetString(response);
if (responseString != null)
{
Dictionary <string, string> dict =
responseString.Split('&')
.Select(x => x.Split('='))
.ToDictionary(y => y[0], y => y[1]);
try
{
String trans_id = dict["TRANSACTION_STATUS"].ToString();
String query_status_desc = "";
switch (trans_id)
{
case "1":
query_status = PaymentStatus.Paid;
query_status_desc = "Approved";
break;
case "2":
query_status_desc = "Declined";
break;
case "4":
query_status_desc = "Cancelled By Customer with back button on payment page";
break;
case "0":
query_status_desc = "Not Done";
break;
default:
break;
}
sBuilder.AppendLine("PayGate Query Data");
sBuilder.AppendLine("=======================");
sBuilder.AppendLine("PayGate Transaction_Id: " + dict["TRANSACTION_ID"]);
sBuilder.AppendLine("PayGate Status Desc: " + query_status_desc);
sBuilder.AppendLine("");
} catch (Exception e)
{
sBuilder.AppendLine("PayGate Query Data");
sBuilder.AppendLine("=======================");
sBuilder.AppendLine("PayGate Query Response: " + responseString);
sBuilder.AppendLine("");
}
}
}
var new_payment_status = PaymentStatus.Pending;
switch (transaction_status)
{
case "1":
new_payment_status = PaymentStatus.Paid;
transaction_status_desc = "Approved";
break;
case "2":
transaction_status_desc = "Declined";
break;
case "4":
transaction_status_desc = "Cancelled By Customer with back button on payment page";
break;
case "0":
transaction_status_desc = "Not Done";
break;
default:
break;
}
sBuilder.AppendLine("PayGate Return Data");
sBuilder.AppendLine("=======================");
sBuilder.AppendLine("PayGate PayRequestId: " + pay_request_id);
sBuilder.AppendLine("PayGate Status Desc: " + transaction_status_desc);
//order note
order.OrderNotes.Add(new OrderNote
{
Note = sBuilder.ToString(),//sbbustring.Format("Order status has been changed to {0}", PaymentStatus.Paid),
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
_orderService.UpdateOrder(order);
//load settings for a chosen store scope
var storeScope = this.GetActiveStoreScopeConfiguration(_storeService, _workContext);
var payGatePaymentSettings = _settingService.LoadSetting <PayGatePaymentSettings>(storeScope);
//mark order as paid
if (query_status == PaymentStatus.Paid)
{
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
order.AuthorizationTransactionId = pay_request_id;
_orderService.UpdateOrder(order);
_orderProcessingService.MarkOrderAsPaid(order);
}
return(RedirectToRoute("CheckoutCompleted", new { orderId = order.Id }));
}
else if (new_payment_status == PaymentStatus.Paid)
{
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
order.AuthorizationTransactionId = pay_request_id;
_orderService.UpdateOrder(order);
_orderProcessingService.MarkOrderAsPaid(order);
}
return(RedirectToRoute("CheckoutCompleted", new { orderId = order.Id }));
}
else
{
order.AuthorizationTransactionId = pay_request_id;
OrderNote _note = new OrderNote();
_note.CreatedOnUtc = DateTime.Now;
_note.DisplayToCustomer = true;
_note.Note = "Payment failed with the following description: " + transaction_status_desc;
_orderProcessingService.CancelOrder(order, false);
order.OrderNotes.Add(_note);
_orderService.UpdateOrder(order);
return(RedirectToAction(order.Id.ToString().Trim(), "orderdetails"));
}
//return RedirectToAction("Index", "Home", new { area = "" });
}
public ActionResult Return()
{
var processor = _paymentPluginManager.LoadPluginBySystemName("Payments.Paytm") 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) && paytm.CheckSum.verifyCheckSum(workingKey, parameters, paytmChecksum))
{
checkSumMatch = true;
}
}
orderId = parameters["ORDERID"];
amount = parameters["TXNAMOUNT"];
resCode = parameters["RESPCODE"];
authDesc = parameters["STATUS"];
var order = _orderService.GetOrderById(Convert.ToInt32(orderId));
if (checkSumMatch == true)
{
if (resCode == "01" && authDesc == "TXN_SUCCESS")
{
if (TxnStatus(orderId, order.OrderTotal.ToString("0.00")))
{
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
_orderProcessingService.MarkOrderAsPaid(order);
}
return(RedirectToRoute("CheckoutCompleted", new { orderId = order.Id }));
}
else
{
return(Content("Amount Mismatch"));
}
}
else if (authDesc == "TXN_FAILURE")
{
_orderProcessingService.CancelOrder(order, false);
order.OrderStatus = OrderStatus.Cancelled;
_orderService.UpdateOrder(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 void PayGateNotifyHandler(IFormCollection form)
{
/**
* Enable IPN if it is set
*/
if (_payGatePaymentSettings.EnableIpn)
{
Response.WriteAsync("OK");
var reference = Request.Query["pgnopcommerce"];
bool isPaid;
_logger.Information("PayGateNotifyHandler start. Order no.: " + reference);
//var order = _orderService.GetOrderById(Int32.Parse(Request.Query["pgnopcommerce"]));
var order = _orderService.GetOrderById(Int32.Parse(Request.Form["USER1"]));
_logger.Information("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 = "";
string[] keys = Request.Form.Keys.ToArray();
for (int i = 0; i < keys.Length; i++)
{
formData[keys[i]] = Request.Form[keys[i]];
formDataJS += keys[i] + "=" + formData[keys[i]] + "&";
}
_logger.Information("PayGateNotifyHandler: POST: " + formDataJS);
var checksum = formData["CHECKSUM"];
var checkstring = "";
for (var i = 0; i < formData.Count - 1; i++)
{
checkstring += formData[i];
}
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
order.OrderNotes.Add(new OrderNote
{
Note = sBuilder.ToString(),//sbbustring.Format("Order status has been changed to {0}", PaymentStatus.Paid),
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
_orderService.UpdateOrder(order);
//load settings for a chosen store scope
var storeScope = this.GetActiveStoreScopeConfiguration(_storeService, _workContext);
var payGatePaymentSettings = _settingService.LoadSetting <PayGatePaymentSettings>(storeScope);
//mark order as paid
if (query_status == PaymentStatus.Paid)
{
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
order.AuthorizationTransactionId = payrequestId;
_orderService.UpdateOrder(order);
_orderProcessingService.MarkOrderAsPaid(order);
}
RedirectToRoute("CheckoutCompleted", new { orderId = order.Id });
}
else
{
order.AuthorizationTransactionId = payrequestId;
OrderNote note = new OrderNote();
note.CreatedOnUtc = DateTime.Now;
note.DisplayToCustomer = true;
note.Note = "Payment failed with the following description: " + transactionStatus;
if (_orderProcessingService.CanCancelOrder(order))
{
_orderProcessingService.CancelOrder(order, false);
}
order.OrderNotes.Add(note);
_orderService.UpdateOrder(order);
RedirectToRoute("OrderDetails", new { orderId = order.Id.ToString().Trim() });
}
}
else
{
_logger.Error("PayGateNotifyHandler: Checksum mismatch: " + ourChecksum + " : " + checksum);
}
}
}
}
public IActionResult QuickCheckoutWebhook()
{
try
{
//validate request
var isValid = _serviceManager.ValidateWebhookRequest(Request.Form);
if (!isValid)
{
return(BadRequest());
}
var orderGuid = Guid.Parse(Request.Form["transaction_id"]);
var order = _orderService.GetOrderByGuid(orderGuid);
if (order == null && _serviceManager.GetPaymentFlowType() == PaymentFlowType.Inline)
{
//order isn't placed
//try save the Skrill transaction_id for further processing
if (int.TryParse(Request.Form["nop_customer_id"].ToString(), out var customerId))
{
var customer = _customerService.GetCustomerById(customerId);
if (customer != null)
{
//status 2 - payment transaction was successful
if (Request.Form["status"].ToString().ToLower() == "2" && Request.Form.TryGetValue("mb_transaction_id", out var transactionId))
{
_genericAttributeService.SaveAttribute(customer, Defaults.PaymentTransactionIdAttribute, transactionId.ToString());
}
}
}
}
else
{
if (order == null)
{
return(Ok());
}
//add order note
var details = Request.Form.Aggregate(string.Empty, (message, parameter) => $"{message}{parameter.Key}: {parameter.Value}; ");
_orderService.InsertOrderNote(new OrderNote
{
OrderId = order.Id,
Note = $"Webhook details: {Environment.NewLine}{details}",
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
//check transaction status
switch (Request.Form["status"].ToString().ToLower())
{
//order cancelled
case "-3":
case "-2":
case "-1":
if (Enum.TryParse <FailedReasonCode>(Request.Form["failed_reason_code"], out var failedReason))
{
_orderService.InsertOrderNote(new OrderNote
{
OrderId = order.Id,
Note = $"Order cancelled. Reason: {failedReason}",
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
}
if (_orderProcessingService.CanCancelOrder(order))
{
_orderProcessingService.CancelOrder(order, true);
}
break;
//order pending
case "0":
order.OrderStatus = OrderStatus.Pending;
_orderService.UpdateOrder(order);
_orderProcessingService.CheckOrderStatus(order);
break;
//order processed
case "2":
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
if (Request.Form.TryGetValue("mb_transaction_id", out var transactionId))
{
order.CaptureTransactionId = transactionId;
}
_orderService.UpdateOrder(order);
_orderProcessingService.MarkOrderAsPaid(order);
}
break;
}
}
}
catch { }
return(Ok());
}
public ActionResult Return()
{
var processor = _paymentService.LoadPaymentMethodBySystemName("Payments.IpayAfrica") as IpayAfricaPaymentProcessor;
if (processor == null ||
!_paymentService.IsPaymentMethodActive(processor) || !processor.PluginDescriptor.Installed)
{
throw new NopException("IpayAfrica module cannot be loaded");
}
var myUtility = new IpayAfricaHelper();
string orderId, Amount, AuthDesc, ResCode;
bool checkSumMatch = false;
//Assign following values to send it to verifychecksum function.
if (String.IsNullOrWhiteSpace(_IpayAfricaPaymentSettings.MerchantKey))
{
throw new NopException("IpayAfrica key is not set");
}
string workingKey = _IpayAfricaPaymentSettings.MerchantKey;
string IpayAfricaChecksum = null;
string transactinon_code = HttpContext.Request.Query["txncd"];
string qwh = HttpContext.Request.Query["qwh"];
string afd = HttpContext.Request.Query["afd"];
string agt = HttpContext.Request.Query["agt"];
string uyt = HttpContext.Request.Query["uyt"];
string ifd = HttpContext.Request.Query["ifd"];
string poi = HttpContext.Request.Query["poi"];
string returned_order_id = HttpContext.Request.Query["id"];
string returned_order_invoice = HttpContext.Request.Query["ivm"];
string status = HttpContext.Request.Query["status"];
string paid_total = HttpContext.Request.Query["mc"] + "00";
string p1 = HttpContext.Request.Query["p1"];
string p2 = HttpContext.Request.Query["p2"];
string p3 = HttpContext.Request.Query["p3"];
string p4 = HttpContext.Request.Query["p4"];
string msisdn_id = HttpContext.Request.Query["msisdn_id"];
string msisdn_idnum = HttpContext.Request.Query["msisdn_idnum"];
string channel = HttpContext.Request.Query["channel"];
string hash_id = HttpContext.Request.Query["hsh"];
Dictionary <string, string> parameters = new Dictionary <string, string>();
Dictionary <string, string> parameters1 = new Dictionary <string, string>
{
["txncd"] = transactinon_code,
["qwh"] = qwh,
["afd"] = afd,
["poi"] = poi,
["uyt"] = uyt,
["ifd"] = ifd,
["agt"] = agt,
["id"] = returned_order_id,
["status"] = status,
["ivm"] = returned_order_invoice,
["mc"] = paid_total,
["p1"] = p1,
["p2"] = p2,
["p3"] = p3,
["p4"] = p4,
["msisdn_id"] = p1,
["msisdn_idnum"] = p2,
["channel"] = p3,
["p4"] = p4,
["hsh"] = HttpContext.Request.Query["hsh"]
};
var live = "1";
string key = _IpayAfricaPaymentSettings.MerchantKey;
var storeLocation = _webHelper.GetStoreLocation();
string vendor_id = _IpayAfricaPaymentSettings.MerchantId;
string currency = p3;
string customer_email = p1;
string mobile_number = msisdn_idnum;
string callback_url = p2;
string email_notify = "1";
string curl = p4;
if (mobile_number.Length > 10)
{
mobile_number = mobile_number.Remove(0, 3).Insert(0, "0");
}
string datastring = live.ToString() + returned_order_id + returned_order_invoice + paid_total + mobile_number + customer_email + vendor_id + currency + p1 + p2 + p3 + p4 + callback_url + email_notify + curl;
byte[] keyByte = new ASCIIEncoding().GetBytes(key);
byte[] messageBytes = new ASCIIEncoding().GetBytes(datastring);
byte[] hashmessage = new HMACSHA1(keyByte).ComputeHash(messageBytes);
String.Concat(Array.ConvertAll(hashmessage, x => x.ToString("x2")));
string hash_message = String.Concat(Array.ConvertAll(hashmessage, x => x.ToString("x2")));
if (hash_id != null)
{
IpayAfricaChecksum = hash_id;
}
if (IpayAfricaChecksum == String.Concat(Array.ConvertAll(hashmessage, x => x.ToString("x2"))))
{
checkSumMatch = true;
}
orderId = returned_order_id;
Amount = HttpContext.Request.Query["mc"];
ResCode = returned_order_invoice;
AuthDesc = status;
var order = _orderService.GetOrderById(Convert.ToInt32(orderId));
if (checkSumMatch == true)
{
if (AuthDesc == "aei7p7yrx4ae34")
{
string ipnurl2 = "https://www.ipayafrica.com/ipn/?vendor=" + _IpayAfricaPaymentSettings.MerchantId + "&id=" + HttpContext.Request.Query["id"] + "&ivm=" + HttpContext.Request.Query["ivm"] + "&qwh=" + HttpContext.Request.Query["qwh"] + "&afd=" + HttpContext.Request.Query["afd"] + "&poi=" + HttpContext.Request.Query["poi"] + "&uyt=" + HttpContext.Request.Query["uyt"] + "&ifd=" + HttpContext.Request.Query["ifd"];
string html = string.Empty;
string url = ipnurl2;
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
using (Stream stream = response.GetResponseStream())
using (StreamReader reader = new StreamReader(stream))
{
html = reader.ReadToEnd();
}
if (TxnStatus(orderId, order.OrderTotal.ToString("0.00")))
{
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
//order note
order.OrderNotes.Add(new OrderNote
{
Note = "Thank you for shopping with us. Your " + channel + " transaction was successful. Your transaction code was " + transactinon_code,
DisplayToCustomer = true,
CreatedOnUtc = DateTime.UtcNow
});
//_orderService.UpdateOrder(order);
_orderProcessingService.MarkOrderAsPaid(order);
}
return(RedirectToRoute("CheckoutCompleted", new { orderId = order.Id }));
}
else
{
//order note
order.OrderNotes.Add(new OrderNote
{
Note = "Failed due to amount mismatch. Your attempt to pay via " + channel + " was successful. Your transaction code was " + transactinon_code,
DisplayToCustomer = true,
CreatedOnUtc = DateTime.UtcNow
});
//_orderService.UpdateOrder(order);
return(Content("Amount Mismatch" + " " + html + " " + order.OrderTotal.ToString()));
}
}
else if (AuthDesc == "fe2707etr5s4wq")
{
_orderProcessingService.CancelOrder(order, false);
order.OrderStatus = OrderStatus.Cancelled;
_orderService.UpdateOrder(order);
return(RedirectToRoute("OrderDetails", new { orderId = order.Id }));
}
else
{
return(Content("Security Error. Illegal access detected. Please try again"));
}
}
else if (string.IsNullOrEmpty(IpayAfricaChecksum))
{
return(Content("Please Contact Customer Care"));
}
else if (status == "dtfi4p7yty45wq")//less paid
{
return(Content("Payment Failed. You Paid less than what was requested"));
}
else if (status == "eq3i7p5yt7645e")//more paid
{
string ipnurl2 = "https://www.ipayafrica.com/ipn/?vendor=" + _IpayAfricaPaymentSettings.MerchantId + "&id=" + HttpContext.Request.Query["id"] + "&ivm=" + HttpContext.Request.Query["ivm"] + "&qwh=" + HttpContext.Request.Query["qwh"] + "&afd=" + HttpContext.Request.Query["afd"] + "&poi=" + HttpContext.Request.Query["poi"] + "&uyt=" + HttpContext.Request.Query["uyt"] + "&ifd=" + HttpContext.Request.Query["ifd"];
string html = string.Empty;
string url = ipnurl2;
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
using (Stream stream = response.GetResponseStream())
using (StreamReader reader = new StreamReader(stream))
{
html = reader.ReadToEnd();
}
//if (html.Contains("aei7p7yrx4ae34") || html.Contains("eq3i7p5yt7645e"))
if (html.Contains("aei7p7yrx4ae34") || html.Contains("eq3i7p5yt7645e") && System.Convert.ToDecimal(paid_total) >= order.OrderTotal)
{
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
//order note
order.OrderNotes.Add(new OrderNote
{
Note = "Thank you for shopping with us. Your " + channel + " transaction was successful. Your transaction code was " + transactinon_code,
DisplayToCustomer = true,
CreatedOnUtc = DateTime.UtcNow
});
//_orderService.UpdateOrder(order);
_orderProcessingService.MarkOrderAsPaid(order);
}
return(RedirectToRoute("CheckoutCompleted", new { orderId = order.Id }));
}
else
{
//order note
order.OrderNotes.Add(new OrderNote
{
Note = "Failed due to amount mismatch. You paid " + paid_total + " instead of " + order.OrderTotal + " via " + channel + " Your transaction code was " + transactinon_code,
DisplayToCustomer = true,
CreatedOnUtc = DateTime.UtcNow
});
_orderService.UpdateOrder(order);
return(RedirectToRoute("OrderDetails", new { orderId = order.Id }));
}
}
else if (status == "bdi6p2yy76etrs")//pending
{
return(RedirectToRoute("OrderDetails", new { orderId = order.Id }));
}
else if (status == "fe2707etr5s4wq")//failed
{
//return Content("Security Error. Illegal access detected, Checksum failed");
if (_orderProcessingService.CanVoidOffline(order))
{
_orderProcessingService.VoidOffline(order);
}
return(RedirectToRoute("OrderDetails", new { orderId = order.Id }));
}
else
{
string ipnurl2 = "https://www.ipayafrica.com/ipn/?vendor=" + _IpayAfricaPaymentSettings.MerchantId + "&id=" + HttpContext.Request.Query["id"] + "&ivm=" + HttpContext.Request.Query["ivm"] + "&qwh=" + HttpContext.Request.Query["qwh"] + "&afd=" + HttpContext.Request.Query["afd"] + "&poi=" + HttpContext.Request.Query["poi"] + "&uyt=" + HttpContext.Request.Query["uyt"] + "&ifd=" + HttpContext.Request.Query["ifd"];
string html = string.Empty;
string url = ipnurl2;
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
using (Stream stream = response.GetResponseStream())
using (StreamReader reader = new StreamReader(stream))
{
html = reader.ReadToEnd();
}
if (html.Contains("aei7p7yrx4ae34") || html.Contains("eq3i7p5yt7645e") && System.Convert.ToDecimal(paid_total) >= order.OrderTotal)
{
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
//order note
order.OrderNotes.Add(new OrderNote
{
Note = "Thank you for shopping with us. Your " + channel + " transaction was successful. Your transaction code was " + transactinon_code,
DisplayToCustomer = true,
CreatedOnUtc = DateTime.UtcNow
});
_orderProcessingService.MarkOrderAsPaid(order);
}
return(RedirectToRoute("CheckoutCompleted", new { orderId = order.Id }));
}
else
{
//order note
order.OrderNotes.Add(new OrderNote
{
Note = "Failed due to amount mismatch. You paid " + paid_total + " instead of " + order.OrderTotal + " via " + channel + " Your transaction code was " + transactinon_code,
DisplayToCustomer = true,
CreatedOnUtc = DateTime.UtcNow
});
return(RedirectToRoute("OrderDetails", new { orderId = order.Id }));
}
}
}
/// <summary>
/// Cancels order
/// </summary>
/// <param name="order">Order</param>
/// <param name="notifyCustomer">True to notify customer</param>
public void CancelOrder(Order order, bool notifyCustomer)
{
_orderProcessingService.CancelOrder(order, notifyCustomer);
}
