protected void PrepareTemplatesModel(CategoryModel model)
{
if (model == null)
{
throw new ArgumentNullException("model");
}
var templates = _categoryTemplateService.GetAllCategoryTemplates();
foreach (var template in templates)
{
model.AvailableCategoryTemplates.Add(new SelectListItem()
{
Text = template.Name,
Value = template.Id.ToString()
});
}
}
public virtual ActionResult CategoryTemplates(DataSourceRequest command)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageMaintenance))
{
return(AccessDeniedKendoGridJson());
}
var templatesModel = _categoryTemplateService.GetAllCategoryTemplates()
.Select(x => x.ToModel())
.ToList();
var gridModel = new DataSourceResult
{
Data = templatesModel,
Total = templatesModel.Count
};
return(Json(gridModel));
}
public virtual string PrepareCategoryTemplateViewPath(int templateId)
{
var templateCacheKey = string.Format(ModelCacheEventConsumer.CATEGORY_TEMPLATE_MODEL_KEY, templateId);
var templateViewPath = _cacheManager.Get(templateCacheKey, () =>
{
var template = _categoryTemplateService.GetCategoryTemplateById(templateId);
if (template == null)
{
template = _categoryTemplateService.GetAllCategoryTemplates().FirstOrDefault();
}
if (template == null)
{
throw new Exception("No default template could be loaded");
}
return(template.ViewPath);
});
return(templateViewPath);
}
public async Task <string> Handle(GetCategoryTemplateViewPath request, CancellationToken cancellationToken)
{
var templateCacheKey = string.Format(ModelCacheEventConst.CATEGORY_TEMPLATE_MODEL_KEY, request.TemplateId);
var templateViewPath = await _cacheBase.GetAsync(templateCacheKey, async() =>
{
var template = await _categoryTemplateService.GetCategoryTemplateById(request.TemplateId);
if (template == null)
{
template = (await _categoryTemplateService.GetAllCategoryTemplates()).FirstOrDefault();
}
if (template == null)
{
throw new Exception("No default template could be loaded");
}
return(template.ViewPath);
});
return(templateViewPath);
}
/// <summary>
/// Prepare paged category template list model
/// </summary>
/// <param name="searchModel">Category template search model</param>
/// <returns>Category template list model</returns>
public virtual CategoryTemplateListModel PrepareCategoryTemplateListModel(CategoryTemplateSearchModel searchModel)
{
if (searchModel == null)
{
throw new ArgumentNullException(nameof(searchModel));
}
//get category templates
var categoryTemplates = _categoryTemplateService.GetAllCategoryTemplates();
//prepare grid model
var model = new CategoryTemplateListModel
{
//fill in model values from the entity
Data = categoryTemplates.PaginationByRequestModel(searchModel).Select(template => template.ToModel <CategoryTemplateModel>()),
Total = categoryTemplates.Count
};
return(model);
}
/// <summary>
/// Prepare available category templates
/// </summary>
/// <param name="items">Category template items</param>
/// <param name="withSpecialDefaultItem">Whether to insert the first special item for the default value</param>
/// <param name="defaultItemText">Default item text; pass null to use default value of the default item text</param>
public virtual void PrepareCategoryTemplates(IList <SelectListItem> items, bool withSpecialDefaultItem = true, string defaultItemText = null)
{
if (items == null)
{
throw new ArgumentNullException(nameof(items));
}
//prepare available category templates
var availableTemplates = _categoryTemplateService.GetAllCategoryTemplates();
foreach (var template in availableTemplates)
{
items.Add(new SelectListItem {
Value = template.Id.ToString(), Text = template.Name
});
}
//insert special item for the default value
PrepareDefaultItem(items, withSpecialDefaultItem, defaultItemText);
}
public ActionResult CategoryTemplates(GridCommand command)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageMaintenance))
{
return(AccessDeniedView());
}
var templatesModel = _categoryTemplateService.GetAllCategoryTemplates()
.Select(x => x.ToModel())
.ToList();
var model = new GridModel <CategoryTemplateModel>
{
Data = templatesModel,
Total = templatesModel.Count
};
return(new JsonResult
{
Data = model
});
}
public ActionResult Category(int categoryId, CatalogSearchQuery query)
{
var category = _categoryService.GetCategoryById(categoryId);
if (category == null || category.Deleted)
{
return(HttpNotFound());
}
// Check whether the current user has a "Manage catalog" permission.
// It allows him to preview a category before publishing.
if (!category.Published && !Services.Permissions.Authorize(Permissions.Catalog.Category.Read))
{
return(HttpNotFound());
}
// ACL (access control list).
if (!_aclService.Authorize(category))
{
return(HttpNotFound());
}
// Store mapping.
if (!_storeMappingService.Authorize(category))
{
return(HttpNotFound());
}
var store = Services.StoreContext.CurrentStore;
var customer = Services.WorkContext.CurrentCustomer;
// 'Continue shopping' URL.
if (!Services.WorkContext.CurrentCustomer.IsSystemAccount)
{
_genericAttributeService.SaveAttribute(customer, SystemCustomerAttributeNames.LastContinueShoppingPage, Services.WebHelper.GetThisPageUrl(false), store.Id);
}
var model = category.ToModel();
if (query.IsSubPage && !_catalogSettings.ShowDescriptionInSubPages)
{
model.Description.ChangeValue(string.Empty);
model.BottomDescription.ChangeValue(string.Empty);
}
Services.DisplayControl.Announce(category);
// Category breadcrumb.
if (_catalogSettings.CategoryBreadcrumbEnabled)
{
_helper.GetCategoryBreadcrumb(_breadcrumb, ControllerContext);
}
// Products.
var catIds = new int[] { categoryId };
if (_catalogSettings.ShowProductsFromSubcategories)
{
// Include subcategories.
catIds = catIds.Concat(_helper.GetChildCategoryIds(categoryId)).ToArray();
}
query.WithCategoryIds(_catalogSettings.IncludeFeaturedProductsInNormalLists ? (bool?)null : false, catIds);
var searchResult = _catalogSearchService.Search(query);
model.SearchResult = searchResult;
var mappingSettings = _helper.GetBestFitProductSummaryMappingSettings(query.GetViewMode());
model.Products = _helper.MapProductSummaryModel(searchResult.Hits, mappingSettings);
model.SubCategoryDisplayType = _catalogSettings.SubCategoryDisplayType;
var customerRolesIds = customer.CustomerRoleMappings
.Select(x => x.CustomerRole)
.Where(x => x.Active)
.Select(x => x.Id)
.ToList();
var pictureSize = _mediaSettings.CategoryThumbPictureSize;
var fallbackType = _catalogSettings.HideCategoryDefaultPictures ? FallbackPictureType.NoFallback : FallbackPictureType.Entity;
var hideSubCategories = _catalogSettings.SubCategoryDisplayType == SubCategoryDisplayType.Hide ||
(_catalogSettings.SubCategoryDisplayType == SubCategoryDisplayType.AboveProductList && query.IsSubPage && !_catalogSettings.ShowSubCategoriesInSubPages);
var hideFeaturedProducts = _catalogSettings.IgnoreFeaturedProducts || (query.IsSubPage && !_catalogSettings.IncludeFeaturedProductsInSubPages);
// Subcategories.
if (!hideSubCategories)
{
var subCategories = _categoryService.GetAllCategoriesByParentCategoryId(categoryId);
model.SubCategories = _helper.MapCategorySummaryModel(subCategories, pictureSize);
}
// Featured Products.
if (!hideFeaturedProducts)
{
CatalogSearchResult featuredProductsResult = null;
string cacheKey = ModelCacheEventConsumer.CATEGORY_HAS_FEATURED_PRODUCTS_KEY.FormatInvariant(categoryId, string.Join(",", customerRolesIds), store.Id);
var hasFeaturedProductsCache = Services.Cache.Get <bool?>(cacheKey);
var featuredProductsQuery = new CatalogSearchQuery()
.VisibleOnly(customer)
.WithVisibility(ProductVisibility.Full)
.WithCategoryIds(true, categoryId)
.HasStoreId(Services.StoreContext.CurrentStore.Id)
.WithLanguage(Services.WorkContext.WorkingLanguage)
.WithCurrency(Services.WorkContext.WorkingCurrency);
if (!hasFeaturedProductsCache.HasValue)
{
featuredProductsResult = _catalogSearchService.Search(featuredProductsQuery);
hasFeaturedProductsCache = featuredProductsResult.TotalHitsCount > 0;
Services.Cache.Put(cacheKey, hasFeaturedProductsCache, TimeSpan.FromHours(6));
}
if (hasFeaturedProductsCache.Value && featuredProductsResult == null)
{
featuredProductsResult = _catalogSearchService.Search(featuredProductsQuery);
}
if (featuredProductsResult != null)
{
var featuredProductsmappingSettings = _helper.GetBestFitProductSummaryMappingSettings(ProductSummaryViewMode.Grid);
model.FeaturedProducts = _helper.MapProductSummaryModel(featuredProductsResult.Hits, featuredProductsmappingSettings);
}
}
// Prepare paging/sorting/mode stuff.
_helper.MapListActions(model.Products, category, _catalogSettings.DefaultPageSizeOptions);
// Template.
var templateCacheKey = string.Format(ModelCacheEventConsumer.CATEGORY_TEMPLATE_MODEL_KEY, category.CategoryTemplateId);
var templateViewPath = Services.Cache.Get(templateCacheKey, () =>
{
var template = _categoryTemplateService.GetCategoryTemplateById(category.CategoryTemplateId);
if (template == null)
{
template = _categoryTemplateService.GetAllCategoryTemplates().FirstOrDefault();
}
return(template.ViewPath);
});
// Activity log.
Services.CustomerActivity.InsertActivity("PublicStore.ViewCategory", T("ActivityLog.PublicStore.ViewCategory"), category.Name);
return(View(templateViewPath, model));
}
public ActionResult Category(int categoryId, CatalogSearchQuery query)
{
var category = _categoryService.GetCategoryById(categoryId);
if (category == null || category.Deleted)
{
return(HttpNotFound());
}
// Check whether the current user has a "Manage catalog" permission
// It allows him to preview a category before publishing
if (!category.Published && !_services.Permissions.Authorize(StandardPermissionProvider.ManageCatalog))
{
return(HttpNotFound());
}
// ACL (access control list)
if (!_aclService.Authorize(category))
{
return(HttpNotFound());
}
// Store mapping
if (!_storeMappingService.Authorize(category))
{
return(HttpNotFound());
}
// 'Continue shopping' URL
if (!_services.WorkContext.CurrentCustomer.IsSystemAccount)
{
_genericAttributeService.SaveAttribute(_services.WorkContext.CurrentCustomer,
SystemCustomerAttributeNames.LastContinueShoppingPage,
_services.WebHelper.GetThisPageUrl(false),
_services.StoreContext.CurrentStore.Id);
}
var model = category.ToModel();
_services.DisplayControl.Announce(category);
// Category breadcrumb
if (_catalogSettings.CategoryBreadcrumbEnabled)
{
_helper.GetCategoryBreadCrumb(category.Id, 0).Select(x => x.Value).Each(x => _breadcrumb.Track(x));
}
model.SubCategoryDisplayType = _catalogSettings.SubCategoryDisplayType;
var customerRolesIds = _services.WorkContext.CurrentCustomer.CustomerRoles.Where(x => x.Active).Select(x => x.Id).ToList();
// subcategories
model.SubCategories = _categoryService
.GetAllCategoriesByParentCategoryId(categoryId)
.Select(x =>
{
var subCatName = x.GetLocalized(y => y.Name);
var subCatModel = new CategoryModel.SubCategoryModel
{
Id = x.Id,
Name = subCatName,
SeName = x.GetSeName(),
};
_services.DisplayControl.Announce(x);
// prepare picture model
int pictureSize = _mediaSettings.CategoryThumbPictureSize;
var categoryPictureCacheKey = string.Format(ModelCacheEventConsumer.CATEGORY_PICTURE_MODEL_KEY, x.Id, pictureSize, true, _services.WorkContext.WorkingLanguage.Id, _services.StoreContext.CurrentStore.Id);
subCatModel.PictureModel = _services.Cache.Get(categoryPictureCacheKey, () =>
{
var picture = _pictureService.GetPictureById(x.PictureId.GetValueOrDefault());
var pictureModel = new PictureModel
{
PictureId = x.PictureId.GetValueOrDefault(),
Size = pictureSize,
FullSizeImageUrl = _pictureService.GetPictureUrl(picture),
FullSizeImageWidth = picture?.Width,
FullSizeImageHeight = picture?.Height,
ImageUrl = _pictureService.GetPictureUrl(picture, pictureSize, !_catalogSettings.HideCategoryDefaultPictures),
Title = string.Format(T("Media.Category.ImageLinkTitleFormat"), subCatName),
AlternateText = string.Format(T("Media.Category.ImageAlternateTextFormat"), subCatName)
};
return(pictureModel);
}, TimeSpan.FromHours(6));
return(subCatModel);
})
.ToList();
// Featured Products
if (!_catalogSettings.IgnoreFeaturedProducts)
{
CatalogSearchResult featuredProductsResult = null;
string cacheKey = ModelCacheEventConsumer.CATEGORY_HAS_FEATURED_PRODUCTS_KEY.FormatInvariant(categoryId, string.Join(",", customerRolesIds), _services.StoreContext.CurrentStore.Id);
var hasFeaturedProductsCache = _services.Cache.Get <bool?>(cacheKey);
var featuredProductsQuery = new CatalogSearchQuery()
.VisibleOnly(_services.WorkContext.CurrentCustomer)
.VisibleIndividuallyOnly(true)
.WithCategoryIds(true, categoryId)
.HasStoreId(_services.StoreContext.CurrentStore.Id)
.WithLanguage(_services.WorkContext.WorkingLanguage)
.WithCurrency(_services.WorkContext.WorkingCurrency);
if (!hasFeaturedProductsCache.HasValue)
{
featuredProductsResult = _catalogSearchService.Search(featuredProductsQuery);
hasFeaturedProductsCache = featuredProductsResult.TotalHitsCount > 0;
_services.Cache.Put(cacheKey, hasFeaturedProductsCache, TimeSpan.FromHours(6));
}
if (hasFeaturedProductsCache.Value && featuredProductsResult == null)
{
featuredProductsResult = _catalogSearchService.Search(featuredProductsQuery);
}
if (featuredProductsResult != null)
{
var featuredProductsmappingSettings = _helper.GetBestFitProductSummaryMappingSettings(ProductSummaryViewMode.Grid);
model.FeaturedProducts = _helper.MapProductSummaryModel(featuredProductsResult.Hits, featuredProductsmappingSettings);
}
}
// Products
int[] catIds = new int[] { categoryId };
if (_catalogSettings.ShowProductsFromSubcategories)
{
// Include subcategories
catIds = catIds.Concat(_helper.GetChildCategoryIds(categoryId)).ToArray();
}
query.WithCategoryIds(_catalogSettings.IncludeFeaturedProductsInNormalLists ? (bool?)null : false, catIds);
var searchResult = _catalogSearchService.Search(query);
model.SearchResult = searchResult;
var mappingSettings = _helper.GetBestFitProductSummaryMappingSettings(query.GetViewMode());
model.Products = _helper.MapProductSummaryModel(searchResult.Hits, mappingSettings);
// Prepare paging/sorting/mode stuff
_helper.MapListActions(model.Products, category, _catalogSettings.DefaultPageSizeOptions);
// template
var templateCacheKey = string.Format(ModelCacheEventConsumer.CATEGORY_TEMPLATE_MODEL_KEY, category.CategoryTemplateId);
var templateViewPath = _services.Cache.Get(templateCacheKey, () =>
{
var template = _categoryTemplateService.GetCategoryTemplateById(category.CategoryTemplateId);
if (template == null)
{
template = _categoryTemplateService.GetAllCategoryTemplates().FirstOrDefault();
}
return(template.ViewPath);
});
// Activity log
_services.CustomerActivity.InsertActivity("PublicStore.ViewCategory", T("ActivityLog.PublicStore.ViewCategory"), category.Name);
return(View(templateViewPath, model));
}
protected override void Import(IImportExecuteContext context)
{
var srcToDestId = new Dictionary <int, ImportCategoryMapping>();
var templateViewPaths = _categoryTemplateService.GetAllCategoryTemplates()
.GroupBy(x => x.ViewPath, StringComparer.OrdinalIgnoreCase)
.ToDictionary(x => x.Key, x => x.First().Id);
using (var scope = new DbContextScope(ctx: _categoryRepository.Context, autoDetectChanges: false, proxyCreation: false, validateOnSave: false))
{
var segmenter = context.GetSegmenter <Category>();
Init(context, _dataExchangeSettings);
context.Result.TotalRecords = segmenter.TotalRows;
while (context.Abort == DataExchangeAbortion.None && segmenter.ReadNextBatch())
{
var batch = segmenter.CurrentBatch;
// Perf: detach all entities
_categoryRepository.Context.DetachAll(false);
context.SetProgress(segmenter.CurrentSegmentFirstRowIndex - 1, segmenter.TotalRows);
try
{
ProcessCategories(context, batch, templateViewPaths, srcToDestId);
}
catch (Exception exception)
{
context.Result.AddError(exception, segmenter.CurrentSegment, "ProcessCategories");
}
// reduce batch to saved (valid) products.
// No need to perform import operations on errored products.
batch = batch.Where(x => x.Entity != null && !x.IsTransient).ToArray();
// update result object
context.Result.NewRecords += batch.Count(x => x.IsNew && !x.IsTransient);
context.Result.ModifiedRecords += batch.Count(x => !x.IsNew && !x.IsTransient);
// process slugs
if (segmenter.HasColumn("SeName") || batch.Any(x => x.IsNew || x.NameChanged))
{
try
{
_categoryRepository.Context.AutoDetectChangesEnabled = true;
ProcessSlugs(context, batch);
}
catch (Exception exception)
{
context.Result.AddError(exception, segmenter.CurrentSegment, "ProcessSlugs");
}
finally
{
_categoryRepository.Context.AutoDetectChangesEnabled = false;
}
}
// process store mappings
if (segmenter.HasColumn("LimitedToStores") && segmenter.HasColumn("StoreIds"))
{
try
{
_categoryRepository.Context.AutoDetectChangesEnabled = true;
ProcessStoreMappings(context, batch);
}
catch (Exception exception)
{
context.Result.AddError(exception, segmenter.CurrentSegment, "ProcessStoreMappings");
}
finally
{
_categoryRepository.Context.AutoDetectChangesEnabled = false;
}
}
// localizations
try
{
ProcessLocalizations(context, batch);
}
catch (Exception exception)
{
context.Result.AddError(exception, segmenter.CurrentSegment, "ProcessLocalizedProperties");
}
// process pictures
if (srcToDestId.Any() && segmenter.HasColumn("ImageUrl"))
{
try
{
_categoryRepository.Context.AutoDetectChangesEnabled = true;
ProcessPictures(context, batch, srcToDestId);
}
catch (Exception exception)
{
context.Result.AddError(exception, segmenter.CurrentSegment, "ProcessPictures");
}
finally
{
_categoryRepository.Context.AutoDetectChangesEnabled = false;
}
}
}
// map parent id of inserted categories
if (srcToDestId.Any() && segmenter.HasColumn("Id") && segmenter.HasColumn("ParentCategoryId"))
{
segmenter.Reset();
while (context.Abort == DataExchangeAbortion.None && segmenter.ReadNextBatch())
{
var batch = segmenter.CurrentBatch;
_categoryRepository.Context.DetachAll(false);
try
{
ProcessParentMappings(context, batch, srcToDestId);
}
catch (Exception exception)
{
context.Result.AddError(exception, segmenter.CurrentSegment, "ProcessParentMappings");
}
}
}
}
}