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 void Ensure_order_cannot_be_marked_as_paid_when_orderStatus_is_cancelled_or_paymentStatus_is_paid_or_refunded_or_voided()
{
var order = new Order();
foreach (OrderStatus os in Enum.GetValues(typeof(OrderStatus)))
{
foreach (PaymentStatus ps in Enum.GetValues(typeof(PaymentStatus)))
{
foreach (ShippingStatus ss in Enum.GetValues(typeof(ShippingStatus)))
{
order.OrderStatus = os;
order.PaymentStatus = ps;
order.ShippingStatus = ss;
if (os == OrderStatus.Cancelled ||
(ps == PaymentStatus.Paid || ps == PaymentStatus.Refunded || ps == PaymentStatus.Voided))
{
_orderProcessingService.CanMarkOrderAsPaid(order).ShouldBeFalse();
}
else
{
_orderProcessingService.CanMarkOrderAsPaid(order).ShouldBeTrue();
}
}
}
}
}
public void Ensure_order_cannot_be_marked_as_paid_when_orderStatus_is_cancelled_or_paymentStatus_is_paid_or_refunded_or_voided()
{
var order = new Order();
foreach (OrderStatus os in Enum.GetValues(typeof(OrderStatus)))
{
foreach (PaymentStatus ps in Enum.GetValues(typeof(PaymentStatus)))
{
foreach (ShippingStatus ss in Enum.GetValues(typeof(ShippingStatus)))
{
order.OrderStatus = os;
order.PaymentStatus = ps;
order.ShippingStatus = ss;
if (os == OrderStatus.Cancelled ||
(ps == PaymentStatus.Paid || ps == PaymentStatus.Refunded || ps == PaymentStatus.Voided))
{
Assert.IsFalse(_orderProcessingService.CanMarkOrderAsPaid(order));
}
else
{
//even if it is Unpaid - it can be marked as paid
//even if it is Unrefunded - it can be marked as paid
//the only "can't" is when order status is: Cancelled
Assert.IsTrue(_orderProcessingService.CanMarkOrderAsPaid(order));
}
}
}
}
}
private bool HandleOrderStatus(Order order, OmniKassa.Model.Enums.PaymentStatus?status)
{
if (order != null)
{
switch (status)
{
case OmniKassa.Model.Enums.PaymentStatus.COMPLETED:
{
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
order.CaptureTransactionResult = status.ToString();
_orderService.UpdateOrder(order);
_orderProcessingService.MarkOrderAsPaid(order);
}
break;
}
// TODO: handle other states as required
default:
{
break;
}
}
return(true);
}
return(false);
}
public void PostProcessPayment(PostProcessPaymentRequest postProcessPaymentRequest)
{
if (_orderProcessingService.CanMarkOrderAsPaid(postProcessPaymentRequest.Order))
{
_orderProcessingService.MarkOrderAsPaid(postProcessPaymentRequest.Order);
}
}
public ActionResult Return(FormCollection form)
{
var processor = _paymentService.LoadPaymentMethodBySystemName("Payments.Assist") as AssistPaymentProcessor;
if (processor == null ||
!processor.IsPaymentMethodActive(_paymentSettings) ||
!processor.PluginDescriptor.Installed)
{
throw new NopException("Assist module cannot be loaded");
}
var order = _orderService.GetOrderById(_webHelper.QueryString <int>("ordernumber"));
if (order == null || order.Deleted || _workContext.CurrentCustomer.Id != order.CustomerId)
{
return(new HttpUnauthorizedResult());
}
if (_assistPaymentSettings.AuthorizeOnly)
{
if (_orderProcessingService.CanMarkOrderAsAuthorized(order))
{
_orderProcessingService.MarkAsAuthorized(order);
}
}
else
{
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
_orderProcessingService.MarkOrderAsPaid(order);
}
}
return(RedirectToRoute("CheckoutCompleted", new { orderId = order.Id }));
}
public IActionResult CompletePaymentHandler(AuthorizationResponseModel model)
{
// Hard coded orderId, should be taken from response
// TODO: take parameters from payment response
int orderId = 14563;
string gateway_reference = "31293";
string gateway_message = "Success";
var order = _orderService.GetOrderById(orderId);
if (order != null)
{
//order note
order.OrderNotes.Add(new OrderNote
{
Note = "PayBright payment process: " + gateway_message,
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
_orderService.UpdateOrder(order);
}
//valid
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
order.AuthorizationTransactionId = gateway_reference;
_orderService.UpdateOrder(order);
_orderProcessingService.MarkOrderAsPaid(order);
}
// redirect to checkout complete page
return(RedirectToRoute("CheckoutCompleted", new { orderId = orderId }));
}
private void UpdateOrderPaymentStatus(BaseTransactionResult result, Order order)
{
switch (result.TransactionStatus.Value)
{
case Enumerations.TransactionStatusCode.Sale:
case Enumerations.TransactionStatusCode.Capture: // Capture should not happen here
order.CaptureTransactionId = result.TransactionNumber;
_orderService.UpdateOrder(order);
// Mark order as paid
if (result.TransactionStatus == Enumerations.TransactionStatusCode.Sale &&
_orderProcessingService.CanMarkOrderAsPaid(order))
{
_orderProcessingService.MarkOrderAsPaid(order);
}
break;
case Enumerations.TransactionStatusCode.Authorize:
order.AuthorizationTransactionId = result.TransactionNumber;
_orderService.UpdateOrder(order);
if (_orderProcessingService.CanMarkOrderAsAuthorized(order))
{
_orderProcessingService.MarkAsAuthorized(order);
}
break;
}
}
/// <summary>
/// Post process payment (used by payment gateways that require redirecting to a third-party URL)
/// </summary>
/// <param name="postProcessPaymentRequest">Payment info required for an order processing</param>
public void PostProcessPayment(PostProcessPaymentRequest postProcessPaymentRequest)
{
switch (_serviceManager.GetPaymentFlowType())
{
case PaymentFlowType.Redirection:
var redirectUrl = _serviceManager.PrepareCheckoutUrl(postProcessPaymentRequest);
if (string.IsNullOrEmpty(redirectUrl))
{
redirectUrl = _urlHelperFactory.GetUrlHelper(_actionContextAccessor.ActionContext)
.RouteUrl(Defaults.OrderDetailsRouteName, new { orderId = postProcessPaymentRequest.Order.Id });
_notificationService.ErrorNotification("Something went wrong, contact the store manager");
}
_actionContextAccessor.ActionContext.HttpContext.Response.Redirect(redirectUrl);
return;
case PaymentFlowType.Inline:
var customer = _customerService.GetCustomerById(postProcessPaymentRequest.Order.CustomerId);
if (customer != null)
{
var order = postProcessPaymentRequest.Order;
var transactionId = _genericAttributeService.GetAttribute <string>(customer, Defaults.PaymentTransactionIdAttribute);
if (!string.IsNullOrEmpty(transactionId) && _orderProcessingService.CanMarkOrderAsPaid(order))
{
order.CaptureTransactionId = transactionId;
_orderService.UpdateOrder(order);
_orderProcessingService.MarkOrderAsPaid(order);
_genericAttributeService.SaveAttribute <string>(customer, Defaults.PaymentTransactionIdAttribute, null);
}
}
return;
}
}
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"));
}
public IActionResult Success()
{
var orderId = _webHelper.QueryString <string>("x_reference");
var oxipayStatus = _webHelper.QueryString <string>("x_result");
var oxipayOrderId = _webHelper.QueryString <string>("x_gateway_reference");
var newPaymentStatus = OxipayHelper.GetPaymentStatus(oxipayStatus, null);
Order order = null;
if (Guid.TryParse(orderId, out Guid orderGuid))
{
order = _orderService.GetOrderByGuid(orderGuid);
}
if (order != null)
{
order.OrderNotes.Add(new OrderNote
{
Note = "Oxipay order ID: " + oxipayOrderId,
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
_orderService.UpdateOrder(order);
}
switch (newPaymentStatus)
{
case PaymentStatus.Pending:
{}
break;
case PaymentStatus.Paid:
{
//valid
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
_orderProcessingService.MarkOrderAsPaid(order);
}
break;
}
case PaymentStatus.Voided:
{
if (_orderProcessingService.CanVoidOffline(order))
{
_orderProcessingService.VoidOffline(order);
}
}
break;
default:
break;
}
if (order == null)
{
return(RedirectToAction("Index", "Home", new { area = string.Empty }));
}
return(RedirectToRoute("CheckoutCompleted", new { orderId = order.Id }));
}
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(""));
}
private void ApplyApcCallback(string requestMessage)
{
var apcMessage = ParseApcMessage(requestMessage);
if (apcMessage == null)
{
_logger.InsertLog(LogLevel.Warning, "Nochex APC Message is invalid", requestMessage);
return;
}
var orderGuid = apcMessage["custom"];
var transactionId = apcMessage["transaction_id"];
var status = apcMessage["status"];
if (orderGuid == null || transactionId == null || status == null)
{
_logger.InsertLog(LogLevel.Warning, "Nochex APC: Missing required data", requestMessage);
return;
}
var order = _orderService.GetOrderByGuid(new Guid(orderGuid));
if (order == null)
{
_logger.InsertLog(LogLevel.Warning, "Nochex APC: Order not found: " + orderGuid, requestMessage);
return;
}
var orderNote = new OrderNote {
Note = "Nochex APC Message Received: \r\n\r\n" + BuildFriendlyApcMessage(apcMessage),
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
};
order.OrderNotes.Add(orderNote);
_orderService.UpdateOrder(order);
var currentStatus = _settings.UseTestMode ? "test" : "live";
if (!string.Equals(status, currentStatus, StringComparison.InvariantCultureIgnoreCase))
{
_logger.InsertLog(LogLevel.Warning, "Nochex APC: Received wrong status " + status, requestMessage);
return;
}
if (!_orderProcessingService.CanMarkOrderAsPaid(order))
{
_logger.InsertLog(LogLevel.Warning, "Nochex APC: Cannot mark order as paid: " + orderGuid, requestMessage);
return;
}
order.AuthorizationTransactionId = transactionId;
_orderService.UpdateOrder(order);
_orderProcessingService.MarkOrderAsPaid(order);
}
public void ProcessOrderPaid(Order order)
{
if (order == null)
{
throw new ArgumentNullException(nameof(order));
}
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
_orderProcessingService.MarkOrderAsPaid(order);
}
}
public ActionResult Return(string orderId)
{
PGResponse oPgResp = new PGResponse();
EncryptionUtil lEncUtil = new EncryptionUtil();
string respcd = null;
string respmsg = null;
string astrResponseData = null;
string strMerchantId, astrFileName = null;
string strKey = null;
string strDigest = null;
string astrsfaDigest = null;
strMerchantId = "96084546";
astrFileName = "c://key//96084546.key";
if (Request.ServerVariables["REQUEST_METHOD"] == "POST")
{
astrResponseData = Request.Form["DATA"];
strDigest = Request.Form["EncryptedData"];
astrsfaDigest = lEncUtil.getHMAC(astrResponseData, astrFileName, strMerchantId);
if (strDigest.Equals(astrsfaDigest))
{
oPgResp.getResponse(astrResponseData);
respcd = oPgResp.RespCode;
respmsg = oPgResp.RespMessage;
if (Int32.Parse(respcd) == 0)
{
var order = _orderService.GetOrderById(Int32.Parse(orderId));
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
_orderProcessingService.MarkOrderAsPaid(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 }));
}
return(Content("Transaction Decline"));
}
else
{
return(RedirectToAction("Index", "Home", new { area = "" }));
}
}
else
{
return(RedirectToAction("Index", "Home", new { area = "" }));
}
}
public ActionResult IPN()
{
var processor = _paymentService.LoadPaymentMethodBySystemName("Payments.WayForPay") as WayForPayPaymentPlugin;
if (processor == null ||
!processor.IsPaymentMethodActive(_paymentSettings) || !processor.PluginDescriptor.Installed)
{
throw new NopException("WayForPay module cannot be loaded");
}
var data = JsonConvert.DeserializeObject <Payment>(Request.Form[0]);
if (data == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var orderIdStr = data.OrderReference.Replace(WayForPayConstants.InvoicePrefix, "");
int orderId;
if (!int.TryParse(orderIdStr, out orderId))
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var order = _orderService.GetOrderById(orderId);
if (order == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
WriteOrderNote(order, FormatContent(Request.Form[0]));
var collection = JsonConvert.DeserializeObject <IDictionary <string, object> >(Request.Form[0]);
if (!_wayForPayService.IsValidSignature(collection, data.MerchantSignature))
{
WriteOrderNote(order, "Not valid signature");
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
if (IsOrderPaid(data.ReasonCode, data.TransactionStatus) && _orderProcessingService.CanMarkOrderAsPaid(order))
{
WriteOrderNote(order, $"New payment status: {PaymentStatus.Paid}");
_orderProcessingService.MarkOrderAsPaid(order);
}
WriteAck(data.OrderReference);
return(new HttpStatusCodeResult(HttpStatusCode.OK));
}
public ActionResult IPNHandler()
{
var stream = new StreamReader(_httpContext.Request.InputStream);
var invoice = JsonConvert.DeserializeObject <Invoice>(stream.ReadToEnd());
if (invoice == null)
{
return(Content(""));
}
var id = invoice.Id;
var bitpay = new BitPayAPI.BitPay(envUrl: BitpayHelper.GetEnvironmentUrl(_bitpaySettings));
invoice = bitpay.getInvoice(id);
var order = _orderService.GetOrderById(int.Parse(invoice.PosData));
if (order == null)
{
return(Content(""));
}
order.OrderNotes.Add(new OrderNote
{
CreatedOnUtc = DateTime.UtcNow,
DisplayToCustomer = false,
Note = $"Bitpay IPN handler. Incoming status is: {invoice.Status}"
});
_orderService.UpdateOrder(order);
switch (invoice.Status)
{
case "new":
break;
case "paid":
case "confirmed":
case "complete":
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
_orderProcessingService.MarkOrderAsPaid(order);
}
break;
default:
break;
}
return(Content(""));
}
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));
}
public ActionResult MerchantReturn(FormCollection form)
{
var processor =
_paymentService.LoadPaymentMethodBySystemName("Payments.eWayHosted") as eWayHostedPaymentProcessor;
if (processor == null ||
!processor.IsPaymentMethodActive(_paymentSettings) || !processor.PluginDescriptor.Installed)
{
throw new NopException("eWayHosted module cannot be loaded");
}
var accessPaymentCode = string.Empty;
if (form["AccessPaymentCode"] != null)
{
accessPaymentCode = Request.Form["AccessPaymentCode"];
}
//get the result of the transaction based on the unique payment code
var validationResult = processor.CheckAccessCode(accessPaymentCode);
if (!string.IsNullOrEmpty(validationResult.ErrorMessage))
{
//failed
return(RedirectToAction("Index", "Home", new { area = "" }));
}
if (string.IsNullOrEmpty(validationResult.TrxnStatus) ||
!validationResult.TrxnStatus.ToLower().Equals("true"))
{
//failed
return(RedirectToAction("Index", "Home", new { area = "" }));
}
var orderId = Convert.ToInt32(validationResult.MerchnatOption1);
var order = _orderService.GetOrderById(orderId);
if (order == null)
{
return(RedirectToAction("Index", "Home", new { area = "" }));
}
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
_orderProcessingService.MarkOrderAsPaid(order);
}
return(RedirectToRoute("CheckoutCompleted", new { orderId = order.Id }));
}
public ActionResult Callback()
{
PayPointCallback payPointPaymentCallback = null;
try
{
using (var streamReader = new StreamReader(HttpContext.Request.InputStream))
{
payPointPaymentCallback = JsonConvert.DeserializeObject <PayPointCallback>(streamReader.ReadToEnd());
}
}
catch (Exception ex)
{
_logger.Error("PayPoint callback error", ex);
return(new HttpStatusCodeResult(HttpStatusCode.OK));
}
if (payPointPaymentCallback.Transaction.Status != PayPointStatus.SUCCESS)
{
_logger.Error(string.Format("PayPoint callback error. Transaction is {0}", payPointPaymentCallback.Transaction.Status));
return(new HttpStatusCodeResult(HttpStatusCode.OK));
}
Guid orderGuid;
if (!Guid.TryParse(payPointPaymentCallback.Transaction.MerchantRef, out orderGuid))
{
_logger.Error("PayPoint callback error. Data is not valid");
return(new HttpStatusCodeResult(HttpStatusCode.OK));
}
var order = _orderService.GetOrderByGuid(orderGuid);
if (order == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.OK));
}
//paid order
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
order.CaptureTransactionId = payPointPaymentCallback.Transaction.TransactionId;
_orderService.UpdateOrder(order);
_orderProcessingService.MarkOrderAsPaid(order);
}
return(new HttpStatusCodeResult(HttpStatusCode.OK));
}
/// <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);
}
}
}
}
}
public IActionResult SuccessCallbackHandler(IpnModel model)
{
var processor = _paymentService.LoadPaymentMethodBySystemName("Payments.Moneris") as MonerisPaymentProcessor;
if (processor == null || !processor.IsPaymentMethodActive(_paymentSettings) || !processor.PluginDescriptor.Installed)
{
throw new NopException("Moneris module cannot be loaded");
}
var parameters = model.Form;
if (string.IsNullOrEmpty(GetValue("transactionKey", parameters)) || string.IsNullOrEmpty(GetValue("rvar_order_id", parameters)))
{
return(RedirectToAction("Index", "Home", new { area = "" }));
}
var transactionKey = GetValue("transactionKey", parameters);
if (!processor.TransactionVerification(transactionKey, out Dictionary <string, string> values))
{
return(RedirectToAction("Index", "Home", new { area = "" }));
}
var orderIdValue = GetValue("rvar_order_id", parameters);
if (!int.TryParse(orderIdValue, out int orderId))
{
return(RedirectToAction("Index", "Home", new { area = "" }));
}
var order = _orderService.GetOrderById(orderId);
if (order == null || !_orderProcessingService.CanMarkOrderAsPaid(order))
{
return(RedirectToAction("Index", "Home", new { area = "" }));
}
if (values.ContainsKey("txn_num"))
{
order.AuthorizationTransactionId = values["txn_num"];
_orderService.UpdateOrder(order);
}
_orderProcessingService.MarkOrderAsPaid(order);
return(RedirectToRoute("CheckoutCompleted", new { orderId = order.Id }));
}
private void OrderCompleted(Notification notification, Order order)
{
if (!decimal.TryParse(notification?.Order?.TotalAmount, out var totalAmount))
{
return;
}
var targetCurrency =
_currencyService.GetCurrencyByCode(order.CustomerCurrencyCode);
var orderTotal = PriceInPayUStandard(order.OrderTotal, targetCurrency);
if (totalAmount == orderTotal)
{
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
order.CaptureTransactionId = notification?.Order?.OrderId;
order.OrderNotes.Add(new OrderNote
{
Note = $"PayU order id {order.CaptureTransactionId}",
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
_orderService.UpdateOrder(order);
_orderProcessingService.MarkOrderAsPaid(order);
}
}
else
{
var error =
$"PayU order id {notification?.Order?.OrderId}. Order id {order.Id}. PayU returned order total {totalAmount}. Order total should be equal to {order.OrderTotal}.";
_logger.Error(error);
order.OrderNotes.Add(new OrderNote
{
Note = error,
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
_orderService.UpdateOrder(order);
}
}
public ActionResult CallBack(YandexRequestModel model)
{
YandexResponceModel responce = _CheckRequest(model, model.action);
string responseType = "";
switch (this.Request.Form["action"])
{
case "checkOrder":
responseType = "checkOrderResponse";
break;
case "paymentAviso":
responseType = "paymentAvisoResponse";
if (responce.code == 0)
{
try
{
Order order = _orderService.GetOrderById(Convert.ToInt32(model.orderNumber));
if (order != null && _orderProcessingService.CanMarkOrderAsPaid(order))
{
order.AuthorizationTransactionId = model.invoiceId.ToString();
_orderService.UpdateOrder(order);
_orderProcessingService.MarkOrderAsPaid(order);
responce.code = 0;
}
else
{
responce.code = 200;
}
}
catch
{
responce.code = 200;
}
}
break;
}
return(new XmlActionResult(MakeXml(responseType, responce)));
}
/// <summary>
/// Paid
/// </summary>
/// <param name="order">Order</param>
/// <param name="capture">Capture</param>
private void MarkOrderAsPaid(Core.Domain.Orders.Order order, Capture capture)
{
//compare amounts
var orderTotal = Math.Round(order.OrderTotal, 2);
if (!decimal.TryParse(capture.Amount?.Value, out var capturedAmount) || capturedAmount != orderTotal)
{
return;
}
//all is ok, so paid order
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
order.CaptureTransactionId = capture.Id;
order.CaptureTransactionResult = capture.Status;
_orderService.UpdateOrder(order);
_orderProcessingService.MarkOrderAsPaid(order);
}
}
public IActionResult PayFastResultHandler(IpnModel model)
{
var form = model.Form;
//validation
if (!ValidateITN(form, out Order order))
{
return(new StatusCodeResult((int)HttpStatusCode.OK));
}
//paid order
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
order.AuthorizationTransactionId = form["pf_payment_id"];
_orderService.UpdateOrder(order);
_orderProcessingService.MarkOrderAsPaid(order);
}
return(new StatusCodeResult((int)HttpStatusCode.OK));
}
public ActionResult IPNHandler(FormCollection form)
{
var processor = _paymentService.LoadPaymentMethodBySystemName("Payments.ChronoPay") as ChronoPayPaymentProcessor;
if (processor == null || !processor.IsPaymentMethodActive(_paymentSettings) || !processor.PluginDescriptor.Installed)
{
throw new NopException("ChronoPay module cannot be loaded");
}
int orderId;
if (HostedPaymentHelper.ValidateResponseSign(form, _chronoPayPaymentSettings.SharedSecrect) && int.TryParse(form["cs1"], out orderId))
{
var order = _orderService.GetOrderById(orderId);
if (order != null && _orderProcessingService.CanMarkOrderAsPaid(order))
{
_orderProcessingService.MarkOrderAsPaid(order);
}
}
return(RedirectToAction("Index", "Home", new { area = "" }));
}
public ActionResult PayFastResultHandler(FormCollection form)
{
//validation
Order order;
if (!ValidateITN(form, out order))
{
return(new HttpStatusCodeResult(HttpStatusCode.OK));
}
//paid order
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
order.AuthorizationTransactionId = form["pf_payment_id"];
_orderService.UpdateOrder(order);
_orderProcessingService.MarkOrderAsPaid(order);
}
return(new HttpStatusCodeResult(HttpStatusCode.OK));
}
public async Task <ActionResult> MerchantReturn()
{
string spData = Request["spdata"];
string url = string.Format("https://shurjopay.com/merchant/decrypt.php?data={0}", spData);
var response = await _client.GetAsync(url);
var xmlResponse = await response.Content.ReadAsStringAsync();
XDocument reader = XDocument.Parse(xmlResponse);
var xmlElements = reader.Root;
var txId = xmlElements.Descendants("txID").First().Value;
var bankTxStatus = xmlElements.Descendants("bankTxStatus").First().Value;
if (bankTxStatus == "SUCCESS")
{
//SUCCESS
var postProcessPaymentRequest = (PostProcessPaymentRequest)Session["MyPostProcessPaymentRequest"];
var orderId = Convert.ToInt32(postProcessPaymentRequest.Order.Id);
var order = _orderService.GetOrderById(orderId);
if (order == null)
{
return(RedirectToAction("Index", "Home", new { area = "" }));
}
order.AuthorizationTransactionId = txId;
_orderService.UpdateOrder(order);
if (_orderProcessingService.CanMarkOrderAsPaid(order))
{
_orderProcessingService.MarkOrderAsPaid(order);
}
return(RedirectToRoute("CheckoutCompleted", new { orderId = order.Id }));
}
else
{
return(RedirectToAction("Index", "Home", new { area = "" }));
}
}
public ActionResult SuccessCallbackHandler()
{
var processor = _paymentService.LoadPaymentMethodBySystemName("Payments.Moneris") as MonerisPaymentProcessor;
if (processor == null || !processor.IsPaymentMethodActive(_paymentSettings) || !processor.PluginDescriptor.Installed)
{
throw new NopException("Moneris module cannot be loaded");
}
if (Request.Params != null && Request.Params.Count > 0)
{
if (Request.Params.AllKeys.Contains("transactionKey") &&
Request.Params.AllKeys.Contains("rvar_order_id"))
{
var transactionKey = Request.Params["transactionKey"];
Dictionary <string, string> values;
if (processor.TransactionVerification(transactionKey, out values))
{
var orderIdValue = Request.Params["rvar_order_id"];
int orderId;
if (int.TryParse(orderIdValue, out orderId))
{
var order = _orderService.GetOrderById(orderId);
if (order != null && _orderProcessingService.CanMarkOrderAsPaid(order))
{
if (values.ContainsKey("txn_num"))
{
order.AuthorizationTransactionId = values["txn_num"];
_orderService.UpdateOrder(order);
}
_orderProcessingService.MarkOrderAsPaid(order);
return(RedirectToRoute("CheckoutCompleted", new { orderId = order.Id }));
}
}
}
}
}
return(RedirectToAction("Index", "Home", new { area = "" }));
}
