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 = "" })); }