/// <summary>
/// Prepare specification attribute group model
/// </summary>
/// <param name="model">Specification attribute group model</param>
/// <param name="specificationAttributeGroup">Specification attribute group</param>
/// <param name="excludeProperties">Whether to exclude populating of some properties of model</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the specification attribute group model
/// </returns>
public virtual async Task <SpecificationAttributeGroupModel> PrepareSpecificationAttributeGroupModelAsync(SpecificationAttributeGroupModel model,
SpecificationAttributeGroup specificationAttributeGroup, bool excludeProperties = false)
{
Func <SpecificationAttributeGroupLocalizedModel, int, Task> localizedModelConfiguration = null;
if (specificationAttributeGroup != null)
{
//fill in model values from the entity
model ??= specificationAttributeGroup.ToModel <SpecificationAttributeGroupModel>();
//define localized model configuration action
localizedModelConfiguration = async(locale, languageId) =>
{
locale.Name = await _localizationService.GetLocalizedAsync(specificationAttributeGroup, entity => entity.Name, languageId, false, false);
};
}
//prepare localized models
if (!excludeProperties)
{
model.Locales = await _localizedModelFactory.PrepareLocalizedModelsAsync(localizedModelConfiguration);
}
return(model);
}
/// <summary>
/// Prepare shipping method model
/// </summary>
/// <param name="model">Shipping method model</param>
/// <param name="shippingMethod">Shipping method</param>
/// <param name="excludeProperties">Whether to exclude populating of some properties of model</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the shipping method model
/// </returns>
public virtual async Task <ShippingMethodModel> PrepareShippingMethodModelAsync(ShippingMethodModel model,
ShippingMethod shippingMethod, bool excludeProperties = false)
{
Action <ShippingMethodLocalizedModel, int> localizedModelConfiguration = null;
if (shippingMethod != null)
{
//fill in model values from the entity
model ??= shippingMethod.ToModel <ShippingMethodModel>();
//define localized model configuration action
localizedModelConfiguration = async(locale, languageId) =>
{
locale.Name = await _localizationService.GetLocalizedAsync(shippingMethod, entity => entity.Name, languageId, false, false);
locale.Description = await _localizationService.GetLocalizedAsync(shippingMethod, entity => entity.Description, languageId, false, false);
};
}
//prepare localized models
if (!excludeProperties)
{
model.Locales = await _localizedModelFactory.PrepareLocalizedModelsAsync(localizedModelConfiguration);
}
return(model);
}
/// <summary>
/// Prepare customer attribute model
/// </summary>
/// <param name="model">Customer attribute model</param>
/// <param name="customerAttribute">Customer attribute</param>
/// <param name="excludeProperties">Whether to exclude populating of some properties of model</param>
/// <returns>Customer attribute model</returns>
public virtual async Task <CustomerAttributeModel> PrepareCustomerAttributeModelAsync(CustomerAttributeModel model,
CustomerAttribute customerAttribute, bool excludeProperties = false)
{
Action <CustomerAttributeLocalizedModel, int> localizedModelConfiguration = null;
if (customerAttribute != null)
{
//fill in model values from the entity
model ??= customerAttribute.ToModel <CustomerAttributeModel>();
//prepare nested search model
PrepareCustomerAttributeValueSearchModel(model.CustomerAttributeValueSearchModel, customerAttribute);
//define localized model configuration action
localizedModelConfiguration = async(locale, languageId) =>
{
locale.Name = await _localizationService.GetLocalizedAsync(customerAttribute, entity => entity.Name, languageId, false, false);
};
}
//prepare localized models
if (!excludeProperties)
{
model.Locales = await _localizedModelFactory.PrepareLocalizedModelsAsync(localizedModelConfiguration);
}
return(model);
}
/// <summary>
/// Prepare product attribute model
/// </summary>
/// <param name="model">Product attribute model</param>
/// <param name="productAttribute">Product attribute</param>
/// <param name="excludeProperties">Whether to exclude populating of some properties of model</param>
/// <returns>Product attribute model</returns>
public virtual async Task <ProductAttributeModel> PrepareProductAttributeModelAsync(ProductAttributeModel model,
ProductAttribute productAttribute, bool excludeProperties = false)
{
Action <ProductAttributeLocalizedModel, int> localizedModelConfiguration = null;
if (productAttribute != null)
{
//fill in model values from the entity
model ??= productAttribute.ToModel <ProductAttributeModel>();
//prepare nested search models
PreparePredefinedProductAttributeValueSearchModel(model.PredefinedProductAttributeValueSearchModel, productAttribute);
PrepareProductAttributeProductSearchModel(model.ProductAttributeProductSearchModel, productAttribute);
//define localized model configuration action
localizedModelConfiguration = async(locale, languageId) =>
{
locale.Name = await _localizationService.GetLocalizedAsync(productAttribute, entity => entity.Name, languageId, false, false);
locale.Description = await _localizationService.GetLocalizedAsync(productAttribute, entity => entity.Description, languageId, false, false);
};
}
//prepare localized models
if (!excludeProperties)
{
model.Locales = await _localizedModelFactory.PrepareLocalizedModelsAsync(localizedModelConfiguration);
}
return(model);
}
/// <summary>
/// Prepare return request reason model
/// </summary>
/// <param name="model">Return request reason model</param>
/// <param name="returnRequestReason">Return request reason</param>
/// <param name="excludeProperties">Whether to exclude populating of some properties of model</param>
/// <returns>Return request reason model</returns>
public virtual async Task <ReturnRequestReasonModel> PrepareReturnRequestReasonModelAsync(ReturnRequestReasonModel model,
ReturnRequestReason returnRequestReason, bool excludeProperties = false)
{
Action <ReturnRequestReasonLocalizedModel, int> localizedModelConfiguration = null;
if (returnRequestReason != null)
{
//fill in model values from the entity
model ??= returnRequestReason.ToModel <ReturnRequestReasonModel>();
//define localized model configuration action
localizedModelConfiguration = async(locale, languageId) =>
{
locale.Name = await _localizationService.GetLocalizedAsync(returnRequestReason, entity => entity.Name, languageId, false, false);
};
}
//prepare localized models
if (!excludeProperties)
{
model.Locales = await _localizedModelFactory.PrepareLocalizedModelsAsync(localizedModelConfiguration);
}
return(model);
}
/// <summary>
/// Prepare checkout attribute model
/// </summary>
/// <param name="model">Checkout attribute model</param>
/// <param name="checkoutAttribute">Checkout attribute</param>
/// <param name="excludeProperties">Whether to exclude populating of some properties of model</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the checkout attribute model
/// </returns>
public virtual async Task <CheckoutAttributeModel> PrepareCheckoutAttributeModelAsync(CheckoutAttributeModel model,
CheckoutAttribute checkoutAttribute, bool excludeProperties = false)
{
Func <CheckoutAttributeLocalizedModel, int, Task> localizedModelConfiguration = null;
if (checkoutAttribute != null)
{
//fill in model values from the entity
model ??= checkoutAttribute.ToModel <CheckoutAttributeModel>();
//prepare nested search model
PrepareCheckoutAttributeValueSearchModel(model.CheckoutAttributeValueSearchModel, checkoutAttribute);
//define localized model configuration action
localizedModelConfiguration = async(locale, languageId) =>
{
locale.Name = await _localizationService.GetLocalizedAsync(checkoutAttribute, entity => entity.Name, languageId, false, false);
locale.TextPrompt = await _localizationService.GetLocalizedAsync(checkoutAttribute, entity => entity.TextPrompt, languageId, false, false);
locale.DefaultValue = await _localizationService.GetLocalizedAsync(checkoutAttribute, entity => entity.DefaultValue, languageId, false, false);
};
//whether to fill in some of properties
if (!excludeProperties)
{
model.TaxCategoryId = checkoutAttribute.TaxCategoryId;
}
//prepare condition attributes model
await PrepareConditionAttributesModelAsync(model.ConditionModel, checkoutAttribute);
}
//currently any checkout attribute can have condition
model.ConditionAllowed = true;
//prepare localized models
if (!excludeProperties)
{
model.Locales = await _localizedModelFactory.PrepareLocalizedModelsAsync(localizedModelConfiguration);
}
//prepare available tax categories
await _baseAdminModelFactory.PrepareTaxCategoriesAsync(model.AvailableTaxCategories);
//prepare model stores
await _storeMappingSupportedModelFactory.PrepareModelStoresAsync(model, checkoutAttribute, excludeProperties);
return(model);
}
/// <summary>
/// Prepare store model
/// </summary>
/// <param name="model">Store model</param>
/// <param name="store">Store</param>
/// <param name="excludeProperties">Whether to exclude populating of some properties of model</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the store model
/// </returns>
public virtual async Task <StoreModel> PrepareStoreModelAsync(StoreModel model, Store store, bool excludeProperties = false)
{
Action <StoreLocalizedModel, int> localizedModelConfiguration = null;
if (store != null)
{
//fill in model values from the entity
model ??= store.ToModel <StoreModel>();
//define localized model configuration action
localizedModelConfiguration = async(locale, languageId) =>
{
locale.Name = await _localizationService.GetLocalizedAsync(store, entity => entity.Name, languageId, false, false);
};
}
//prepare available languages
await _baseAdminModelFactory.PrepareLanguagesAsync(model.AvailableLanguages,
defaultItemText : await _localizationService.GetResourceAsync("Admin.Common.EmptyItemText"));
//prepare localized models
if (!excludeProperties)
{
model.Locales = await _localizedModelFactory.PrepareLocalizedModelsAsync(localizedModelConfiguration);
}
return(model);
}
/// <summary>
/// Prepare review type model
/// </summary>
/// <param name="model">Review type model</param>
/// <param name="reviewType">Review type</param>
/// <param name="excludeProperties">Whether to exclude populating of some properties of model</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the review type model
/// </returns>
public virtual async Task <ReviewTypeModel> PrepareReviewTypeModelAsync(ReviewTypeModel model,
ReviewType reviewType, bool excludeProperties = false)
{
Func <ReviewTypeLocalizedModel, int, Task> localizedModelConfiguration = null;
if (reviewType != null)
{
//fill in model values from the entity
model ??= reviewType.ToModel <ReviewTypeModel>();
//define localized model configuration action
localizedModelConfiguration = async(locale, languageId) =>
{
locale.Name = await _localizationService.GetLocalizedAsync(reviewType, entity => entity.Name, languageId, false, false);
locale.Description = await _localizationService.GetLocalizedAsync(reviewType, entity => entity.Description, languageId, false, false);
};
}
//prepare localized models
if (!excludeProperties)
{
model.Locales = await _localizedModelFactory.PrepareLocalizedModelsAsync(localizedModelConfiguration);
}
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 async Task <TopicModel> PrepareTopicModelAsync(TopicModel model, Topic topic, bool excludeProperties = false)
{
Action <TopicLocalizedModel, int> localizedModelConfiguration = null;
if (topic != null)
{
//fill in model values from the entity
if (model == null)
{
model = topic.ToModel <TopicModel>();
model.SeName = await _urlRecordService.GetSeNameAsync(topic, 0, true, false);
}
model.Url = _urlHelperFactory.GetUrlHelper(_actionContextAccessor.ActionContext)
.RouteUrl("Topic", new { SeName = await _urlRecordService.GetSeNameAsync(topic) }, _webHelper.GetCurrentRequestProtocol());
//define localized model configuration action
localizedModelConfiguration = async(locale, languageId) =>
{
locale.Title = await _localizationService.GetLocalizedAsync(topic, entity => entity.Title, languageId, false, false);
locale.Body = await _localizationService.GetLocalizedAsync(topic, entity => entity.Body, languageId, false, false);
locale.MetaKeywords = await _localizationService.GetLocalizedAsync(topic, entity => entity.MetaKeywords, languageId, false, false);
locale.MetaDescription = await _localizationService.GetLocalizedAsync(topic, entity => entity.MetaDescription, languageId, false, false);
locale.MetaTitle = await _localizationService.GetLocalizedAsync(topic, entity => entity.MetaTitle, languageId, false, false);
locale.SeName = await _urlRecordService.GetSeNameAsync(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 = await _localizedModelFactory.PrepareLocalizedModelsAsync(localizedModelConfiguration);
}
//prepare available topic templates
await _baseAdminModelFactory.PrepareTopicTemplatesAsync(model.AvailableTopicTemplates, false);
//prepare model customer roles
await _aclSupportedModelFactory.PrepareModelCustomerRolesAsync(model, topic, excludeProperties);
//prepare model stores
await _storeMappingSupportedModelFactory.PrepareModelStoresAsync(model, topic, excludeProperties);
return(model);
}
/// <summary>
/// Prepare message template model
/// </summary>
/// <param name="model">Message template model</param>
/// <param name="messageTemplate">Message template</param>
/// <param name="excludeProperties">Whether to exclude populating of some properties of model</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the message template model
/// </returns>
public virtual async Task <MessageTemplateModel> PrepareMessageTemplateModelAsync(MessageTemplateModel model,
MessageTemplate messageTemplate, bool excludeProperties = false)
{
Action <MessageTemplateLocalizedModel, int> localizedModelConfiguration = null;
if (messageTemplate != null)
{
//fill in model values from the entity
model ??= messageTemplate.ToModel <MessageTemplateModel>();
//define localized model configuration action
localizedModelConfiguration = async(locale, languageId) =>
{
locale.BccEmailAddresses = await _localizationService.GetLocalizedAsync(messageTemplate, entity => entity.BccEmailAddresses, languageId, false, false);
locale.Subject = await _localizationService.GetLocalizedAsync(messageTemplate, entity => entity.Subject, languageId, false, false);
locale.Body = await _localizationService.GetLocalizedAsync(messageTemplate, entity => entity.Body, languageId, false, false);
locale.EmailAccountId = await _localizationService.GetLocalizedAsync(messageTemplate, entity => entity.EmailAccountId, languageId, false, false);
//prepare available email accounts
await _baseAdminModelFactory.PrepareEmailAccountsAsync(locale.AvailableEmailAccounts,
defaultItemText : await _localizationService.GetResourceAsync("Admin.ContentManagement.MessageTemplates.Fields.EmailAccount.Standard"));
//PrepareEmailAccounts only gets available accounts, we need to set the item as selected manually
if (locale.AvailableEmailAccounts?.FirstOrDefault(x => x.Value == locale.EmailAccountId.ToString()) is SelectListItem emailAccountListItem)
{
emailAccountListItem.Selected = true;
}
};
}
model.SendImmediately = !model.DelayBeforeSend.HasValue;
model.HasAttachedDownload = model.AttachedDownloadId > 0;
var allowedTokens = string.Join(", ", await _messageTokenProvider.GetListOfAllowedTokensAsync(_messageTokenProvider.GetTokenGroups(messageTemplate)));
model.AllowedTokens = $"{allowedTokens}{Environment.NewLine}{Environment.NewLine}" +
$"{await _localizationService.GetResourceAsync("Admin.ContentManagement.MessageTemplates.Tokens.ConditionalStatement")}{Environment.NewLine}";
//prepare localized models
if (!excludeProperties)
{
model.Locales = await _localizedModelFactory.PrepareLocalizedModelsAsync(localizedModelConfiguration);
}
//prepare available email accounts
await _baseAdminModelFactory.PrepareEmailAccountsAsync(model.AvailableEmailAccounts);
//prepare available stores
await _storeMappingSupportedModelFactory.PrepareModelStoresAsync(model, messageTemplate, excludeProperties);
return(model);
}
/// <summary>
/// Prepare country model
/// </summary>
/// <param name="model">Country model</param>
/// <param name="country">Country</param>
/// <param name="excludeProperties">Whether to exclude populating of some properties of model</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the country model
/// </returns>
public virtual async Task <CountryModel> PrepareCountryModelAsync(CountryModel model, Country country, bool excludeProperties = false)
{
Func <CountryLocalizedModel, int, Task> localizedModelConfiguration = null;
if (country != null)
{
//fill in model values from the entity
if (model == null)
{
model = country.ToModel <CountryModel>();
model.NumberOfStates = (await _stateProvinceService.GetStateProvincesByCountryIdAsync(country.Id))?.Count ?? 0;
}
//prepare nested search model
PrepareStateProvinceSearchModel(model.StateProvinceSearchModel, country);
//define localized model configuration action
localizedModelConfiguration = async(locale, languageId) =>
{
locale.Name = await _localizationService.GetLocalizedAsync(country, entity => entity.Name, languageId, false, false);
};
}
//set default values for the new model
if (country == null)
{
model.Published = true;
model.AllowsBilling = true;
model.AllowsShipping = true;
}
//prepare localized models
if (!excludeProperties)
{
model.Locales = await _localizedModelFactory.PrepareLocalizedModelsAsync(localizedModelConfiguration);
}
//prepare available stores
await _storeMappingSupportedModelFactory.PrepareModelStoresAsync(model, country, 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>
/// A task that represents the asynchronous operation
/// The task result contains the plugin model
/// </returns>
public virtual async Task <PluginModel> PreparePluginModelAsync(PluginModel model, PluginDescriptor pluginDescriptor, bool excludeProperties = false)
{
Func <PluginLocalizedModel, int, Task> localizedModelConfiguration = null;
if (pluginDescriptor != null)
{
//fill in model values from the entity
model ??= pluginDescriptor.ToPluginModel(model);
model.LogoUrl = await _pluginService.GetPluginLogoUrlAsync(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 = async(locale, languageId) =>
{
locale.FriendlyName = await _localizationService.GetLocalizedFriendlyNameAsync(plugin, languageId, false);
};
}
//prepare localized models
if (!excludeProperties)
{
model.Locales = await _localizedModelFactory.PrepareLocalizedModelsAsync(localizedModelConfiguration);
}
//prepare model customer roles
await _aclSupportedModelFactory.PrepareModelCustomerRolesAsync(model);
//prepare available stores
await _storeMappingSupportedModelFactory.PrepareModelStoresAsync(model);
return(model);
}
/// <summary>
/// Prepare currency model
/// </summary>
/// <param name="model">Currency model</param>
/// <param name="currency">Currency</param>
/// <param name="excludeProperties">Whether to exclude populating of some properties of model</param>
/// <returns>Currency model</returns>
public virtual async Task <CurrencyModel> PrepareCurrencyModelAsync(CurrencyModel model, Currency currency, bool excludeProperties = false)
{
Action <CurrencyLocalizedModel, int> localizedModelConfiguration = null;
if (currency != null)
{
//fill in model values from the entity
model ??= currency.ToModel <CurrencyModel>();
//convert dates to the user time
model.CreatedOn = await _dateTimeHelper.ConvertToUserTimeAsync(currency.CreatedOnUtc, DateTimeKind.Utc);
//define localized model configuration action
localizedModelConfiguration = async(locale, languageId) =>
{
locale.Name = await _localizationService.GetLocalizedAsync(currency, entity => entity.Name, languageId, false, false);
};
}
//set default values for the new model
if (currency == null)
{
model.Published = true;
model.Rate = 1;
}
//prepare localized models
if (!excludeProperties)
{
model.Locales = await _localizedModelFactory.PrepareLocalizedModelsAsync(localizedModelConfiguration);
}
//prepare available stores
await _storeMappingSupportedModelFactory.PrepareModelStoresAsync(model, currency, excludeProperties);
return(model);
}
public virtual async Task <CompanyModel> PrepareCompanyModelAsync(CompanyModel model, Company company, bool excludeProperties = false)
{
Action <CompanyLocalizedModel, int> localizedModelConfiguration = null;
if (company != null)
{
//fill in model values from the entity
if (model == null)
{
model = company.ToModel <CompanyModel>();
}
//prepare nested search model
PrepareCompanyCustomerSearchModel(model.CompanyCustomerSearchModel, company);
//define localized model configuration action
localizedModelConfiguration = async(locale, languageId) =>
{
locale.Name = await _localizationService.GetLocalizedAsync(company, entity => entity.Name, languageId, false, false);
};
var companyCustomers = await _companyService.GetCompanyCustomersByCompanyIdAsync(company.Id);
if (companyCustomers.Any())
{
model.CustomerExist = true;
}
}
//prepare localized models
if (!excludeProperties)
{
model.Locales = await _localizedModelFactory.PrepareLocalizedModelsAsync(localizedModelConfiguration);
}
return(model);
}
/// <summary>
/// Prepare vendor model
/// </summary>
/// <param name="model">Vendor model</param>
/// <param name="vendor">Vendor</param>
/// <param name="excludeProperties">Whether to exclude populating of some properties of model</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the vendor model
/// </returns>
public virtual async Task <VendorModel> PrepareVendorModelAsync(VendorModel model, Vendor vendor, bool excludeProperties = false)
{
Action <VendorLocalizedModel, int> localizedModelConfiguration = null;
if (vendor != null)
{
//fill in model values from the entity
if (model == null)
{
model = vendor.ToModel <VendorModel>();
model.SeName = await _urlRecordService.GetSeNameAsync(vendor, 0, true, false);
}
//define localized model configuration action
localizedModelConfiguration = async(locale, languageId) =>
{
locale.Name = await _localizationService.GetLocalizedAsync(vendor, entity => entity.Name, languageId, false, false);
locale.Description = await _localizationService.GetLocalizedAsync(vendor, entity => entity.Description, languageId, false, false);
locale.MetaKeywords = await _localizationService.GetLocalizedAsync(vendor, entity => entity.MetaKeywords, languageId, false, false);
locale.MetaDescription = await _localizationService.GetLocalizedAsync(vendor, entity => entity.MetaDescription, languageId, false, false);
locale.MetaTitle = await _localizationService.GetLocalizedAsync(vendor, entity => entity.MetaTitle, languageId, false, false);
locale.SeName = await _urlRecordService.GetSeNameAsync(vendor, languageId, false, false);
};
//prepare associated customers
await PrepareAssociatedCustomerModelsAsync(model.AssociatedCustomers, vendor);
//prepare nested search models
PrepareVendorNoteSearchModel(model.VendorNoteSearchModel, vendor);
}
//set default values for the new model
if (vendor == null)
{
model.PageSize = 6;
model.Active = true;
model.AllowCustomersToSelectPageSize = true;
model.PageSizeOptions = _vendorSettings.DefaultVendorPageSizeOptions;
model.PriceRangeFiltering = true;
model.ManuallyPriceRange = true;
model.PriceFrom = NopCatalogDefaults.DefaultPriceRangeFrom;
model.PriceTo = NopCatalogDefaults.DefaultPriceRangeTo;
}
model.PrimaryStoreCurrencyCode = (await _currencyService.GetCurrencyByIdAsync(_currencySettings.PrimaryStoreCurrencyId)).CurrencyCode;
//prepare localized models
if (!excludeProperties)
{
model.Locales = await _localizedModelFactory.PrepareLocalizedModelsAsync(localizedModelConfiguration);
}
//prepare model vendor attributes
await PrepareVendorAttributeModelsAsync(model.VendorAttributes, vendor);
//prepare address model
var address = await _addressService.GetAddressByIdAsync(vendor?.AddressId ?? 0);
if (!excludeProperties && address != null)
{
model.Address = address.ToModel(model.Address);
}
await _addressModelFactory.PrepareAddressModelAsync(model.Address, address);
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 async Task <ManufacturerModel> PrepareManufacturerModelAsync(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 = await _urlRecordService.GetSeNameAsync(manufacturer, 0, true, false);
}
//prepare nested search model
PrepareManufacturerProductSearchModel(model.ManufacturerProductSearchModel, manufacturer);
//define localized model configuration action
localizedModelConfiguration = async(locale, languageId) =>
{
locale.Name = await _localizationService.GetLocalizedAsync(manufacturer, entity => entity.Name, languageId, false, false);
locale.Description = await _localizationService.GetLocalizedAsync(manufacturer, entity => entity.Description, languageId, false, false);
locale.MetaKeywords = await _localizationService.GetLocalizedAsync(manufacturer, entity => entity.MetaKeywords, languageId, false, false);
locale.MetaDescription = await _localizationService.GetLocalizedAsync(manufacturer, entity => entity.MetaDescription, languageId, false, false);
locale.MetaTitle = await _localizationService.GetLocalizedAsync(manufacturer, entity => entity.MetaTitle, languageId, false, false);
locale.SeName = await _urlRecordService.GetSeNameAsync(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 = await _localizedModelFactory.PrepareLocalizedModelsAsync(localizedModelConfiguration);
}
//prepare available manufacturer templates
await _baseAdminModelFactory.PrepareManufacturerTemplatesAsync(model.AvailableManufacturerTemplates, false);
//prepare model discounts
var availableDiscounts = await _discountService.GetAllDiscountsAsync(DiscountType.AssignedToManufacturers, showHidden : true);
await _discountSupportedModelFactory.PrepareModelDiscountsAsync(model, manufacturer, availableDiscounts, excludeProperties);
//prepare model customer roles
await _aclSupportedModelFactory.PrepareModelCustomerRolesAsync(model, manufacturer, excludeProperties);
//prepare model stores
await _storeMappingSupportedModelFactory.PrepareModelStoresAsync(model, manufacturer, excludeProperties);
return(model);
}
/// <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>
/// A task that represents the asynchronous operation
/// The task result contains the category model
/// </returns>
public virtual async Task <CategoryModel> PrepareCategoryModelAsync(CategoryModel model, Category category, bool excludeProperties = false)
{
Func <CategoryLocalizedModel, int, Task> localizedModelConfiguration = null;
if (category != null)
{
//fill in model values from the entity
if (model == null)
{
model = category.ToModel <CategoryModel>();
model.SeName = await _urlRecordService.GetSeNameAsync(category, 0, true, false);
}
//prepare nested search model
PrepareCategoryProductSearchModel(model.CategoryProductSearchModel, category);
//define localized model configuration action
localizedModelConfiguration = async(locale, languageId) =>
{
locale.Name = await _localizationService.GetLocalizedAsync(category, entity => entity.Name, languageId, false, false);
locale.Description = await _localizationService.GetLocalizedAsync(category, entity => entity.Description, languageId, false, false);
locale.MetaKeywords = await _localizationService.GetLocalizedAsync(category, entity => entity.MetaKeywords, languageId, false, false);
locale.MetaDescription = await _localizationService.GetLocalizedAsync(category, entity => entity.MetaDescription, languageId, false, false);
locale.MetaTitle = await _localizationService.GetLocalizedAsync(category, entity => entity.MetaTitle, languageId, false, false);
locale.SeName = await _urlRecordService.GetSeNameAsync(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;
model.PriceRangeFiltering = true;
model.ManuallyPriceRange = true;
model.PriceFrom = NopCatalogDefaults.DefaultPriceRangeFrom;
model.PriceTo = NopCatalogDefaults.DefaultPriceRangeTo;
}
model.PrimaryStoreCurrencyCode = (await _currencyService.GetCurrencyByIdAsync(_currencySettings.PrimaryStoreCurrencyId)).CurrencyCode;
//prepare localized models
if (!excludeProperties)
{
model.Locales = await _localizedModelFactory.PrepareLocalizedModelsAsync(localizedModelConfiguration);
}
//prepare available category templates
await _baseAdminModelFactory.PrepareCategoryTemplatesAsync(model.AvailableCategoryTemplates, false);
//prepare available parent categories
await _baseAdminModelFactory.PrepareCategoriesAsync(model.AvailableCategories,
defaultItemText : await _localizationService.GetResourceAsync("Admin.Catalog.Categories.Fields.Parent.None"));
//prepare model discounts
var availableDiscounts = await _discountService.GetAllDiscountsAsync(DiscountType.AssignedToCategories, showHidden : true);
await _discountSupportedModelFactory.PrepareModelDiscountsAsync(model, category, availableDiscounts, excludeProperties);
//prepare model customer roles
await _aclSupportedModelFactory.PrepareModelCustomerRolesAsync(model, category, excludeProperties);
//prepare model stores
await _storeMappingSupportedModelFactory.PrepareModelStoresAsync(model, category, excludeProperties);
return(model);
}