public ActionResult CategoryTemplateUpdate(CategoryTemplateModel model, GridCommand command)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageMaintenance))
{
return(AccessDeniedView());
}
if (!ModelState.IsValid)
{
//display the first model error
var modelStateErrors = this.ModelState.Values.SelectMany(x => x.Errors).Select(x => x.ErrorMessage);
return(Content(modelStateErrors.FirstOrDefault()));
}
var template = _categoryTemplateService.GetCategoryTemplateById(model.Id);
if (template == null)
{
throw new ArgumentException("No template found with the specified id");
}
template = model.ToEntity(template);
_categoryTemplateService.UpdateCategoryTemplate(template);
return(CategoryTemplates(command));
}
public virtual ActionResult CategoryTemplateUpdate(CategoryTemplateModel model)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageMaintenance))
{
return(AccessDeniedView());
}
if (!ModelState.IsValid)
{
return(Json(new DataSourceResult {
Errors = ModelState.SerializeErrors()
}));
}
var template = _categoryTemplateService.GetCategoryTemplateById(model.Id);
if (template == null)
{
throw new ArgumentException("No template found with the specified id");
}
template = model.ToEntity(template);
_categoryTemplateService.UpdateCategoryTemplate(template);
return(new NullJsonResult());
}
public CategoryValidator(IEnumerable <IValidatorConsumer <CategoryDto> > validators,
ILocalizationService localizationService, IPictureService pictureService, ICategoryService categoryService, ICategoryTemplateService
categoryTemplateService) : base(validators)
{
RuleFor(x => x.Name).NotEmpty().WithMessage(localizationService.GetResource("Api.Catalog.Category.Fields.Name.Required"));
RuleFor(x => x.PageSizeOptions).Must(FluentValidationUtilities.PageSizeOptionsValidator).WithMessage(localizationService.GetResource("Api.Catalog.Category.Fields.PageSizeOptions.ShouldHaveUniqueItems"));
RuleFor(x => x).MustAsync(async(x, y, context) =>
{
if (!string.IsNullOrEmpty(x.PictureId))
{
var picture = await pictureService.GetPictureById(x.PictureId);
if (picture == null)
{
return(false);
}
}
return(true);
}).WithMessage(localizationService.GetResource("Api.Catalog.Category.Fields.PictureId.NotExists"));
RuleFor(x => x).MustAsync(async(x, y, context) =>
{
if (!string.IsNullOrEmpty(x.ParentCategoryId))
{
var category = await categoryService.GetCategoryById(x.ParentCategoryId);
if (category == null)
{
return(false);
}
}
return(true);
}).WithMessage(localizationService.GetResource("Api.Catalog.Category.Fields.ParentCategoryId.NotExists"));
RuleFor(x => x).MustAsync(async(x, y, context) =>
{
if (!string.IsNullOrEmpty(x.CategoryTemplateId))
{
var template = await categoryTemplateService.GetCategoryTemplateById(x.CategoryTemplateId);
if (template == null)
{
return(false);
}
}
return(true);
}).WithMessage(localizationService.GetResource("Api.Catalog.Category.Fields.CategoryTemplateId.NotExists"));
RuleFor(x => x).MustAsync(async(x, y, context) =>
{
if (!string.IsNullOrEmpty(x.Id))
{
var category = await categoryService.GetCategoryById(x.Id);
if (category == null)
{
return(false);
}
}
return(true);
}).WithMessage(localizationService.GetResource("Api.Catalog.Category.Fields.Id.NotExists"));
}
public virtual IActionResult CategoryTemplateUpdate(CategoryTemplateModel model)
{
if (!ModelState.IsValid)
{
return(Json(new DataSourceResult {
Errors = ModelState.SerializeErrors()
}));
}
//try to get a category template with the specified id
CategoryTemplate template = _categoryTemplateService.GetCategoryTemplateById(model.Id)
?? throw new ArgumentException("No template found with the specified id");
template = model.ToEntity(template);
_categoryTemplateService.UpdateCategoryTemplate(template);
return(new NullJsonResult());
}
public async Task <IActionResult> CategoryTemplateUpdate(CategoryTemplateModel model)
{
if (!ModelState.IsValid)
{
return(Json(new DataSourceResult {
Errors = ModelState.SerializeErrors()
}));
}
var template = await _categoryTemplateService.GetCategoryTemplateById(model.Id);
if (template == null)
{
throw new ArgumentException("No template found with the specified id");
}
if (ModelState.IsValid)
{
template = model.ToEntity(template);
await _categoryTemplateService.UpdateCategoryTemplate(template);
return(new NullJsonResult());
}
return(ErrorForKendoGridJson(ModelState));
}
/// <summary>
/// Prepare category template view path
/// </summary>
/// <param name="templateId">Template identifier</param>
/// <returns>Category template view path</returns>
public virtual string PrepareCategoryTemplateViewPath(int templateId)
{
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);
}
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);
}
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));
}