public async Task <IActionResult> Configure()
{
if (!await _permissionService.AuthorizeAsync(StandardPermissionProvider.ManagePaymentMethods))
{
return(AccessDeniedView());
}
//load settings for a chosen store scope
var storeScope = await _storeContext.GetActiveStoreScopeConfigurationAsync();
var manualPaymentSettings = await _settingService.LoadSettingAsync <ManualPaymentSettings>(storeScope);
var model = new ConfigurationModel
{
TransactModeId = Convert.ToInt32(manualPaymentSettings.TransactMode),
AdditionalFee = manualPaymentSettings.AdditionalFee,
AdditionalFeePercentage = manualPaymentSettings.AdditionalFeePercentage,
TransactModeValues = await manualPaymentSettings.TransactMode.ToSelectListAsync(),
ActiveStoreScopeConfiguration = storeScope
};
if (storeScope > 0)
{
model.TransactModeId_OverrideForStore = await _settingService.SettingExistsAsync(manualPaymentSettings, x => x.TransactMode, storeScope);
model.AdditionalFee_OverrideForStore = await _settingService.SettingExistsAsync(manualPaymentSettings, x => x.AdditionalFee, storeScope);
model.AdditionalFeePercentage_OverrideForStore = await _settingService.SettingExistsAsync(manualPaymentSettings, x => x.AdditionalFeePercentage, storeScope);
}
return(View("~/Plugins/Payments.Manual/Views/Configure.cshtml", model));
}
public async Task <IActionResult> LogList(TaxTransactionLogSearchModel searchModel)
{
if (!await _permissionService.AuthorizeAsync(StandardPermissionProvider.ManageTaxSettings))
{
return(await AccessDeniedDataTablesJson());
}
//prepare filter parameters
var createdFromValue = searchModel.CreatedFrom.HasValue
? (DateTime?)_dateTimeHelper.ConvertToUtcTime(searchModel.CreatedFrom.Value, await _dateTimeHelper.GetCurrentTimeZoneAsync())
: null;
var createdToValue = searchModel.CreatedTo.HasValue
? (DateTime?)_dateTimeHelper.ConvertToUtcTime(searchModel.CreatedTo.Value, await _dateTimeHelper.GetCurrentTimeZoneAsync()).AddDays(1)
: null;
//get tax transaction log
var taxtransactionLog = await _taxTransactionLogService.GetTaxTransactionLogAsync(createdFromUtc : createdFromValue, createdToUtc : createdToValue,
pageIndex : searchModel.Page - 1, pageSize : searchModel.PageSize);
//prepare grid model
var model = await new TaxTransactionLogListModel().PrepareToGridAsync(searchModel, taxtransactionLog, () =>
{
return(taxtransactionLog.SelectAwait(async logItem => new TaxTransactionLogModel
{
Id = logItem.Id,
StatusCode = logItem.StatusCode,
Url = logItem.Url,
CustomerId = logItem.CustomerId,
CreatedDate = await _dateTimeHelper.ConvertToUserTimeAsync(logItem.CreatedDateUtc, DateTimeKind.Utc)
}));
});
return(Json(model));
}
public async Task <IActionResult> Configure()
{
if (!await _permissionService.AuthorizeAsync(StandardPermissionProvider.ManagePaymentMethods))
{
return(AccessDeniedView());
}
//load settings for a chosen store scope
var storeScope = await _storeContext.GetActiveStoreScopeConfigurationAsync();
var purchaseOrderPaymentSettings = await _settingService.LoadSettingAsync <PurchaseOrderPaymentSettings>(storeScope);
var model = new ConfigurationModel
{
AdditionalFee = purchaseOrderPaymentSettings.AdditionalFee,
AdditionalFeePercentage = purchaseOrderPaymentSettings.AdditionalFeePercentage,
ShippableProductRequired = purchaseOrderPaymentSettings.ShippableProductRequired,
ActiveStoreScopeConfiguration = storeScope
};
if (storeScope > 0)
{
model.AdditionalFee_OverrideForStore = await _settingService.SettingExistsAsync(purchaseOrderPaymentSettings, x => x.AdditionalFee, storeScope);
model.AdditionalFeePercentage_OverrideForStore = await _settingService.SettingExistsAsync(purchaseOrderPaymentSettings, x => x.AdditionalFeePercentage, storeScope);
model.ShippableProductRequired_OverrideForStore = await _settingService.SettingExistsAsync(purchaseOrderPaymentSettings, x => x.ShippableProductRequired, storeScope);
}
return(View("~/Plugins/Payments.PurchaseOrder/Views/Configure.cshtml", model));
}
/// <returns>A task that represents the asynchronous operation</returns>
public virtual async Task <IActionResult> Methods(bool showtour = false)
{
if (!await _permissionService.AuthorizeAsync(StandardPermissionProvider.ManagePaymentMethods))
{
return(AccessDeniedView());
}
//prepare model
var model = await _paymentModelFactory.PreparePaymentMethodsModelAsync(new PaymentMethodsModel());
//show configuration tour
if (showtour)
{
var hideCard = await _genericAttributeService.GetAttributeAsync <bool>(await _workContext.GetCurrentCustomerAsync(), NopCustomerDefaults.HideConfigurationStepsAttribute);
var closeCard = await _genericAttributeService.GetAttributeAsync <bool>(await _workContext.GetCurrentCustomerAsync(), NopCustomerDefaults.CloseConfigurationStepsAttribute);
if (!hideCard && !closeCard)
{
ViewBag.ShowTour = true;
}
}
return(View(model));
}
public virtual async Task <IActionResult> Category(int categoryId, CatalogProductsCommand command)
{
var category = await _categoryService.GetCategoryByIdAsync(categoryId);
if (!await CheckCategoryAvailabilityAsync(category))
{
return(InvokeHttp404());
}
//'Continue shopping' URL
await _genericAttributeService.SaveAttributeAsync(await _workContext.GetCurrentCustomerAsync(),
NopCustomerDefaults.LastContinueShoppingPageAttribute,
_webHelper.GetThisPageUrl(false),
(await _storeContext.GetCurrentStoreAsync()).Id);
//display "edit" (manage) link
if (await _permissionService.AuthorizeAsync(StandardPermissionProvider.AccessAdminPanel) && await _permissionService.AuthorizeAsync(StandardPermissionProvider.ManageCategories))
{
DisplayEditLink(Url.Action("Edit", "Category", new { id = category.Id, area = AreaNames.Admin }));
}
//activity log
await _customerActivityService.InsertActivityAsync("PublicStore.ViewCategory",
string.Format(await _localizationService.GetResourceAsync("ActivityLog.PublicStore.ViewCategory"), category.Name), category);
//model
var model = await _catalogModelFactory.PrepareCategoryModelAsync(category, command);
//template
var templateViewPath = await _catalogModelFactory.PrepareCategoryTemplateViewPathAsync(category.CategoryTemplateId);
return(View(templateViewPath, model));
}
public async Task <IActionResult> Configure()
{
if (!await _permissionService.AuthorizeAsync(StandardPermissionProvider.ManageWidgets))
{
return(AccessDeniedView());
}
var storeId = await _storeContext.GetActiveStoreScopeConfigurationAsync();
var settings = await _settingService.LoadSettingAsync <AccessiBeSettings>(storeId);
var widgetSettings = await _settingService.LoadSettingAsync <WidgetSettings>(storeId);
var model = new ConfigurationModel
{
Script = settings.Script,
Enabled = widgetSettings.ActiveWidgetSystemNames.Contains(AccessiBeDefaults.SystemName),
ActiveStoreScopeConfiguration = storeId
};
if (storeId > 0)
{
model.Script_OverrideForStore = await _settingService.SettingExistsAsync(settings, setting => setting.Script, storeId);
model.Enabled_OverrideForStore = await _settingService.SettingExistsAsync(widgetSettings, setting => setting.ActiveWidgetSystemNames, storeId);
}
//prepare store URL
model.Url = storeId > 0
? (await _storeService.GetStoreByIdAsync(storeId))?.Url
: _webHelper.GetStoreLocation();
return(View("~/Plugins/Widgets.AccessiBe/Views/Configure.cshtml", model));
}
public async Task <IActionResult> Configure(int discountId, int?discountRequirementId)
{
if (!await _permissionService.AuthorizeAsync(StandardPermissionProvider.ManageDiscounts))
{
return(Content("Access denied"));
}
var discount = await _discountService.GetDiscountByIdAsync(discountId);
if (discount == null)
{
throw new ArgumentException("Discount could not be loaded");
}
//check whether the discount requirement exists
if (discountRequirementId.HasValue && await _discountService.GetDiscountRequirementByIdAsync(discountRequirementId.Value) is null)
{
return(Content("Failed to load requirement."));
}
var restrictedProductIds = await _settingService.GetSettingByKeyAsync <string>(string.Format(DiscountRequirementDefaults.SETTINGS_KEY, discountRequirementId ?? 0));
var model = new RequirementModel
{
RequirementId = discountRequirementId ?? 0,
DiscountId = discountId,
ProductIds = restrictedProductIds
};
//add a prefix
ViewData.TemplateInfo.HtmlFieldPrefix = string.Format(DiscountRequirementDefaults.HTML_FIELD_PREFIX, discountRequirementId ?? 0);
return(View("~/Plugins/DiscountRules.HasAllProducts/Views/Configure.cshtml", model));
}
public async Task <IActionResult> Configure()
{
if (!await _permissionService.AuthorizeAsync(StandardPermissionProvider.ManageWidgets))
{
return(AccessDeniedView());
}
//load settings for a chosen store scope
var storeScope = await _storeContext.GetActiveStoreScopeConfigurationAsync();
var helloWorldSettings = await _settingService.LoadSettingAsync <HelloWorldSettings>(storeScope);
var model = new ConfigurationModel
{
Text = helloWorldSettings.Text,
ActiveStoreScopeConfiguration = storeScope
};
if (storeScope > 0)
{
model.Text_OverrideForStore = await _settingService.SettingExistsAsync(helloWorldSettings, x => x.Text, storeScope);
}
return(View("~/Plugins/Widgets.HelloWorld/Views/Configure.cshtml", model));
}
public async Task <IActionResult> Permissions()
{
if (!await _permissionService.AuthorizeAsync(StandardPermissionProvider.ManageAcl))
{
return(AccessDeniedView());
}
var model = await _securityModelFactory.PreparePermissionRolesModel(new PermissionRolesModel());
return(View(model));
}
public async Task <IActionResult> Index()
{
if (!await _permissionService.AuthorizeAsync(StandardPermissionProvider.ManageUsers))
{
return(AccessDeniedView());
}
var model = await _roleModelFactory.PrepareRoleSearchModel(new RoleSearchModel());
return(View(model));
}
/// <returns>A task that represents the asynchronous operation</returns>
public virtual async Task <IActionResult> List()
{
if (!await _permissionService.AuthorizeAsync(StandardPermissionProvider.ManagePlugins))
{
return(AccessDeniedView());
}
var model = await _pluginModelFactory.PreparePluginSearchModelAsync(new PluginSearchModel());
return(View(model));
}
public async Task <IActionResult> Index()
{
if (!await _permissionService.AuthorizeAsync(StandardPermissionProvider.ManageReports))
{
return(AccessDeniedView());
}
var model = await _reportModelFactory.PrepareReportContainerModel(new ReportContainerModel());
return(View(model));
}
public async Task <IActionResult> SystemInfo()
{
if (!await _permissionService.AuthorizeAsync(StandardPermissionProvider.ManageMaintenance))
{
return(AccessDeniedView());
}
var model = await _commonModelFactory.PrepareSystemInfoModel(new SystemInfoModel());
return(View(model));
}
/// <returns>A task that represents the asynchronous operation</returns>
public virtual async Task <IActionResult> List()
{
if (!await _permissionService.AuthorizeAsync(StandardPermissionProvider.ManageCustomers))
{
return(AccessDeniedView());
}
//prepare model
var model = await _customerModelFactory.PrepareOnlineCustomerSearchModelAsync(new OnlineCustomerSearchModel());
return(View(model));
}
public async Task <IActionResult> Index()
{
if (!await _permissionService.AuthorizeAsync(StandardPermissionProvider.ManagePlugins))
{
return(AccessDeniedView());
}
//prepare model
var model = await _apiSettingModelFactory.PrepareApiSettingsModel();
return(View(ViewNames.ApiSettings, model));
}
public virtual async Task <IActionResult> SendNotification()
{
if (!await _permissionService.AuthorizeAsync(StandardPermissionProvider.ManageCustomers))
{
return(AccessDeniedView());
}
//prepare model
var model = new PushNotificationModel();
return(View(model));
}
public virtual async Task <IActionResult> CurrentCarts()
{
if (!await _permissionService.AuthorizeAsync(StandardPermissionProvider.ManageCurrentCarts))
{
return(AccessDeniedView());
}
//prepare model
var model = await _shoppingCartModelFactory.PrepareShoppingCartSearchModelAsync(new ShoppingCartSearchModel());
return(View(model));
}
public async Task <IActionResult> Configure()
{
if (!await _permissionService.AuthorizeAsync(StandardPermissionProvider.ManagePaymentMethods))
{
return(AccessDeniedView());
}
//load settings for a chosen store scope
var storeScope = await _storeContext.GetActiveStoreScopeConfigurationAsync();
var yuansferPaymentSettings = await _settingService.LoadSettingAsync <YuansferPaymentSettings>(storeScope);
var model = new ConfigurationModel
{
ActiveStoreScopeConfiguration = storeScope,
BaseApiUrl = yuansferPaymentSettings.BaseApiUrl,
MerchantId = yuansferPaymentSettings.MerchantId,
StoreId = yuansferPaymentSettings.StoreId,
ApiToken = yuansferPaymentSettings.ApiToken,
PaymentChannels = yuansferPaymentSettings.PaymentChannels,
AdditionalFee = yuansferPaymentSettings.AdditionalFee,
AdditionalFeePercentage = yuansferPaymentSettings.AdditionalFeePercentage,
AvailablePaymentChannels = Defaults.AvailablePaymentChannels
};
if (storeScope > 0)
{
model.BaseApiUrl_OverrideForStore = await _settingService.SettingExistsAsync(yuansferPaymentSettings, x => x.BaseApiUrl, storeScope);
model.MerchantId_OverrideForStore = await _settingService.SettingExistsAsync(yuansferPaymentSettings, x => x.MerchantId, storeScope);
model.StoreId_OverrideForStore = await _settingService.SettingExistsAsync(yuansferPaymentSettings, x => x.StoreId, storeScope);
model.ApiToken_OverrideForStore = await _settingService.SettingExistsAsync(yuansferPaymentSettings, x => x.ApiToken, storeScope);
model.PaymentChannels_OverrideForStore = await _settingService.SettingExistsAsync(yuansferPaymentSettings, x => x.PaymentChannels, storeScope);
model.AdditionalFee_OverrideForStore = await _settingService.SettingExistsAsync(yuansferPaymentSettings, x => x.AdditionalFee, storeScope);
model.AdditionalFeePercentage_OverrideForStore = await _settingService.SettingExistsAsync(yuansferPaymentSettings, x => x.AdditionalFeePercentage, storeScope);
}
//prices and total aren't rounded, so display warning
if (!_shoppingCartSettings.RoundPricesDuringCalculation)
{
var url = Url.Action("AllSettings", "Setting", new { settingName = nameof(ShoppingCartSettings.RoundPricesDuringCalculation) });
var warning = string.Format(await _localizationService.GetResourceAsync("Plugins.Payments.Yuansfer.RoundingWarning"), url);
_notificationService.WarningNotification(warning, false);
}
return(View("~/Plugins/Payments.Yuansfer/Views/Configure.cshtml", model));
}
/// <returns>A task that represents the asynchronous operation</returns>
public virtual async Task <IActionResult> Methods()
{
if (!await _permissionService.AuthorizeAsync(StandardPermissionProvider.ManageExternalAuthenticationMethods))
{
return(AccessDeniedView());
}
//prepare model
var model = _externalAuthenticationMethodModelFactory
.PrepareExternalAuthenticationMethodSearchModel(new ExternalAuthenticationMethodSearchModel());
return(View(model));
}
public virtual async Task <IActionResult> Category(int categoryId, CatalogPagingFilteringModel command)
{
var category = await _categoryService.GetCategoryByIdAsync(categoryId);
if (category == null || category.Deleted)
{
return(InvokeHttp404());
}
var notAvailable =
//published?
!category.Published ||
//ACL (access control list)
!await _aclService.AuthorizeAsync(category) ||
//Store mapping
!await _storeMappingService.AuthorizeAsync(category);
//Check whether the current user has a "Manage categories" permission (usually a store owner)
//We should allows him (her) to use "Preview" functionality
var hasAdminAccess = await _permissionService.AuthorizeAsync(StandardPermissionProvider.AccessAdminPanel) && await _permissionService.AuthorizeAsync(StandardPermissionProvider.ManageCategories);
if (notAvailable && !hasAdminAccess)
{
return(InvokeHttp404());
}
//'Continue shopping' URL
await _genericAttributeService.SaveAttributeAsync(await _workContext.GetCurrentCustomerAsync(),
NopCustomerDefaults.LastContinueShoppingPageAttribute,
_webHelper.GetThisPageUrl(false),
(await _storeContext.GetCurrentStoreAsync()).Id);
//display "edit" (manage) link
if (await _permissionService.AuthorizeAsync(StandardPermissionProvider.AccessAdminPanel) && await _permissionService.AuthorizeAsync(StandardPermissionProvider.ManageCategories))
{
DisplayEditLink(Url.Action("Edit", "Category", new { id = category.Id, area = AreaNames.Admin }));
}
//activity log
await _customerActivityService.InsertActivityAsync("PublicStore.ViewCategory",
string.Format(await _localizationService.GetResourceAsync("ActivityLog.PublicStore.ViewCategory"), category.Name), category);
//model
var model = await _catalogModelFactory.PrepareCategoryModelAsync(category, command);
//template
var templateViewPath = await _catalogModelFactory.PrepareCategoryTemplateViewPathAsync(category.CategoryTemplateId);
return(View(templateViewPath, model));
}
public async Task <IActionResult> Configure()
{
if (!await _permissionService.AuthorizeAsync(StandardPermissionProvider.ManageWidgets))
{
return(AccessDeniedView());
}
var model = new ConfigurationModel
{
Enabled = _what3WordsSettings.Enabled
};
return(View("~/Plugins/Widgets.What3words/Views/Configure.cshtml", model));
}
/// <summary>
/// Prepare the header links model
/// </summary>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the header links model
/// </returns>
public virtual async Task <HeaderLinksModel> PrepareHeaderLinksModelAsync()
{
var customer = await _workContext.GetCurrentCustomerAsync();
var store = await _storeContext.GetCurrentStoreAsync();
var unreadMessageCount = await GetUnreadPrivateMessagesAsync();
var unreadMessage = string.Empty;
var alertMessage = string.Empty;
if (unreadMessageCount > 0)
{
unreadMessage = string.Format(await _localizationService.GetResourceAsync("PrivateMessages.TotalUnread"), unreadMessageCount);
//notifications here
if (_forumSettings.ShowAlertForPM &&
!await _genericAttributeService.GetAttributeAsync <bool>(customer, NopCustomerDefaults.NotifiedAboutNewPrivateMessagesAttribute, store.Id))
{
await _genericAttributeService.SaveAttributeAsync(customer, NopCustomerDefaults.NotifiedAboutNewPrivateMessagesAttribute, true, store.Id);
alertMessage = string.Format(await _localizationService.GetResourceAsync("PrivateMessages.YouHaveUnreadPM"), unreadMessageCount);
}
}
var model = new HeaderLinksModel
{
RegistrationType = _customerSettings.UserRegistrationType,
IsAuthenticated = await _customerService.IsRegisteredAsync(customer),
CustomerName = await _customerService.IsRegisteredAsync(customer) ? await _customerService.FormatUsernameAsync(customer) : string.Empty,
ShoppingCartEnabled = await _permissionService.AuthorizeAsync(StandardPermissionProvider.EnableShoppingCart),
WishlistEnabled = await _permissionService.AuthorizeAsync(StandardPermissionProvider.EnableWishlist),
AllowPrivateMessages = await _customerService.IsRegisteredAsync(customer) && _forumSettings.AllowPrivateMessages,
UnreadPrivateMessages = unreadMessage,
AlertMessage = alertMessage,
};
//performance optimization (use "HasShoppingCartItems" property)
if (customer.HasShoppingCartItems)
{
model.ShoppingCartItems = (await _shoppingCartService.GetShoppingCartAsync(customer, ShoppingCartType.ShoppingCart, store.Id))
.Sum(item => item.Quantity);
model.WishlistItems = (await _shoppingCartService.GetShoppingCartAsync(customer, ShoppingCartType.Wishlist, store.Id))
.Sum(item => item.Quantity);
}
return(model);
}
public async Task <IActionResult> Configure(int discountId, int?discountRequirementId)
{
if (!await _permissionService.AuthorizeAsync(StandardPermissionProvider.ManageDiscounts))
{
return(Content("Access denied"));
}
//load the discount
var discount = await _discountService.GetDiscountByIdAsync(discountId);
if (discount == null)
{
throw new ArgumentException("Discount could not be loaded");
}
//check whether the discount requirement exists
if (discountRequirementId.HasValue && await _discountService.GetDiscountRequirementByIdAsync(discountRequirementId.Value) is null)
{
return(Content("Failed to load requirement."));
}
//try to get previously saved restricted customer role identifier
var restrictedRoleId = await _settingService.GetSettingByKeyAsync <int>(string.Format(DiscountRequirementDefaults.SettingsKey, discountRequirementId ?? 0));
var model = new RequirementModel
{
RequirementId = discountRequirementId ?? 0,
DiscountId = discountId,
CustomerRoleId = restrictedRoleId
};
//set available customer roles
model.AvailableCustomerRoles = (await _customerService.GetAllCustomerRolesAsync(true)).Select(role => new SelectListItem
{
Text = role.Name,
Value = role.Id.ToString(),
Selected = role.Id == restrictedRoleId
}).ToList();
model.AvailableCustomerRoles.Insert(0, new SelectListItem
{
Text = await _localizationService.GetResourceAsync("Plugins.DiscountRules.CustomerRoles.Fields.CustomerRole.Select"),
Value = "0"
});
//set the HTML field prefix
ViewData.TemplateInfo.HtmlFieldPrefix = string.Format(DiscountRequirementDefaults.HtmlFieldPrefix, discountRequirementId ?? 0);
return(View("~/Plugins/DiscountRules.CustomerRoles/Views/Configure.cshtml", model));
}
/// <returns>A task that represents the asynchronous operation</returns>
public async Task <IActionResult> Configure()
{
if (!await _permissionService.AuthorizeAsync(StandardPermissionProvider.ManageExternalAuthenticationMethods))
{
return(AccessDeniedView());
}
var model = new ConfigurationModel
{
ClientId = _facebookExternalAuthSettings.ClientKeyIdentifier,
ClientSecret = _facebookExternalAuthSettings.ClientSecret
};
return(View("~/Plugins/ExternalAuth.Facebook/Views/Configure.cshtml", model));
}
public virtual async Task <IActionResult> Index(int?id, int?pageNumber)
{
if (!_customerSettings.AllowViewingProfiles)
{
return(RedirectToRoute("Homepage"));
}
var customerId = 0;
if (id.HasValue)
{
customerId = id.Value;
}
var customer = await _customerService.GetCustomerByIdAsync(customerId);
if (customer == null || await _customerService.IsGuestAsync(customer))
{
return(RedirectToRoute("Homepage"));
}
//display "edit" (manage) link
if (await _permissionService.AuthorizeAsync(StandardPermissionProvider.AccessAdminPanel) && await _permissionService.AuthorizeAsync(StandardPermissionProvider.ManageCustomers))
{
DisplayEditLink(Url.Action("Edit", "Customer", new { id = customer.Id, area = AreaNames.Admin }));
}
var model = await _profileModelFactory.PrepareProfileIndexModelAsync(customer, pageNumber);
return(View(model));
}
public virtual async Task <IActionResult> Index()
{
//display a warning to a store owner if there are some error
var hideCard = await _genericAttributeService.GetAttributeAsync <bool>(await _workContext.GetCurrentCustomerAsync(), NopCustomerDefaults.HideConfigurationStepsAttribute);
var closeCard = await _genericAttributeService.GetAttributeAsync <bool>(await _workContext.GetCurrentCustomerAsync(), NopCustomerDefaults.CloseConfigurationStepsAttribute);
if ((hideCard || closeCard) && await _permissionService.AuthorizeAsync(StandardPermissionProvider.ManageMaintenance))
{
var warnings = await _commonModelFactory.PrepareSystemWarningModelsAsync();
if (warnings.Any(warning => warning.Level == SystemWarningLevel.Fail ||
warning.Level == SystemWarningLevel.CopyrightRemovalKey ||
warning.Level == SystemWarningLevel.Warning))
{
_notificationService.WarningNotification(
string.Format(await _localizationService.GetResourceAsync("Admin.System.Warnings.Errors"),
Url.Action("Warnings", "Common")),
//do not encode URLs
false);
}
}
//prepare model
var model = await _homeModelFactory.PrepareDashboardModelAsync(new DashboardModel());
return(View(model));
}
/// <returns>A task that represents the asynchronous operation</returns>
public async Task <IActionResult> ExportProducts(string selectedIds)
{
//ensure that Avalara tax provider is active
if (!await _taxPluginManager.IsPluginActiveAsync(AvalaraTaxDefaults.SystemName))
{
return(RedirectToAction("List", "Product"));
}
if (!await _permissionService.AuthorizeAsync(StandardPermissionProvider.ManageTaxSettings))
{
return(AccessDeniedView());
}
//export items
var exportedItems = await _avalaraTaxManager.ExportProductsAsync(selectedIds);
if (exportedItems.HasValue)
{
if (exportedItems > 0)
{
_notificationService.SuccessNotification(string.Format(await _localizationService.GetResourceAsync("Plugins.Tax.Avalara.Items.Export.Success"), exportedItems));
}
else
{
_notificationService.SuccessNotification(await _localizationService.GetResourceAsync("Plugins.Tax.Avalara.Items.Export.AlreadyExported"));
}
}
else
{
_notificationService.ErrorNotification(await _localizationService.GetResourceAsync("Plugins.Tax.Avalara.Items.Export.Error"));
}
return(RedirectToAction("List", "Product"));
}
/// <summary>
/// Called early in the filter pipeline to confirm request is authorized
/// </summary>
/// <param name="context">Authorization filter context</param>
/// <returns>A task that on completion indicates the filter has executed</returns>
private async Task CheckAccessPublicStoreAsync(AuthorizationFilterContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (!await DataSettingsManager.IsDatabaseInstalledAsync())
{
return;
}
//check whether this filter has been overridden for the Action
var actionFilter = context.ActionDescriptor.FilterDescriptors
.Where(filterDescriptor => filterDescriptor.Scope == FilterScope.Action)
.Select(filterDescriptor => filterDescriptor.Filter)
.OfType <CheckAccessPublicStoreAttribute>()
.FirstOrDefault();
//ignore filter (the action is available even if navigation is not allowed)
if (actionFilter?.IgnoreFilter ?? _ignoreFilter)
{
return;
}
//check whether current customer has access to a public store
if (await _permissionService.AuthorizeAsync(StandardPermissionProvider.PublicStoreAllowNavigation))
{
return;
}
//customer hasn't access to a public store
context.Result = new ChallengeResult();
}
public async Task OnAuthorizationAsync(AuthorizationFilterContext filterContext)
{
if (filterContext == null)
{
throw new ArgumentNullException(nameof(filterContext));
}
//check whether this filter has been overridden for the action
var actionFilter = filterContext.ActionDescriptor.FilterDescriptors
.Where(fd => fd.Scope == FilterScope.Action)
.Select(fd => fd.Filter)
.OfType <AuthorizeUserAttribute>().FirstOrDefault();
if (actionFilter?.IgnoreFilter ?? _ignoreFilter)
{
return;
}
if (!DataSettingsManager.DatabaseIsInstalled)
{
return;
}
if (filterContext.Filters.Any(filter => filter is AuthorizeUserFilter))
{
if (!await _permissionService.AuthorizeAsync(StandardPermissionProvider.AccessPanel))
{
filterContext.Result = new ChallengeResult();
}
}
}
/// <summary>
/// Called early in the filter pipeline to confirm request is authorized
/// </summary>
/// <param name="context">Authorization filter context</param>
/// <returns>A task that represents the asynchronous operation</returns>
private async Task AuthorizeAdminAsync(AuthorizationFilterContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (!await DataSettingsManager.IsDatabaseInstalledAsync())
{
return;
}
//check whether this filter has been overridden for the action
var actionFilter = context.ActionDescriptor.FilterDescriptors
.Where(filterDescriptor => filterDescriptor.Scope == FilterScope.Action)
.Select(filterDescriptor => filterDescriptor.Filter)
.OfType <AuthorizeAdminAttribute>()
.FirstOrDefault();
//ignore filter (the action is available even if a customer hasn't access to the admin area)
if (actionFilter?.IgnoreFilter ?? _ignoreFilter)
{
return;
}
//there is AdminAuthorizeFilter, so check access
if (context.Filters.Any(filter => filter is AuthorizeAdminFilter))
{
//authorize permission of access to the admin area
if (!await _permissionService.AuthorizeAsync(StandardPermissionProvider.AccessAdminPanel))
{
context.Result = new ChallengeResult();
}
}
}