/// <summary>
        /// Uninstall the plugin
        /// </summary>
        /// <returns>A task that represents the asynchronous operation</returns>
        public override async Task UninstallAsync()
        {
            //generic attributes
            await _avalaraTaxManager.DeleteAttributesAsync();

            //settings
            _taxSettings.ActiveTaxProviderSystemName = (await _taxPluginManager.LoadAllPluginsAsync())
                                                       .FirstOrDefault(taxProvider => !taxProvider.PluginDescriptor.SystemName.Equals(AvalaraTaxDefaults.SystemName))
                                                       ?.PluginDescriptor.SystemName;
            await _settingService.SaveSettingAsync(_taxSettings);

            _widgetSettings.ActiveWidgetSystemNames.Remove(AvalaraTaxDefaults.SystemName);
            await _settingService.SaveSettingAsync(_widgetSettings);

            await _settingService.DeleteSettingAsync <AvalaraTaxSettings>();

            //schedule task
            var task = await _scheduleTaskService.GetTaskByTypeAsync(AvalaraTaxDefaults.DownloadTaxRatesTask.Type);

            if (task is not null)
            {
                await _scheduleTaskService.DeleteTaskAsync(task);
            }

            //locales
            await _localizationService.DeleteLocaleResourcesAsync("Enums.Nop.Plugin.Tax.Avalara.Domain");

            await _localizationService.DeleteLocaleResourcesAsync("Plugins.Tax.Avalara");

            await base.UninstallAsync();
        }
Example #2
0
        /// <summary>
        /// Uninstall plugin
        /// </summary>
        /// <returns>A task that represents the asynchronous operation</returns>
        public override async Task UninstallAsync()
        {
            //settings
            await _settingService.DeleteSettingAsync <ShipStationSettings>();

            //locales
            await _localizationService.DeleteLocaleResourcesAsync("Enums.Nop.Plugin.Shipping.ShipStation");

            await _localizationService.DeleteLocaleResourcesAsync("Plugins.Shipping.ShipStation");

            await base.UninstallAsync();
        }
Example #3
0
        /// <summary>
        /// Uninstall the plugin
        /// </summary>
        /// <returns>A task that represents the asynchronous operation</returns>
        public override async Task UninstallAsync()
        {
            //locales
            await _localizationService.DeleteLocaleResourcesAsync("Plugins.Pickup.PickupInStore");

            await base.UninstallAsync();
        }
        /// <summary>
        /// Uninstall the plugin
        /// </summary>
        /// <returns>The <see cref="Task"/></returns>
        public override async Task UninstallAsync()
        {
            //settings
            await _settingService.DeleteSettingAsync <OpenPayPaymentSettings>();

            if (_widgetSettings.ActiveWidgetSystemNames.Contains(Defaults.SystemName))
            {
                _widgetSettings.ActiveWidgetSystemNames.Remove(Defaults.SystemName);
                await _settingService.SaveSettingAsync(_widgetSettings);
            }

            //schedule task
            foreach (var task in Defaults.ScheduleTasks)
            {
                if (await _scheduleTaskService.GetTaskByTypeAsync(task.Type) != null)
                {
                    await _scheduleTaskService.DeleteTaskAsync(task);
                }
            }

            //locales
            await _localizationService.DeleteLocaleResourcesAsync("Plugins.Payments.OpenPay");

            await base.UninstallAsync();
        }
Example #5
0
        public override async Task UninstallAsync()
        {
            await _localizationService.DeleteLocaleResourcesAsync(CoreLocales.Base);

            await DeleteStoredProcs();

            await base.UninstallAsync();
        }
        /// <summary>
        /// Uninstall plugin
        /// </summary>
        /// <returns>A task that represents the asynchronous operation</returns>
        public override async Task UninstallAsync()
        {
            _widgetSettings.ActiveWidgetSystemNames.Remove(FacebookPixelDefaults.SystemName);
            await _settingService.SaveSettingAsync(_widgetSettings);

            await _localizationService.DeleteLocaleResourcesAsync("Plugins.Widgets.FacebookPixel");

            await base.UninstallAsync();
        }
Example #7
0
        public override async System.Threading.Tasks.Task UninstallAsync()
        {
            await RemoveTaskAsync();

            await _localizationService.DeleteLocaleResourcesAsync(ExportOrderLocaleKeys.Base);

            await _settingService.DeleteSettingAsync <ExportOrderSettings>();

            await base.UninstallAsync();
        }
Example #8
0
        public override async Task UninstallAsync()
        {
            await RemoveTaskAsync();

            await _localizationService.DeleteLocaleResourcesAsync(AbcPromosLocales.Base);

            await _settingService.DeleteSettingAsync <AbcPromosSettings>();

            await base.UninstallAsync();
        }
        /// <summary>
        /// Uninstall the plugin
        /// </summary>
        public override async Task UninstallAsync()
        {
            //settings
            await _settingService.DeleteSettingAsync <GoogleAuthenticatorSettings>();

            //locales
            await _localizationService.DeleteLocaleResourcesAsync("Plugins.MultiFactorAuth.GoogleAuthenticator");

            await base.UninstallAsync();
        }
Example #10
0
        /// <summary>
        /// Uninstall plugin
        /// </summary>
        /// <returns>A task that represents the asynchronous operation</returns>
        public override async Task UninstallAsync()
        {
            //settings
            await _settingService.DeleteSettingAsync <NivoSliderSettings>();

            //locales
            await _localizationService.DeleteLocaleResourcesAsync("Plugins.Widgets.NivoSlider");

            await base.UninstallAsync();
        }
        /// <summary>
        /// Uninstall the plugin
        /// </summary>
        /// <returns>A task that represents the asynchronous operation</returns>
        public override async Task UninstallAsync()
        {
            //settings
            await _settingService.DeleteSettingAsync <FacebookExternalAuthSettings>();

            //locales
            await _localizationService.DeleteLocaleResourcesAsync("Plugins.ExternalAuth.Facebook");

            await base.UninstallAsync();
        }
        public override async Task UninstallAsync()
        {
            //settings
            await _settingService.DeleteSettingAsync <PayuPaymentSettings>();

            //locales
            await _localizationService.DeleteLocaleResourcesAsync("Plugins.Payments.Payu");

            await base.UninstallAsync();
        }
Example #13
0
        /// <summary>
        /// Uninstall plugin
        /// </summary>
        public override async Task UninstallAsync()
        {
            //settings
            await _settingService.DeleteSettingAsync <GoogleAnalyticsSettings>();

            //locales
            await _localizationService.DeleteLocaleResourcesAsync("Plugins.Widgets.GoogleAnalytics");

            await base.UninstallAsync();
        }
Example #14
0
        public override async Task UninstallAsync()
        {
            //settings
            await _settingService.DeleteSettingAsync <ComingSoonPageSettings>();

            //locales
            await _localizationService.DeleteLocaleResourcesAsync("Plugins.Misc.ComingSoonPage");

            await base.UninstallAsync();
        }
Example #15
0
        public override Task UninstallAsync()
        {
            _settingService.DeleteSettingAsync <LuceneSettings>();

            //locales
            _localizationService.DeleteLocaleResourcesAsync(new List <string>
            {
                "Plugins.Misc.Lucene.Fields.Enabled",
                "Plugins.Misc.Lucene.Fields.Enabled.Hint",
                "Plugins.Misc.Lucene.Fields.AutoCompleteSearchEnabled",
                "Plugins.Misc.Lucene.Fields.AutoCompleteSearchEnabled.Hint"
            });

            return(base.UninstallAsync());
        }
Example #16
0
        /// <summary>
        /// Uninstall the plugin
        /// </summary>
        /// <returns>A task that represents the asynchronous operation</returns>
        public override async Task UninstallAsync()
        {
            //smtp accounts
            foreach (var store in await _storeService.GetAllStoresAsync())
            {
                var key            = $"{nameof(SendinblueSettings)}.{nameof(SendinblueSettings.EmailAccountId)}";
                var emailAccountId = await _settingService.GetSettingByKeyAsync <int>(key, storeId : store.Id, loadSharedValueIfNotFound : true);

                var emailAccount = await _emailAccountService.GetEmailAccountByIdAsync(emailAccountId);

                if (emailAccount != null)
                {
                    await _emailAccountService.DeleteEmailAccountAsync(emailAccount);
                }
            }

            //settings
            if (_widgetSettings.ActiveWidgetSystemNames.Contains(SendinblueDefaults.SystemName))
            {
                _widgetSettings.ActiveWidgetSystemNames.Remove(SendinblueDefaults.SystemName);
                await _settingService.SaveSettingAsync(_widgetSettings);
            }
            await _settingService.DeleteSettingAsync <SendinblueSettings>();

            //generic attributes
            foreach (var store in await _storeService.GetAllStoresAsync())
            {
                var messageTemplates = await _messageTemplateService.GetAllMessageTemplatesAsync(store.Id);

                foreach (var messageTemplate in messageTemplates)
                {
                    await _genericAttributeService.SaveAttributeAsync <int?>(messageTemplate, SendinblueDefaults.TemplateIdAttribute, null);
                }
            }

            //schedule task
            var task = await _scheduleTaskService.GetTaskByTypeAsync(SendinblueDefaults.SynchronizationTask);

            if (task != null)
            {
                await _scheduleTaskService.DeleteTaskAsync(task);
            }

            //locales
            await _localizationService.DeleteLocaleResourcesAsync("Plugins.Misc.Sendinblue");

            await base.UninstallAsync();
        }
        /// <summary>
        /// Uninstall the plugin
        /// </summary>
        /// <returns>A task that represents the asynchronous operation</returns>
        public override async Task UninstallAsync()
        {
            //discount requirements
            var discountRequirements = (await _discountService.GetAllDiscountRequirementsAsync())
                                       .Where(discountRequirement => discountRequirement.DiscountRequirementRuleSystemName == DiscountRequirementDefaults.SYSTEM_NAME);

            foreach (var discountRequirement in discountRequirements)
            {
                await _discountService.DeleteDiscountRequirementAsync(discountRequirement, false);
            }

            //locales
            await _localizationService.DeleteLocaleResourcesAsync("Plugins.DiscountRules.HasAllProducts");

            await base.UninstallAsync();
        }
Example #18
0
        /// <summary>
        /// Uninstall plugin
        /// </summary>
        /// <returns>A task that represents the asynchronous operation</returns>
        public override async Task UninstallAsync()
        {
            //settings
            await _settingService.DeleteSettingAsync <What3wordsSettings>();

            if (_widgetSettings.ActiveWidgetSystemNames.Contains(What3wordsDefaults.SystemName))
            {
                _widgetSettings.ActiveWidgetSystemNames.Remove(What3wordsDefaults.SystemName);
                await _settingService.SaveSettingAsync(_widgetSettings);
            }

            //locales
            await _localizationService.DeleteLocaleResourcesAsync("Plugins.Widgets.What3words");

            await base.UninstallAsync();
        }
        /// <summary>
        /// Uninstall plugin
        /// </summary>
        /// <returns>A task that represents the asynchronous operation</returns>
        public override async Task UninstallAsync()
        {
            //settings
            await _settingService.DeleteSettingAsync <FixedOrByCountryStateZipTaxSettings>();

            //fixed rates
            var fixedRates = await(await _taxCategoryService.GetAllTaxCategoriesAsync())
                             .SelectAwait(async taxCategory => await _settingService.GetSettingAsync(string.Format(FixedOrByCountryStateZipDefaults.FixedRateSettingsKey, taxCategory.Id)))
                             .Where(setting => setting != null).ToListAsync();
            await _settingService.DeleteSettingsAsync(fixedRates);

            //locales
            await _localizationService.DeleteLocaleResourcesAsync("Plugins.Tax.FixedOrByCountryStateZip");

            await base.UninstallAsync();
        }
        /// <summary>
        /// Uninstall plugin
        /// </summary>
        /// <returns>A task that represents the asynchronous operation</returns>
        public override async Task UninstallAsync()
        {
            await _easyPostService.DeleteWebhookAsync();

            await _settingService.DeleteSettingAsync <EasyPostSettings>();

            if (_widgetSettings.ActiveWidgetSystemNames.Contains(EasyPostDefaults.SystemName))
            {
                _widgetSettings.ActiveWidgetSystemNames.Remove(EasyPostDefaults.SystemName);
                await _settingService.SaveSettingAsync(_widgetSettings);
            }

            await _localizationService.DeleteLocaleResourcesAsync("Plugins.Shipping.EasyPost");

            await base.UninstallAsync();
        }
Example #21
0
        /// <summary>
        /// Uninstall plugin
        /// </summary>
        /// <returns>A task that represents the asynchronous operation</returns>
        public override async Task UninstallAsync()
        {
            //settings
            await _settingService.DeleteSettingAsync <FixedByWeightByTotalSettings>();

            //fixed rates
            var fixedRates = await(await _shippingService.GetAllShippingMethodsAsync())
                             .SelectAwait(async shippingMethod => await _settingService.GetSettingAsync(
                                              string.Format(FixedByWeightByTotalDefaults.FixedRateSettingsKey, shippingMethod.Id)))
                             .Where(setting => setting != null).ToListAsync();
            await _settingService.DeleteSettingsAsync(fixedRates);

            //locales
            await _localizationService.DeleteLocaleResourcesAsync("Plugins.Shipping.FixedByWeightByTotal");

            await base.UninstallAsync();
        }
Example #22
0
        public override async System.Threading.Tasks.Task UninstallAsync()
        {
            await DeleteAllRelatedTasksAsync();

            var task = new ScheduleTask()
            {
                Name        = "Clear log",
                Seconds     = 3600,
                Type        = DefaultClearLogTaskType,
                Enabled     = false,
                StopOnError = false
            };
            await _scheduleTaskService.InsertTaskAsync(task);

            await _settingService.DeleteSettingAsync <EnhancedLoggingSettings>();

            await _localizationService.DeleteLocaleResourcesAsync(LocaleKey.Base);

            await base.UninstallAsync();
        }
Example #23
0
        /// <summary>
        /// Uninstall plugin
        /// </summary>
        /// <returns>A task that represents the asynchronous operation</returns>
        public override async Task UninstallAsync()
        {
            await _settingService.DeleteSettingAsync <AccessiBeSettings>();

            var stores = await _storeService.GetAllStoresAsync();

            var storeIds = new List <int> {
                0
            }.Union(stores.Select(store => store.Id));

            foreach (var storeId in storeIds)
            {
                var widgetSettings = await _settingService.LoadSettingAsync <WidgetSettings>(storeId);

                widgetSettings.ActiveWidgetSystemNames.Remove(AccessiBeDefaults.SystemName);
                await _settingService.SaveSettingAsync(widgetSettings);
            }

            await _localizationService.DeleteLocaleResourcesAsync("Plugins.Widgets.AccessiBe");

            await base.UninstallAsync();
        }
        /// <summary>
        /// Collect the UP migration expressions
        /// </summary>
        public override void Up()
        {
            if (!DataSettingsManager.IsDatabaseInstalled())
            {
                return;
            }

            //locales
            var languages  = _languageService.GetAllLanguagesAsync(true).Result;
            var languageId = languages
                             .FirstOrDefault(lang => lang.UniqueSeoCode == new CultureInfo(NopCommonDefaults.DefaultLanguageCulture).TwoLetterISOLanguageName)
                             ?.Id;

            _localizationService.AddOrUpdateLocaleResourceAsync(new Dictionary <string, string>
            {
                ["Plugins.Tax.Avalara.Configuration.Certificates"]                = "Exemption certificates",
                ["Plugins.Tax.Avalara.Configuration.Certificates.InProgress"]     = "Exemption certificates",
                ["Plugins.Tax.Avalara.Configuration.Certificates.NotProvisioned"] = "The selected company isn't configured to use exemption certificates, use the button 'Request certificate setup' below to access this feature",
                ["Plugins.Tax.Avalara.Configuration.Certificates.Provisioned"]    = "The selected company is configured to use exemption certificates",
                ["Plugins.Tax.Avalara.Configuration.Certificates.Button"]         = "Request certificate setup",
                ["Plugins.Tax.Avalara.Configuration.Common"]                          = "Common settings",
                ["Plugins.Tax.Avalara.Configuration.Credentials.Button"]              = "Check connection",
                ["Plugins.Tax.Avalara.Configuration.Credentials.Declined"]            = "Credentials declined",
                ["Plugins.Tax.Avalara.Configuration.Credentials.Verified"]            = "Credentials verified",
                ["Plugins.Tax.Avalara.Configuration.TaxCalculation"]                  = "Tax calculation",
                ["Plugins.Tax.Avalara.ExemptionCertificates"]                         = "Tax exemption certificates",
                ["Plugins.Tax.Avalara.ExemptionCertificates.Add.ExposureZone"]        = "State",
                ["Plugins.Tax.Avalara.ExemptionCertificates.Add.Fail"]                = "An error occurred while adding a certificate",
                ["Plugins.Tax.Avalara.ExemptionCertificates.Add.Success"]             = "Certificate added successfully",
                ["Plugins.Tax.Avalara.ExemptionCertificates.Description"]             = @"
                    <h3>Here you can view and manage your certificates.</h3>
                    <p>
                        The certificate document contains information about a customer's eligibility for exemption from sales.<br />
                        When you add a certificate, it will be processed and become available for use in calculating tax exemptions.<br />
                    </p>
                    <p>
                        You can also go to <a href=""{0}"" target=""_blank"">CertExpress website</a> where you can follow a step-by-step guide to enter information about your exemption certificates.
                    </p>
                    <p>
                        The certificates entered will be recorded and automatically linked to your account.
                    </p>
                    <p>If you have any questions, please <a href=""{1}"" target=""_blank"">contact us</a>.</p>",
                ["Plugins.Tax.Avalara.ExemptionCertificates.ExpirationDate"]          = "Expiration date",
                ["Plugins.Tax.Avalara.ExemptionCertificates.ExposureZone"]            = "State",
                ["Plugins.Tax.Avalara.ExemptionCertificates.None"]                    = "No downloaded certificates yet",
                ["Plugins.Tax.Avalara.ExemptionCertificates.OrderReview"]             = "Tax",
                ["Plugins.Tax.Avalara.ExemptionCertificates.OrderReview.Applied"]     = "Exemption certificate applied",
                ["Plugins.Tax.Avalara.ExemptionCertificates.OrderReview.None"]        = @"You have no valid certificates in the selected region. You can add them in your account on <a href=""{0}"" target=""_blank"" style=""color: #4ab2f1;"">this page</a>.",
                ["Plugins.Tax.Avalara.ExemptionCertificates.SignedDate"]              = "Signed date",
                ["Plugins.Tax.Avalara.ExemptionCertificates.Status"]                  = "Status",
                ["Plugins.Tax.Avalara.ExemptionCertificates.View"]                    = "View",
                ["Plugins.Tax.Avalara.Fields.AllowEditCustomer"]                      = "Allow edit info",
                ["Plugins.Tax.Avalara.Fields.AllowEditCustomer.Hint"]                 = "Determine whether to allow customers to edit their info (name, phone, address, etc) when managing certificates. If disabled, the info will be auto updated when customers change details in their accounts.",
                ["Plugins.Tax.Avalara.Fields.AutoValidateCertificate"]                = "Auto validate certificates",
                ["Plugins.Tax.Avalara.Fields.AutoValidateCertificate.Hint"]           = "Determine whether the new certificates are automatically valid, this allows your customers to make exempt purchases right away, otherwise a customer is not treated as exempt until you validate the document.",
                ["Plugins.Tax.Avalara.Fields.CustomerRoles"]                          = "Limited to customer roles",
                ["Plugins.Tax.Avalara.Fields.CustomerRoles.Hint"]                     = "Select customer roles for which exemption certificates will be available. Leave empty if you want this feature to be available to all customers.",
                ["Plugins.Tax.Avalara.Fields.DisplayNoValidCertificatesMessage"]      = "Display 'No valid certificates' message",
                ["Plugins.Tax.Avalara.Fields.DisplayNoValidCertificatesMessage.Hint"] = "Determine whether to display a message that there are no valid certificates for the customer on the order confirmation page.",
                ["Plugins.Tax.Avalara.Fields.EnableCertificates"]                     = "Enable exemption certificates",
                ["Plugins.Tax.Avalara.Fields.EnableCertificates.Hint"]                = "Determine whether to enable this feature. In this case, a new page will be added in the account section, so customers can manage their exemption certificates before making a purchase.",
                ["Plugins.Tax.Avalara.Fields.EnableCertificates.Warning"]             = "To use this feature, you need the following information from customers: name, country, state, city, address, postal code. Ensure that the appropriate Customer form fields are enabled under <a href=\"{0}\" target=\"_blank\">Customer settings</a>",
                ["Plugins.Tax.Avalara.TestTax.Button"] = "Submit",
            }, languageId).Wait();

            _localizationService.DeleteLocaleResourcesAsync(new List <string>
            {
                "Enums.Nop.Plugin.Tax.Avalara.Domain.LogType.Create",
                "Enums.Nop.Plugin.Tax.Avalara.Domain.LogType.CreateResponse",
                "Enums.Nop.Plugin.Tax.Avalara.Domain.LogType.Error",
                "Enums.Nop.Plugin.Tax.Avalara.Domain.LogType.Refund",
                "Enums.Nop.Plugin.Tax.Avalara.Domain.LogType.RefundResponse",
                "Enums.Nop.Plugin.Tax.Avalara.Domain.LogType.Void",
                "Enums.Nop.Plugin.Tax.Avalara.Domain.LogType.VoidResponse",
                "Plugins.Tax.Avalara.VerifyCredentials",
                "Plugins.Tax.Avalara.VerifyCredentials.Declined",
                "Plugins.Tax.Avalara.VerifyCredentials.Verified",
            }).Wait();

            //settings
            if (!_settingService.SettingExistsAsync(_avalaraTaxSettings, settings => settings.CompanyId).Result)
            {
                _avalaraTaxSettings.CompanyId = null;
            }
            if (!_settingService.SettingExistsAsync(_avalaraTaxSettings, settings => settings.EnableCertificates).Result)
            {
                _avalaraTaxSettings.EnableCertificates = false;
            }
            if (!_settingService.SettingExistsAsync(_avalaraTaxSettings, settings => settings.AutoValidateCertificate).Result)
            {
                _avalaraTaxSettings.AutoValidateCertificate = true;
            }
            if (!_settingService.SettingExistsAsync(_avalaraTaxSettings, settings => settings.AllowEditCustomer).Result)
            {
                _avalaraTaxSettings.AllowEditCustomer = true;
            }
            if (!_settingService.SettingExistsAsync(_avalaraTaxSettings, settings => settings.DisplayNoValidCertificatesMessage).Result)
            {
                _avalaraTaxSettings.DisplayNoValidCertificatesMessage = true;
            }
            if (!_settingService.SettingExistsAsync(_avalaraTaxSettings, settings => settings.CustomerRoleIds).Result)
            {
                _avalaraTaxSettings.CustomerRoleIds = null;
            }
            if (!_settingService.SettingExistsAsync(_avalaraTaxSettings, settings => settings.PreviewCertificate).Result)
            {
                _avalaraTaxSettings.PreviewCertificate = false;
            }
            if (!_settingService.SettingExistsAsync(_avalaraTaxSettings, settings => settings.UploadOnly).Result)
            {
                _avalaraTaxSettings.UploadOnly = false;
            }
            if (!_settingService.SettingExistsAsync(_avalaraTaxSettings, settings => settings.FillOnly).Result)
            {
                _avalaraTaxSettings.FillOnly = false;
            }
            _settingService.SaveSettingAsync(_avalaraTaxSettings).Wait();
        }
        /// <summary>
        /// Uninstall plugin
        /// </summary>
        public override async Task UninstallAsync()
        {
            //locales
            await _localizationService.DeleteLocaleResourcesAsync("Plugins.Payments.Param.UseSandbox");

            await _localizationService.DeleteLocaleResourcesAsync("Plugins.Payments.Param.UseSandbox.Hint");

            await _localizationService.DeleteLocaleResourcesAsync("Plugins.Payments.Param.ClientCode");

            await _localizationService.DeleteLocaleResourcesAsync("Plugins.Payments.Param.ClientCode.Hint");

            await _localizationService.DeleteLocaleResourcesAsync("Plugins.Payments.Param.ClientUsername");

            await _localizationService.DeleteLocaleResourcesAsync("Plugins.Payments.Param.ClientUsername.Hint");

            await _localizationService.DeleteLocaleResourcesAsync("Plugins.Payments.Param.ClientPassword");

            await _localizationService.DeleteLocaleResourcesAsync("Plugins.Payments.Param.ClientPassword.Hint");

            await _localizationService.DeleteLocaleResourcesAsync("Plugins.Payments.Param.Guid");

            await _localizationService.DeleteLocaleResourcesAsync("Plugins.Payments.Param.Guid.Hint");

            await _localizationService.DeleteLocaleResourcesAsync("Plugins.Payments.Param.Installment");

            await _localizationService.DeleteLocaleResourcesAsync("Plugins.Payments.Param.Installment.Hint");

            await _localizationService.DeleteLocaleResourcesAsync("Plugins.Payments.Param.PaymentMethodDescription");

            await base.UninstallAsync();
        }
        public override async Task UninstallAsync()
        {
            await _settingService.DeleteSettingAsync <SwiperSliderSettings>();

            await _localizationService.DeleteLocaleResourcesAsync("Nop.Plugin.Widgets.SwiperSlider");
        }