public virtual async Task <SwiperSliderModel> PrepareSliderModelAsync(SwiperSliderModel model, Slider slider)
{
if (slider != null)
{
if (model == null)
{
model = slider.ToModel <SwiperSliderModel>();
}
await PrepareSliderItemSearchModelAsync(model.SwiperSliderItemSearchModel, slider);
}
if (slider == null)
{
model.Published = true;
}
//prepare model customer roles
await _aclSupportedModelFactory.PrepareModelCustomerRolesAsync(model, slider, false);
//prepare model stores
await _storeMappingSupportedModelFactory.PrepareModelStoresAsync(model, slider, false);
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 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 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);
}
public async Task <IActionResult> Configure(string testTaxResult = null)
{
if (!await _permissionService.AuthorizeAsync(StandardPermissionProvider.ManageTaxSettings))
{
return(AccessDeniedView());
}
var customer = await _workContext.GetCurrentCustomerAsync();
var model = new ConfigurationModel
{
AccountId = _avalaraTaxSettings.AccountId,
LicenseKey = _avalaraTaxSettings.LicenseKey,
CompanyCode = _avalaraTaxSettings.CompanyCode,
UseSandbox = _avalaraTaxSettings.UseSandbox,
CommitTransactions = _avalaraTaxSettings.CommitTransactions,
ValidateAddress = _avalaraTaxSettings.ValidateAddress,
TaxOriginAddressTypeId = (int)_avalaraTaxSettings.TaxOriginAddressType,
EnableLogging = _avalaraTaxSettings.EnableLogging,
GetTaxRateByAddressOnly = _avalaraTaxSettings.GetTaxRateByAddressOnly,
EnableCertificates = _avalaraTaxSettings.EnableCertificates,
AutoValidateCertificate = _avalaraTaxSettings.AutoValidateCertificate,
AllowEditCustomer = _avalaraTaxSettings.AllowEditCustomer,
DisplayNoValidCertificatesMessage = _avalaraTaxSettings.DisplayNoValidCertificatesMessage,
SelectedCustomerRoleIds = _avalaraTaxSettings.CustomerRoleIds,
TestTaxResult = testTaxResult
};
model.IsConfigured = !string.IsNullOrEmpty(_avalaraTaxSettings.AccountId) && !string.IsNullOrEmpty(_avalaraTaxSettings.LicenseKey);
model.TaxOriginAddressTypes = (await TaxOriginAddressType.DefaultTaxAddress.ToSelectListAsync(false))
.Select(type => new SelectListItem(type.Text, type.Value)).ToList();
model.HideGeneralBlock = await _genericAttributeService.GetAttributeAsync <bool>(customer, AvalaraTaxDefaults.HideGeneralBlock);
model.HideLogBlock = await _genericAttributeService.GetAttributeAsync <bool>(customer, AvalaraTaxDefaults.HideLogBlock);
//prepare model customer roles
await _aclSupportedModelFactory.PrepareModelCustomerRolesAsync(model);
//prepare address model
await _baseAdminModelFactory.PrepareCountriesAsync(model.TestAddress.AvailableCountries);
await _baseAdminModelFactory.PrepareStatesAndProvincesAsync(model.TestAddress.AvailableStates, model.TestAddress.CountryId);
//prepare tax transaction log model
model.TaxTransactionLogSearchModel.SetGridPageSize();
//get active account companies
var activeCompanies = model.IsConfigured ? await _avalaraTaxManager.GetAccountCompaniesAsync() : null;
if (activeCompanies?.Any() ?? false)
{
model.Companies = activeCompanies.OrderBy(company => company.isDefault ?? false ? 0 : 1).Select(company => new SelectListItem
{
Text = company.isTest ?? false ? $"{company.name} (Test)" : company.name,
Value = company.companyCode
}).ToList();
}
var defaultCompanyCode = _avalaraTaxSettings.CompanyCode;
if (!model.Companies.Any())
{
//add the special item for 'there are no companies' with empty guid value
var noCompaniesText = await _localizationService.GetResourceAsync("Plugins.Tax.Avalara.Fields.Company.NotExist");
model.Companies.Add(new SelectListItem {
Text = noCompaniesText, Value = Guid.Empty.ToString()
});
defaultCompanyCode = Guid.Empty.ToString();
}
else if (string.IsNullOrEmpty(_avalaraTaxSettings.CompanyCode) || _avalaraTaxSettings.CompanyCode.Equals(Guid.Empty.ToString()))
{
defaultCompanyCode = model.Companies.FirstOrDefault()?.Value;
}
//set the default company
var selectedCompany = activeCompanies?.FirstOrDefault(company => company.companyCode.Equals(defaultCompanyCode));
model.CompanyCode = defaultCompanyCode;
_avalaraTaxSettings.CompanyCode = defaultCompanyCode;
_avalaraTaxSettings.CompanyId = selectedCompany?.id;
await _settingService.SaveSettingAsync(_avalaraTaxSettings);
//display warning in case of company currency differ from the primary store currency
var primaryCurrency = await _currencyService.GetCurrencyByIdAsync(_currencySettings.PrimaryStoreCurrencyId);
if (!selectedCompany?.baseCurrencyCode?.Equals(primaryCurrency?.CurrencyCode, StringComparison.InvariantCultureIgnoreCase) ?? false)
{
var warning = string.Format(await _localizationService.GetResourceAsync("Plugins.Tax.Avalara.Fields.Company.Currency.Warning"),
selectedCompany.name, selectedCompany.baseCurrencyCode, primaryCurrency?.CurrencyCode);
_notificationService.WarningNotification(warning);
}
return(View("~/Plugins/Tax.Avalara/Views/Configuration/Configure.cshtml", model));
}
