/// <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); }