public async Task <IActionResult> NewPullPayment([ModelBinder(typeof(WalletIdModelBinder))]
                                                         WalletId walletId, NewPullPaymentModel model)
        {
            if (GetDerivationSchemeSettings(walletId) == null)
            {
                return(NotFound());
            }

            var storeMethods         = CurrentStore.GetSupportedPaymentMethods(NetworkProvider).Select(method => method.PaymentId).ToList();
            var paymentMethodOptions = _payoutHandlers.GetSupportedPaymentMethods(storeMethods);

            model.PaymentMethodItems =
                paymentMethodOptions.Select(id => new SelectListItem(id.ToPrettyString(), id.ToString(), true));
            model.Name ??= string.Empty;
            model.Currency = model.Currency.ToUpperInvariant().Trim();
            if (!model.PaymentMethods.Any())
            {
                ModelState.AddModelError(nameof(model.PaymentMethods), "You need at least one payment method");
            }
            if (_currencyTable.GetCurrencyData(model.Currency, false) is null)
            {
                ModelState.AddModelError(nameof(model.Currency), "Invalid currency");
            }
            if (model.Amount <= 0.0m)
            {
                ModelState.AddModelError(nameof(model.Amount), "The amount should be more than zero");
            }
            if (model.Name.Length > 50)
            {
                ModelState.AddModelError(nameof(model.Name), "The name should be maximum 50 characters.");
            }

            var selectedPaymentMethodIds = model.PaymentMethods.Select(PaymentMethodId.Parse).ToArray();

            if (!selectedPaymentMethodIds.All(id => selectedPaymentMethodIds.Contains(id)))
            {
                ModelState.AddModelError(nameof(model.Name), "Not all payment methods are supported");
            }
            if (!ModelState.IsValid)
            {
                return(View(model));
            }
            await _pullPaymentService.CreatePullPayment(new HostedServices.CreatePullPayment()
            {
                Name             = model.Name,
                Amount           = model.Amount,
                Currency         = model.Currency,
                StoreId          = walletId.StoreId,
                PaymentMethodIds = selectedPaymentMethodIds,
                EmbeddedCSS      = model.EmbeddedCSS,
                CustomCSSLink    = model.CustomCSSLink
            });

            this.TempData.SetStatusMessageModel(new StatusMessageModel()
            {
                Message  = "Pull payment request created",
                Severity = StatusMessageModel.StatusSeverity.Success
            });
            return(RedirectToAction(nameof(PullPayments), new { walletId = walletId.ToString() }));
        }
Beispiel #2
0
        public async Task <IActionResult> NewPullPayment([ModelBinder(typeof(WalletIdModelBinder))]
                                                         WalletId walletId, NewPullPaymentModel model)
        {
            if (GetDerivationSchemeSettings(walletId) == null)
            {
                return(NotFound());
            }

            model.Name ??= string.Empty;
            model.Currency = model.Currency.ToUpperInvariant().Trim();
            if (_currencyTable.GetCurrencyData(model.Currency, false) is null)
            {
                ModelState.AddModelError(nameof(model.Currency), "Invalid currency");
            }
            if (model.Amount <= 0.0m)
            {
                ModelState.AddModelError(nameof(model.Amount), "The amount should be more than zero");
            }
            if (model.Name.Length > 50)
            {
                ModelState.AddModelError(nameof(model.Name), "The name should be maximum 50 characters.");
            }
            var paymentMethodId = walletId.GetPaymentMethodId();
            var n = this.NetworkProvider.GetNetwork <BTCPayNetwork>(paymentMethodId.CryptoCode);

            if (n is null || paymentMethodId.PaymentType != PaymentTypes.BTCLike || n.ReadonlyWallet)
            {
                ModelState.AddModelError(nameof(model.Name), "Pull payments are not supported with this wallet");
            }
            if (!ModelState.IsValid)
            {
                return(View(model));
            }
            await _pullPaymentService.CreatePullPayment(new HostedServices.CreatePullPayment()
            {
                Name             = model.Name,
                Amount           = model.Amount,
                Currency         = model.Currency,
                StoreId          = walletId.StoreId,
                PaymentMethodIds = new[] { paymentMethodId },
                EmbeddedCSS      = model.EmbeddedCSS,
                CustomCSSLink    = model.CustomCSSLink
            });

            this.TempData.SetStatusMessageModel(new StatusMessageModel()
            {
                Message  = "Pull payment request created",
                Severity = StatusMessageModel.StatusSeverity.Success
            });
            return(RedirectToAction(nameof(PullPayments), new { walletId = walletId.ToString() }));
        }
Beispiel #3
0
        public async Task <IActionResult> NewPullPayment([ModelBinder(typeof(WalletIdModelBinder))]
                                                         WalletId walletId, NewPullPaymentModel model)
        {
            model.Name ??= string.Empty;
            if (_currencyTable.GetCurrencyData(model.Currency, false) is null)
            {
                ModelState.AddModelError(nameof(model.Currency), "Invalid currency");
            }
            if (model.Amount <= 0.0m)
            {
                ModelState.AddModelError(nameof(model.Amount), "The amount should be more than zero");
            }
            if (model.Name.Length > 50)
            {
                ModelState.AddModelError(nameof(model.Name), "The name should be maximum 50 characters.");
            }
            if (!ModelState.IsValid)
            {
                return(View(model));
            }
            await _pullPaymentService.CreatePullPayment(new HostedServices.CreatePullPayment()
            {
                Name             = model.Name,
                Amount           = model.Amount,
                Currency         = walletId.CryptoCode,
                StoreId          = walletId.StoreId,
                PaymentMethodIds = new[] { new PaymentMethodId(walletId.CryptoCode, PaymentTypes.BTCLike) }
            });

            this.TempData.SetStatusMessageModel(new StatusMessageModel()
            {
                Message  = "Pull payment request created",
                Severity = StatusMessageModel.StatusSeverity.Success
            });
            return(RedirectToAction(nameof(PullPayments), new { walletId = walletId.ToString() }));
        }
        public async Task <IActionResult> NewPullPayment(string storeId, NewPullPaymentModel model)
        {
            if (CurrentStore is null)
            {
                return(NotFound());
            }

            var paymentMethodOptions = await _payoutHandlers.GetSupportedPaymentMethods(CurrentStore);

            model.PaymentMethodItems =
                paymentMethodOptions.Select(id => new SelectListItem(id.ToPrettyString(), id.ToString(), true));
            model.Name ??= string.Empty;
            model.Currency = model.Currency?.ToUpperInvariant()?.Trim() ?? String.Empty;
            model.PaymentMethods ??= new List <string>();
            if (!model.PaymentMethods.Any())
            {
                // Since we assign all payment methods to be selected by default above we need to update
                // them here to reflect user's selection so that they can correct their mistake
                model.PaymentMethodItems = paymentMethodOptions.Select(id => new SelectListItem(id.ToPrettyString(), id.ToString(), false));
                ModelState.AddModelError(nameof(model.PaymentMethods), "You need at least one payment method");
            }
            if (_currencyNameTable.GetCurrencyData(model.Currency, false) is null)
            {
                ModelState.AddModelError(nameof(model.Currency), "Invalid currency");
            }
            if (model.Amount <= 0.0m)
            {
                ModelState.AddModelError(nameof(model.Amount), "The amount should be more than zero");
            }
            if (model.Name.Length > 50)
            {
                ModelState.AddModelError(nameof(model.Name), "The name should be maximum 50 characters.");
            }

            var selectedPaymentMethodIds = model.PaymentMethods.Select(PaymentMethodId.Parse).ToArray();

            if (!selectedPaymentMethodIds.All(id => selectedPaymentMethodIds.Contains(id)))
            {
                ModelState.AddModelError(nameof(model.Name), "Not all payment methods are supported");
            }
            if (!ModelState.IsValid)
            {
                return(View(model));
            }
            await _pullPaymentService.CreatePullPayment(new HostedServices.CreatePullPayment()
            {
                Name             = model.Name,
                Amount           = model.Amount,
                Currency         = model.Currency,
                StoreId          = storeId,
                PaymentMethodIds = selectedPaymentMethodIds,
                EmbeddedCSS      = model.EmbeddedCSS,
                CustomCSSLink    = model.CustomCSSLink,
                BOLT11Expiration = TimeSpan.FromDays(model.BOLT11Expiration)
            });

            this.TempData.SetStatusMessageModel(new StatusMessageModel()
            {
                Message  = "Pull payment request created",
                Severity = StatusMessageModel.StatusSeverity.Success
            });
            return(RedirectToAction(nameof(PullPayments), new { storeId = storeId }));
        }