/// <summary>
/// Prepare customer search model
/// </summary>
/// <param name="searchModel">Customer search model</param>
/// <returns>Customer search model</returns>
public virtual CustomerSearchModel PrepareCustomerSearchModel(CustomerSearchModel searchModel)
{
if (searchModel == null)
{
throw new ArgumentNullException(nameof(searchModel));
}
searchModel.UsernamesEnabled = _customerSettings.UsernamesEnabled;
searchModel.AvatarEnabled = _customerSettings.AllowCustomersToUploadAvatars;
searchModel.DateOfBirthEnabled = _customerSettings.DateOfBirthEnabled;
searchModel.CompanyEnabled = _customerSettings.CompanyEnabled;
searchModel.PhoneEnabled = _customerSettings.PhoneEnabled;
searchModel.ZipPostalCodeEnabled = _customerSettings.ZipPostalCodeEnabled;
//search registered customers by default
var registeredRole = _customerService.GetCustomerRoleBySystemName(NopCustomerDefaults.RegisteredRoleName);
if (registeredRole != null)
{
searchModel.SelectedCustomerRoleIds.Add(registeredRole.Id);
}
//prepare available customer roles
_aclSupportedModelFactory.PrepareModelCustomerRoles(searchModel);
//prepare page parameters
searchModel.SetGridPageSize();
return(searchModel);
}
/// <summary>
/// Prepare category model
/// </summary>
/// <param name="model">Category model</param>
/// <param name="category">Category</param>
/// <param name="excludeProperties">Whether to exclude populating of some properties of model</param>
/// <returns>Category model</returns>
public virtual CategoryModel PrepareCategoryModel(CategoryModel model, Category category, bool excludeProperties = false)
{
Action <CategoryLocalizedModel, int> localizedModelConfiguration = null;
if (category != null)
{
//fill in model values from the entity
model = model ?? category.ToModel <CategoryModel>();
//prepare nested search model
PrepareCategoryProductSearchModel(model.CategoryProductSearchModel, category);
//define localized model configuration action
localizedModelConfiguration = (locale, languageId) =>
{
locale.Name = _localizationService.GetLocalized(category, entity => entity.Name, languageId, false, false);
locale.Description = _localizationService.GetLocalized(category, entity => entity.Description, languageId, false, false);
locale.MetaKeywords = _localizationService.GetLocalized(category, entity => entity.MetaKeywords, languageId, false, false);
locale.MetaDescription = _localizationService.GetLocalized(category, entity => entity.MetaDescription, languageId, false, false);
locale.MetaTitle = _localizationService.GetLocalized(category, entity => entity.MetaTitle, languageId, false, false);
locale.SeName = _urlRecordService.GetSeName(category, languageId, false, false);
};
}
//set default values for the new model
if (category == null)
{
model.PageSize = _catalogSettings.DefaultCategoryPageSize;
model.PageSizeOptions = _catalogSettings.DefaultCategoryPageSizeOptions;
model.Published = true;
model.IncludeInTopMenu = true;
model.AllowCustomersToSelectPageSize = true;
}
//prepare localized models
if (!excludeProperties)
{
model.Locales = _localizedModelFactory.PrepareLocalizedModels(localizedModelConfiguration);
}
//prepare available category templates
_baseAdminModelFactory.PrepareCategoryTemplates(model.AvailableCategoryTemplates, false);
//prepare available parent categories
_baseAdminModelFactory.PrepareCategories(model.AvailableCategories,
defaultItemText: _localizationService.GetResource("Admin.Catalog.Categories.Fields.Parent.None"));
//prepare model discounts
var availableDiscounts = _discountService.GetAllDiscounts(DiscountType.AssignedToCategories, showHidden: true);
_discountSupportedModelFactory.PrepareModelDiscounts(model, category, availableDiscounts, excludeProperties);
//prepare model customer roles
_aclSupportedModelFactory.PrepareModelCustomerRoles(model, category, excludeProperties);
//prepare model stores
_storeMappingSupportedModelFactory.PrepareModelStores(model, category, excludeProperties);
return(model);
}
/// <summary>
/// Prepare manufacturer model
/// </summary>
/// <param name="model">Manufacturer model</param>
/// <param name="manufacturer">Manufacturer</param>
/// <param name="excludeProperties">Whether to exclude populating of some properties of model</param>
/// <returns>Manufacturer model</returns>
public virtual ManufacturerModel PrepareManufacturerModel(ManufacturerModel model,
Manufacturer manufacturer, bool excludeProperties = false)
{
Action <ManufacturerLocalizedModel, int> localizedModelConfiguration = null;
if (manufacturer != null)
{
//fill in model values from the entity
if (model == null)
{
model = manufacturer.ToModel <ManufacturerModel>();
model.SeName = _urlRecordService.GetSeName(manufacturer, 0, true, false);
}
//prepare nested search model
PrepareManufacturerProductSearchModel(model.ManufacturerProductSearchModel, manufacturer);
//define localized model configuration action
localizedModelConfiguration = (locale, languageId) =>
{
locale.Name = _localizationService.GetLocalized(manufacturer, entity => entity.Name, languageId, false, false);
locale.Description = _localizationService.GetLocalized(manufacturer, entity => entity.Description, languageId, false, false);
locale.MetaKeywords = _localizationService.GetLocalized(manufacturer, entity => entity.MetaKeywords, languageId, false, false);
locale.MetaDescription = _localizationService.GetLocalized(manufacturer, entity => entity.MetaDescription, languageId, false, false);
locale.MetaTitle = _localizationService.GetLocalized(manufacturer, entity => entity.MetaTitle, languageId, false, false);
locale.SeName = _urlRecordService.GetSeName(manufacturer, languageId, false, false);
};
}
//set default values for the new model
if (manufacturer == null)
{
model.PageSize = _catalogSettings.DefaultManufacturerPageSize;
model.PageSizeOptions = _catalogSettings.DefaultManufacturerPageSizeOptions;
model.Published = true;
model.AllowCustomersToSelectPageSize = true;
}
//prepare localized models
if (!excludeProperties)
{
model.Locales = _localizedModelFactory.PrepareLocalizedModels(localizedModelConfiguration);
}
//prepare available manufacturer templates
_baseAdminModelFactory.PrepareManufacturerTemplates(model.AvailableManufacturerTemplates, false);
//prepare model discounts
var availableDiscounts = _discountService.GetAllDiscounts(DiscountType.AssignedToManufacturers, showHidden: true);
_discountSupportedModelFactory.PrepareModelDiscounts(model, manufacturer, availableDiscounts, excludeProperties);
//prepare model customer roles
_aclSupportedModelFactory.PrepareModelCustomerRoles(model, manufacturer, excludeProperties);
//prepare model stores
_storeMappingSupportedModelFactory.PrepareModelStores(model, manufacturer, excludeProperties);
return(model);
}
/// <summary>
/// Prepare topic model
/// </summary>
/// <param name="model">Topic model</param>
/// <param name="topic">Topic</param>
/// <param name="excludeProperties">Whether to exclude populating of some properties of model</param>
/// <returns>Topic model</returns>
public virtual TopicModel PrepareTopicModel(TopicModel model, Topic topic, bool excludeProperties = false)
{
Action <TopicLocalizedModel, int> localizedModelConfiguration = null;
if (topic != null)
{
//fill in model values from the entity
model = model ?? topic.ToModel <TopicModel>();
model.Url = _urlHelperFactory.GetUrlHelper(_actionContextAccessor.ActionContext)
.RouteUrl("Topic", new { SeName = _urlRecordService.GetSeName(topic) }, _webHelper.CurrentRequestProtocol);
//define localized model configuration action
localizedModelConfiguration = (locale, languageId) =>
{
locale.Title = _localizationService.GetLocalized(topic, entity => entity.Title, languageId, false, false);
locale.Body = _localizationService.GetLocalized(topic, entity => entity.Body, languageId, false, false);
locale.MetaKeywords = _localizationService.GetLocalized(topic, entity => entity.MetaKeywords, languageId, false, false);
locale.MetaDescription = _localizationService.GetLocalized(topic, entity => entity.MetaDescription, languageId, false, false);
locale.MetaTitle = _localizationService.GetLocalized(topic, entity => entity.MetaTitle, languageId, false, false);
locale.SeName = _urlRecordService.GetSeName(topic, languageId, false, false);
};
}
//set default values for the new model
if (topic == null)
{
model.DisplayOrder = 1;
model.Published = true;
}
//prepare localized models
if (!excludeProperties)
{
model.Locales = _localizedModelFactory.PrepareLocalizedModels(localizedModelConfiguration);
}
//prepare available topic templates
_baseAdminModelFactory.PrepareTopicTemplates(model.AvailableTopicTemplates, false);
//prepare model customer roles
_aclSupportedModelFactory.PrepareModelCustomerRoles(model, topic, excludeProperties);
//prepare model stores
_storeMappingSupportedModelFactory.PrepareModelStores(model, topic, excludeProperties);
model.AvailableCategories = _topicService
.GetAllTopicCategories()
.Select(x => new Microsoft.AspNetCore.Mvc.Rendering.SelectListItem()
{
Value = x.Id.ToString(), Text = x.Name
})
.ToList();
return(model);
}
/// <summary>
/// Prepare topic model
/// </summary>
/// <param name="model">Topic model</param>
/// <param name="topic">Topic</param>
/// <param name="excludeProperties">Whether to exclude populating of some properties of model</param>
/// <returns>Topic model</returns>
public virtual TopicModel PrepareTopicModel(TopicModel model, Topic topic, bool excludeProperties = false)
{
Action <TopicLocalizedModel, int> localizedModelConfiguration = null;
if (topic != null)
{
//fill in model values from the entity
model = model ?? topic.ToModel();
model.Url = _urlHelperFactory.GetUrlHelper(_actionContextAccessor.ActionContext)
.RouteUrl("Topic", new { SeName = topic.GetSeName() }, _webHelper.CurrentRequestProtocol);
//define localized model configuration action
localizedModelConfiguration = (locale, languageId) =>
{
locale.Title = topic.GetLocalized(entity => entity.Title, languageId, false, false);
locale.Body = topic.GetLocalized(entity => entity.Body, languageId, false, false);
locale.MetaKeywords = topic.GetLocalized(entity => entity.MetaKeywords, languageId, false, false);
locale.MetaDescription = topic.GetLocalized(entity => entity.MetaDescription, languageId, false, false);
locale.MetaTitle = topic.GetLocalized(entity => entity.MetaTitle, languageId, false, false);
locale.SeName = topic.GetSeName(languageId, false, false);
};
}
//set default values for the new model
if (topic == null)
{
model.DisplayOrder = 1;
model.Published = true;
}
//prepare localized models
if (!excludeProperties)
{
model.Locales = _localizedModelFactory.PrepareLocalizedModels(localizedModelConfiguration);
}
//prepare available topic templates
_baseAdminModelFactory.PrepareTopicTemplates(model.AvailableTopicTemplates, false);
//prepare model customer roles
_aclSupportedModelFactory.PrepareModelCustomerRoles(model, topic, excludeProperties);
//prepare model stores
_storeMappingSupportedModelFactory.PrepareModelStores(model, topic, excludeProperties);
return(model);
}
/// <summary>
/// Prepare plugin model
/// </summary>
/// <param name="model">Plugin model</param>
/// <param name="pluginDescriptor">Plugin descriptor</param>
/// <param name="excludeProperties">Whether to exclude populating of some properties of model</param>
/// <returns>Plugin model</returns>
public virtual PluginModel PreparePluginModel(PluginModel model, PluginDescriptor pluginDescriptor, bool excludeProperties = false)
{
Action <PluginLocalizedModel, int> localizedModelConfiguration = null;
if (pluginDescriptor != null)
{
//fill in model values from the entity
model ??= pluginDescriptor.ToPluginModel(model);
model.LogoUrl = _pluginService.GetPluginLogoUrl(pluginDescriptor);
model.SelectedStoreIds = pluginDescriptor.LimitedToStores;
model.SelectedCustomerRoleIds = pluginDescriptor.LimitedToCustomerRoles;
var plugin = pluginDescriptor.Instance <IPlugin>();
if (pluginDescriptor.Installed)
{
PrepareInstalledPluginModel(model, plugin);
}
//define localized model configuration action
localizedModelConfiguration = (locale, languageId) =>
{
locale.FriendlyName = _localizationService.GetLocalizedFriendlyName(plugin, languageId, false);
};
}
//prepare localized models
if (!excludeProperties)
{
model.Locales = _localizedModelFactory.PrepareLocalizedModels(localizedModelConfiguration);
}
//prepare model customer roles
_aclSupportedModelFactory.PrepareModelCustomerRoles(model);
//prepare available stores
_storeMappingSupportedModelFactory.PrepareModelStores(model);
return(model);
}
/// <summary>
/// Prepare product model
/// </summary>
/// <param name="model">Product model</param>
/// <param name="product">Product</param>
/// <param name="excludeProperties">Whether to exclude populating of some properties of model</param>
/// <returns>Product model</returns>
public virtual ProductModel PrepareProductModel(ProductModel model, Product product, bool excludeProperties = false)
{
Action <ProductLocalizedModel, int> localizedModelConfiguration = null;
if (product != null)
{
//fill in model values from the entity
model = model ?? product.ToModel <ProductModel>();
var parentGroupedProduct = _productService.GetProductById(product.ParentGroupedProductId);
if (parentGroupedProduct != null)
{
model.AssociatedToProductId = product.ParentGroupedProductId;
model.AssociatedToProductName = parentGroupedProduct.Name;
}
model.CreatedOn = _dateTimeHelper.ConvertToUserTime(product.CreatedOnUtc, DateTimeKind.Utc);
model.UpdatedOn = _dateTimeHelper.ConvertToUserTime(product.UpdatedOnUtc, DateTimeKind.Utc);
model.ProductTags = string.Join(", ", _productTagService.GetAllProductTagsByProductId(product.Id).Select(tag => tag.Name));
if (!excludeProperties)
{
model.SelectedCategoryIds = _categoryService.GetProductCategoriesByProductId(product.Id, true)
.Select(productCategory => productCategory.CategoryId).ToList();
}
//prepare copy product model
PrepareCopyProductModel(model.CopyProductModel, product);
//prepare nested search model
PrepareRelatedProductSearchModel(model.RelatedProductSearchModel, product);
PrepareAssociatedProductSearchModel(model.AssociatedProductSearchModel, product);
PrepareProductPictureSearchModel(model.ProductPictureSearchModel, product);
//define localized model configuration action
localizedModelConfiguration = (locale, languageId) =>
{
locale.Name = _localizationService.GetLocalized(product, entity => entity.Name, languageId, false, false);
locale.FullDescription = _localizationService.GetLocalized(product, entity => entity.FullDescription, languageId, false, false);
locale.ShortDescription = _localizationService.GetLocalized(product, entity => entity.ShortDescription, languageId, false, false);
locale.MetaKeywords = _localizationService.GetLocalized(product, entity => entity.MetaKeywords, languageId, false, false);
locale.MetaDescription = _localizationService.GetLocalized(product, entity => entity.MetaDescription, languageId, false, false);
locale.MetaTitle = _localizationService.GetLocalized(product, entity => entity.MetaTitle, languageId, false, false);
locale.SeName = _urlRecordService.GetSeName(product, languageId, false, false);
};
}
//set default values for the new model
if (product == null)
{
model.AllowCustomerReviews = true;
model.Published = true;
model.VisibleIndividually = true;
}
model.IsLoggedInAsVendor = _workContext.CurrentVendor != null;
//prepare localized models
if (!excludeProperties)
{
model.Locales = _localizedModelFactory.PrepareLocalizedModels(localizedModelConfiguration);
}
//prepare editor settings
model.ProductEditorSettingsModel = _settingModelFactory.PrepareProductEditorSettingsModel();
//prepare available product templates
_baseAdminModelFactory.PrepareProductTemplates(model.AvailableProductTemplates, false);
//prepare available product types
var productTemplates = _productTemplateService.GetAllProductTemplates();
foreach (var productType in Enum.GetValues(typeof(ProductType)).OfType <ProductType>())
{
model.ProductsTypesSupportedByProductTemplates.Add((int)productType, new List <SelectListItem>());
foreach (var template in productTemplates)
{
var list = (IList <int>)TypeDescriptor.GetConverter(typeof(List <int>)).ConvertFrom(template.IgnoredProductTypes) ?? new List <int>();
if (string.IsNullOrEmpty(template.IgnoredProductTypes) || !list.Contains((int)productType))
{
model.ProductsTypesSupportedByProductTemplates[(int)productType].Add(new SelectListItem
{
Text = template.Name,
Value = template.Id.ToString()
});
}
}
}
//prepare available vendors
_baseAdminModelFactory.PrepareVendors(model.AvailableVendors,
defaultItemText: _localizationService.GetResource("Admin.Catalog.Products.Fields.Vendor.None"));
//prepare model categories
_baseAdminModelFactory.PrepareCategories(model.AvailableCategories, false);
foreach (var categoryItem in model.AvailableCategories)
{
categoryItem.Selected = int.TryParse(categoryItem.Value, out var categoryId) &&
model.SelectedCategoryIds.Contains(categoryId);
}
//prepare model customer roles
_aclSupportedModelFactory.PrepareModelCustomerRoles(model, product, excludeProperties);
//prepare model stores
_storeMappingSupportedModelFactory.PrepareModelStores(model, product, excludeProperties);
return(model);
}
public BookDirModel PrepareBookDirModel(BookDirModel model, BookDir bookdir = null, bool excludeProperties = false)
{
Action <BookDirLocalizedModel, int> localizedModelConfiguration = null;
if (bookdir != null)
{
//fill in model values from the entity
if (model == null)
{
model = bookdir.ToModel <BookDirModel>();
model.SeName = _urlRecordService.GetSeName(bookdir, 0, true, false);
}
var result = _productService.GetProductById(bookdir.BookID);
if (result != null)
{
if (result.ProductCategories != null)
{
model.CategryID = result.ProductCategories.FirstOrDefault().CategoryId;
}
model.BookID = result.Id;
var products = _productService.SearchProducts(showHidden: true,
categoryIds: new List <int>()
{
model.CategryID
},
manufacturerId: 0,
storeId: 0,
vendorId: 0,
warehouseId: 0,
productType: null,
keywords: null,
pageIndex: 0,
pageSize: int.MaxValue);
// model.BookList = products.ToList().ToSelect<Product>()
}
//prepare nested search model
// PrepareBookDirSearchModel()
// PrepareCategoryProductSearchModel(model.CategoryProductSearchModel, category);
//define localized model configuration action
localizedModelConfiguration = (locale, languageId) =>
{
locale.Name = _localizationService.GetLocalized(bookdir, entity => entity.Name, languageId, false, false);
locale.Description = _localizationService.GetLocalized(bookdir, entity => entity.Description, languageId, false, false);
locale.MetaKeywords = _localizationService.GetLocalized(bookdir, entity => entity.MetaKeywords, languageId, false, false);
locale.MetaDescription = _localizationService.GetLocalized(bookdir, entity => entity.MetaDescription, languageId, false, false);
//locale.MetaTitle = _localizationService.GetLocalized(category, entity => entity.MetaTitle, languageId, false, false);
//locale.SeName = _urlRecordService.GetSeName(category, languageId, false, false);
};
}
//set default values for the new model
if (bookdir == null)
{
if (model == null)
{
model = new BookDirModel();
}
//model.PageSize = _catalogSettings.DefaultCategoryPageSize;
// model.PageSizeOptions = _catalogSettings.DefaultCategoryPageSizeOptions;
model.Published = true;
// model.IncludeInTopMenu = true;
model.AllowCustomersToSelectPageSize = true;
}
//prepare localized models
if (!excludeProperties)
{
model.Locales = _localizedModelFactory.PrepareLocalizedModels(localizedModelConfiguration);
}
//prepare available category templates
// _baseAdminModelFactory.PrepareCategoryTemplates(model.AvailableCategoryTemplates, false);
//prepare available parent categories
_baseAdminModelFactory.PrepareCategories(model.AvailableCategories,
defaultItemText: _localizationService.GetResource("Admin.Catalog.Categories.Fields.Parent.None"));
//prepare model discounts
// var availableDiscounts = _discountService.GetAllDiscounts(DiscountType.AssignedToCategories, showHidden: true);
//_discountSupportedModelFactory.PrepareModelDiscounts(model, category, availableDiscounts, excludeProperties);
//prepare model customer roles
_aclSupportedModelFactory.PrepareModelCustomerRoles(model, bookdir, excludeProperties);
//prepare model stores
_storeMappingSupportedModelFactory.PrepareModelStores(model, bookdir, excludeProperties);
return(model);
}
