public virtual ActionResult ManufacturerTemplateUpdate(ManufacturerTemplateModel model)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageMaintenance))
{
return(AccessDeniedView());
}
if (!ModelState.IsValid)
{
return(Json(new DataSourceResult {
Errors = ModelState.SerializeErrors()
}));
}
var template = _manufacturerTemplateService.GetManufacturerTemplateById(model.Id);
if (template == null)
{
throw new ArgumentException("No template found with the specified id");
}
template = model.ToEntity(template);
_manufacturerTemplateService.UpdateManufacturerTemplate(template);
return(new NullJsonResult());
}
public ActionResult ManufacturerTemplateUpdate(ManufacturerTemplateModel 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 = _manufacturerTemplateService.GetManufacturerTemplateById(model.Id);
if (template == null)
{
throw new ArgumentException("No template found with the specified id");
}
template = model.ToEntity(template);
_manufacturerTemplateService.UpdateManufacturerTemplate(template);
return(ManufacturerTemplates(command));
}
public IActionResult ManufacturerTemplateUpdate(ManufacturerTemplateModel model)
{
if (!ModelState.IsValid)
{
return(Json(new DataSourceResult {
Errors = ModelState.SerializeErrors()
}));
}
var template = _manufacturerTemplateService.GetManufacturerTemplateById(model.Id);
if (template == null)
{
throw new ArgumentException("No template found with the specified id");
}
if (ModelState.IsValid)
{
template = model.ToEntity(template);
_manufacturerTemplateService.UpdateManufacturerTemplate(template);
return(new NullJsonResult());
}
return(ErrorForKendoGridJson(ModelState));
}
public ManufacturerValidator(IEnumerable <IValidatorConsumer <ManufacturerDto> > validators,
ILocalizationService localizationService, IPictureService pictureService, IManufacturerService manufacturerService, IManufacturerTemplateService manufacturerTemplateService)
: base(validators)
{
RuleFor(x => x.Name).NotEmpty().WithMessage(localizationService.GetResource("Api.Catalog.Manufacturer.Fields.Name.Required"));
RuleFor(x => x.PageSizeOptions).Must(FluentValidationUtilities.PageSizeOptionsValidator).WithMessage(localizationService.GetResource("Api.Catalog.Manufacturer.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.Manufacturer.Fields.PictureId.NotExists"));
RuleFor(x => x).MustAsync(async(x, y, context) =>
{
if (!string.IsNullOrEmpty(x.ManufacturerTemplateId))
{
var template = await manufacturerTemplateService.GetManufacturerTemplateById(x.ManufacturerTemplateId);
if (template == null)
{
return(false);
}
}
return(true);
}).WithMessage(localizationService.GetResource("Api.Catalog.Manufacturer.Fields.ManufacturerTemplateId.NotExists"));
RuleFor(x => x).MustAsync(async(x, y, context) =>
{
if (!string.IsNullOrEmpty(x.Id))
{
var manufacturer = await manufacturerService.GetManufacturerById(x.Id);
if (manufacturer == null)
{
return(false);
}
}
return(true);
}).WithMessage(localizationService.GetResource("Api.Catalog.Manufacturer.Fields.Id.NotExists"));
}
public async Task <string> Handle(GetManufacturerTemplateViewPath request, CancellationToken cancellationToken)
{
var templateCacheKey = string.Format(ModelCacheEventConst.MANUFACTURER_TEMPLATE_MODEL_KEY, request.TemplateId);
var templateViewPath = await _cacheManager.GetAsync(templateCacheKey, async() =>
{
var template = await _manufacturerTemplateService.GetManufacturerTemplateById(request.TemplateId);
if (template == null)
{
template = (await _manufacturerTemplateService.GetAllManufacturerTemplates()).FirstOrDefault();
}
if (template == null)
{
throw new Exception("No default template could be loaded");
}
return(template.ViewPath);
});
return(templateViewPath);
}
/// <summary>
/// Prepare manufacturer template view path
/// </summary>
/// <param name="templateId">Template identifier</param>
/// <returns>Manufacturer template view path</returns>
public virtual string PrepareManufacturerTemplateViewPath(int templateId)
{
var templateCacheKey = string.Format(ModelCacheEventConsumer.MANUFACTURER_TEMPLATE_MODEL_KEY, templateId);
var templateViewPath = _cacheManager.Get(templateCacheKey, () =>
{
var template = _manufacturerTemplateService.GetManufacturerTemplateById(templateId);
if (template == null)
{
template = _manufacturerTemplateService.GetAllManufacturerTemplates().FirstOrDefault();
}
if (template == null)
{
throw new Exception("No default template could be loaded");
}
return(template.ViewPath);
});
return(templateViewPath);
}
public ActionResult Manufacturer(int manufacturerId, CatalogSearchQuery query)
{
var manufacturer = _manufacturerService.GetManufacturerById(manufacturerId);
if (manufacturer == null || manufacturer.Deleted)
{
return(HttpNotFound());
}
// Check whether the current user has a "Manage catalog" permission.
// It allows him to preview a manufacturer before publishing.
if (!manufacturer.Published && !Services.Permissions.Authorize(Permissions.Catalog.Manufacturer.Read))
{
return(HttpNotFound());
}
// ACL (access control list).
if (!_aclService.Authorize(manufacturer))
{
return(HttpNotFound());
}
// Store mapping.
if (!_storeMappingService.Authorize(manufacturer))
{
return(HttpNotFound());
}
var store = Services.StoreContext.CurrentStore;
var customer = Services.WorkContext.CurrentCustomer;
// 'Continue shopping' URL.
if (!customer.IsSystemAccount)
{
_genericAttributeService.SaveAttribute(customer, SystemCustomerAttributeNames.LastContinueShoppingPage, Services.WebHelper.GetThisPageUrl(false), store.Id);
}
var model = manufacturer.ToModel();
if (query.IsSubPage && !_catalogSettings.ShowDescriptionInSubPages)
{
model.Description.ChangeValue(string.Empty);
model.BottomDescription.ChangeValue(string.Empty);
}
model.PictureModel = _helper.PrepareManufacturerPictureModel(manufacturer, model.Name);
// Featured products.
var hideFeaturedProducts = _catalogSettings.IgnoreFeaturedProducts || (query.IsSubPage && !_catalogSettings.IncludeFeaturedProductsInSubPages);
if (!hideFeaturedProducts)
{
CatalogSearchResult featuredProductsResult = null;
var customerRolesIds = customer.CustomerRoleMappings
.Select(x => x.CustomerRole)
.Where(x => x.Active)
.Select(x => x.Id)
.ToList();
var cacheKey = ModelCacheEventConsumer.MANUFACTURER_HAS_FEATURED_PRODUCTS_KEY.FormatInvariant(manufacturerId, string.Join(",", customerRolesIds), store.Id);
var hasFeaturedProductsCache = Services.Cache.Get <bool?>(cacheKey);
var featuredProductsQuery = new CatalogSearchQuery()
.VisibleOnly(customer)
.WithVisibility(ProductVisibility.Full)
.WithManufacturerIds(true, manufacturerId)
.HasStoreId(store.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)
{
// TODO: (mc) determine settings properly
var featuredProductsmappingSettings = _helper.GetBestFitProductSummaryMappingSettings(ProductSummaryViewMode.Grid);
model.FeaturedProducts = _helper.MapProductSummaryModel(featuredProductsResult.Hits, featuredProductsmappingSettings);
}
}
// Products
query.WithManufacturerIds(_catalogSettings.IncludeFeaturedProductsInNormalLists ? null : (bool?)false, manufacturerId);
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, manufacturer, _catalogSettings.DefaultPageSizeOptions);
// Template
var templateCacheKey = string.Format(ModelCacheEventConsumer.MANUFACTURER_TEMPLATE_MODEL_KEY, manufacturer.ManufacturerTemplateId);
var templateViewPath = Services.Cache.Get(templateCacheKey, () =>
{
var template = _manufacturerTemplateService.GetManufacturerTemplateById(manufacturer.ManufacturerTemplateId);
if (template == null)
{
template = _manufacturerTemplateService.GetAllManufacturerTemplates().FirstOrDefault();
}
return(template.ViewPath);
});
//activity log
Services.CustomerActivity.InsertActivity("PublicStore.ViewManufacturer", T("ActivityLog.PublicStore.ViewManufacturer"), manufacturer.Name);
Services.DisplayControl.Announce(manufacturer);
return(View(templateViewPath, model));
}