public IActionResult MenuItemEditor(int menuId, int menuItemId)
{
var menu = _menuService.Get(menuId);
if (menu == null)
{
return(NotFound());
}
var menuItem = menuItemId > 0 ? menu.MenuItems.FirstOrDefault(x => x.Id == menuItemId) : new MenuItem();
if (menuItem == null)
{
return(NotFound());
}
var model = _modelMapper.Map <MenuItemModel>(menuItem);
if (menuItem.SeoMeta != null)
{
model.Url = SeoMetaHelper.GetUrl(menuItem.SeoMeta);
var entityId = menuItem.SeoMeta.EntityId;
switch (menuItem.SeoMeta.EntityName)
{
case nameof(Product):
model.SeoMetaTargetName = _productService.FirstOrDefault(y => y.Id == entityId)?.Name ?? "NA";
break;
case nameof(Category):
model.SeoMetaTargetName =
_categoryService.FirstOrDefault(y => y.Id == entityId)?.Name ?? "NA";
break;
case nameof(ContentPage):
model.SeoMetaTargetName =
_contentPageService.FirstOrDefault(y => y.Id == entityId)?.Name ?? "NA";
break;
}
}
IList <SelectListItem> availableMenuItems = null;
//send available parent menu items to which this menu item can be moved to
if (menu.MenuItems != null)
{
menu.MenuItems = menu.MenuItems.GetWithParentTree();
availableMenuItems = SelectListHelper.GetSelectItemListWithAction(
menu.MenuItems.Where(x => x.ParentId != menuItemId).ToList(), x => x.Id,
item => item.GetFieldBreadCrumb(y => y.Name)).OrderBy(x => x.Text).ToList();
}
return(R.Success.With("menuItem", model).With("availableMenuItems", availableMenuItems).Result);
}
public IActionResult ContentPageEditor(int contentPageId)
{
var contentPage = contentPageId > 0 ? _contentPageService.Get(contentPageId) : new ContentPage();
if (contentPage == null)
{
return(NotFound());
}
var model = PrepareModel(contentPage);
//get all pages to make a tree
var availablePages = _contentPageService.Get(x => x.Id != contentPageId).ToList().GetWithParentTree();
var contentPageModels =
SelectListHelper.GetSelectItemListWithAction(availablePages, x => x.Id, x => x.GetNameBreadCrumb())
.OrderBy(x => x.Text).ToList();
return(R.Success.With("contentPage", model)
.With("availablePages", contentPageModels)
.WithActiveThemeTemplates()
.Result);
}
public IActionResult StockReport(StockReportSearchModel searchModel)
{
searchModel = searchModel ?? new StockReportSearchModel();
//get availalbe warehouses
var warehouses = _warehouseService.Get(x => true).ToList();
if (searchModel.WarehouseId < 1)
{
searchModel.WarehouseId = warehouses.First().Id;
}
var products = _productService.GetProductsWithVariants(out int totalResults, searchModel.WarehouseId, searchModel.ProductSearch,
searchModel.Published, true, page: searchModel.Current, count: searchModel.RowCount);
var models = products.Select(_reportModelFactory.Create).ToList();
var warehouseModels = SelectListHelper.GetSelectItemListWithAction(warehouses, x => x.Id, x => x.Address.Name);
return(R.Success.WithGridResponse(totalResults, searchModel.Current, searchModel.RowCount)
.With("reportItems", models)
.With("availableWarehouses", warehouseModels)
.Result);
}
private IActionResult GetSettingResult(string settingType)
{
SettingsModel model = null;
ISettingGroup settings = null;
var result = R.Success;
switch (settingType)
{
case "general":
settings = DependencyResolver.Resolve <GeneralSettings>();
model = _modelMapper.Map <GeneralSettingsModel>(settings);
var menuService = DependencyResolver.Resolve <IMenuService>();
var menus = menuService.Get(x => true).ToList();
var menuSelectList = SelectListHelper.GetSelectItemList(menus, x => x.Id, x => x.Name);
result.WithTimezones();
result.With("availableMenus", menuSelectList);
//get themes
var themes = _themeProvider.GetAvailableThemes()
.Select(x => new ThemeInfoModel()
{
DirectoryName = x.DirectoryName,
Name = x.Name,
ThumbnailUrl = x.ThumbnailUrl,
PendingRestart = x.PendingRestart
}).ToList();
result.With("availableThemes", themes);
break;
case "order":
settings = DependencyResolver.Resolve <OrderSettings>();
result.WithAvailableOrderStatusTypes();
model = _modelMapper.Map <OrderSettingsModel>(settings);
break;
case "user":
settings = DependencyResolver.Resolve <UserSettings>();
model = _modelMapper.Map <UserSettingsModel>(settings);
result.WithRegistrationModes();
break;
case "url":
settings = DependencyResolver.Resolve <UrlSettings>();
model = _modelMapper.Map <UrlSettingsModel>(settings);
break;
case "media":
settings = DependencyResolver.Resolve <MediaSettings>();
model = _modelMapper.Map <MediaSettingsModel>(settings);
break;
case "tax":
settings = DependencyResolver.Resolve <TaxSettings>();
var taxService = DependencyResolver.Resolve <ITaxService>();
var taxes = taxService.Get(x => true).ToList();
var taxesSelectList = SelectListHelper.GetSelectItemList(taxes, x => x.Id, x => x.Name);
model = _modelMapper.Map <TaxSettingsModel>(settings);
result.With("availableTaxes", taxesSelectList);
break;
case "email":
settings = DependencyResolver.Resolve <EmailSenderSettings>();
model = _modelMapper.Map <EmailSettingsModel>(settings);
result.WithEmailAccounts();
break;
case "catalog":
settings = DependencyResolver.Resolve <CatalogSettings>();
model = _modelMapper.Map <CatalogSettingsModel>(settings);
result.WithCatalogPaginationTypes();
break;
case "localization":
settings = DependencyResolver.Resolve <LocalizationSettings>();
model = _modelMapper.Map <LocalizationSettingsModel>(settings);
var currencyService = DependencyResolver.Resolve <ICurrencyService>();
var currencies = currencyService.Get(x => x.Published).ToList();
var currenciesSelectList = SelectListHelper.GetSelectItemListWithAction(currencies, x => x.Id, x => $"{x.Name} ({x.IsoCode})");
result.With("availableCurrencies", currenciesSelectList);
result.WithCatalogPaginationTypes();
break;
case "gdpr":
settings = DependencyResolver.Resolve <GdprSettings>();
model = _modelMapper.Map <GdprSettingsModel>(settings);
var consentGroupService = DependencyResolver.Resolve <IConsentGroupService>();
var consentGroups = consentGroupService.Get(x => true).ToList();
var groupSelectList = SelectListHelper.GetSelectItemList(consentGroups, x => x.Id, x => x.Name);
result.With("availableConsentGroups", groupSelectList);
break;
case "security":
settings = DependencyResolver.Resolve <SecuritySettings>();
model = _modelMapper.Map <SecuritySettingsModel>(settings);
break;
case "affiliate":
settings = DependencyResolver.Resolve <AffiliateSettings>();
model = _modelMapper.Map <AffiliateSettingsModel>(settings);
break;
}
return(result.With("settings", model).With("settingType", settingType).Result);
}
