private TemplateInfo LocalizeTemplate(ITemplateInfo template, ILocalizationLocator localizationInfo) { TemplateInfo localizedTemplate = new TemplateInfo { GeneratorId = template.GeneratorId, ConfigPlace = template.ConfigPlace, ConfigMountPointId = template.ConfigMountPointId, Name = localizationInfo?.Name ?? template.Name, Tags = LocalizeCacheTags(template, localizationInfo), CacheParameters = LocalizeCacheParameters(template, localizationInfo), ShortName = template.ShortName, Classifications = template.Classifications, Author = localizationInfo?.Author ?? template.Author, Description = localizationInfo?.Description ?? template.Description, GroupIdentity = template.GroupIdentity ?? string.Empty, Precedence = template.Precedence, Identity = template.Identity, DefaultName = template.DefaultName, LocaleConfigPlace = localizationInfo?.ConfigPlace ?? null, LocaleConfigMountPointId = localizationInfo?.MountPointId ?? Guid.Empty, HostConfigMountPointId = template.HostConfigMountPointId, HostConfigPlace = template.HostConfigPlace, ThirdPartyNotices = template.ThirdPartyNotices, BaselineInfo = template.BaselineInfo, HasScriptRunningPostActions = template.HasScriptRunningPostActions }; if (template is IShortNameList templateWithShortNameList) { localizedTemplate.ShortNameList = templateWithShortNameList.ShortNameList; } return(localizedTemplate); }
private TemplateInfo LocalizeTemplate(ITemplateInfo template, ILocalizationLocator localizationInfo) { TemplateInfo localizedTemplate = new TemplateInfo { GeneratorId = template.GeneratorId, ConfigPlace = template.ConfigPlace, ConfigMountPointId = template.ConfigMountPointId, Name = localizationInfo?.Name ?? template.Name, Tags = LocalizeCacheTags(template, localizationInfo), CacheParameters = LocalizeCacheParameters(template, localizationInfo), ShortName = template.ShortName, Classifications = template.Classifications, Author = localizationInfo?.Author ?? template.Author, Description = localizationInfo?.Description ?? template.Description, GroupIdentity = template.GroupIdentity ?? string.Empty, Precedence = template.Precedence, Identity = template.Identity, DefaultName = template.DefaultName, LocaleConfigPlace = localizationInfo?.ConfigPlace ?? null, LocaleConfigMountPointId = localizationInfo?.MountPointId ?? Guid.Empty, HostConfigMountPointId = template.HostConfigMountPointId, HostConfigPlace = template.HostConfigPlace }; return(localizedTemplate); }
private void AddLocalizationToMemoryCache(ILocalizationLocator locator) { if (!_localizationMemoryCache.TryGetValue(locator.Locale, out IDictionary <string, ILocalizationLocator> localeLocators)) { localeLocators = new Dictionary <string, ILocalizationLocator>(); _localizationMemoryCache.Add(locator.Locale, localeLocators); } localeLocators[locator.Identity] = locator; }
private void AddLocalizationToMemoryCache(ILocalizationLocator locator) { if (!_localizationMemoryCache.TryGetValue(locator.Locale, out IDictionary <string, ILocalizationLocator> value)) { value = new Dictionary <string, ILocalizationLocator>(); _localizationMemoryCache.Add(locator.Locale, value); } value[locator.Identity] = locator; }
private void WriteTemplateCacheForLocale(string locale, string existingCacheVersion) { IReadOnlyList <TemplateInfo> existingTemplatesForLocale = GetTemplatesForLocale(locale, existingCacheVersion); IDictionary <string, ILocalizationLocator> existingLocatorsForLocale; bool hasContentChanges = false; if (existingTemplatesForLocale.Count == 0) { // the cache for this locale didn't exist previously. Start with the neutral locale as if it were the existing (no locales) existingTemplatesForLocale = GetTemplatesForLocale(null, existingCacheVersion); existingLocatorsForLocale = new Dictionary <string, ILocalizationLocator>(); hasContentChanges = true; } else { existingLocatorsForLocale = GetLocalizationsFromTemplates(existingTemplatesForLocale, locale); } HashSet <string> foundTemplates = new HashSet <string>(); List <ITemplateInfo> mergedTemplateList = new List <ITemplateInfo>(); // These are from langpacks being installed... identity -> locator if (string.IsNullOrEmpty(locale) || !_localizationMemoryCache.TryGetValue(locale, out IDictionary <string, ILocalizationLocator> newLocatorsForLocale)) { newLocatorsForLocale = new Dictionary <string, ILocalizationLocator>(); } else { hasContentChanges = true; // there are new langpacks for this locale } foreach (ITemplate newTemplate in _templateMemoryCache.Values) { ILocalizationLocator locatorForTemplate = GetPreferredLocatorForTemplate(newTemplate.Identity, existingLocatorsForLocale, newLocatorsForLocale); TemplateInfo localizedTemplate = LocalizeTemplate(newTemplate, locatorForTemplate); mergedTemplateList.Add(localizedTemplate); foundTemplates.Add(newTemplate.Identity); hasContentChanges = true; // new template } foreach (TemplateInfo existingTemplate in existingTemplatesForLocale) { if (!foundTemplates.Contains(existingTemplate.Identity)) { ILocalizationLocator locatorForTemplate = GetPreferredLocatorForTemplate(existingTemplate.Identity, existingLocatorsForLocale, newLocatorsForLocale); TemplateInfo localizedTemplate = LocalizeTemplate(existingTemplate, locatorForTemplate); mergedTemplateList.Add(localizedTemplate); foundTemplates.Add(existingTemplate.Identity); } } _environmentSettings.SettingsLoader.WriteTemplateCache(mergedTemplateList, locale, hasContentChanges); }
private void WriteTemplateCacheForLocale(string locale, string existingCacheVersion) { IReadOnlyList <TemplateInfo> templatesForLocale = GetTemplatesForLocale(locale, existingCacheVersion); bool hasContentChanges = false; IDictionary <string, ILocalizationLocator> existingLocatorsForLocale; if (templatesForLocale.Count == 0) { templatesForLocale = GetTemplatesForLocale(null, existingCacheVersion); existingLocatorsForLocale = new Dictionary <string, ILocalizationLocator>(); hasContentChanges = true; } else { existingLocatorsForLocale = GetLocalizationsFromTemplates(templatesForLocale, locale); } HashSet <string> hashSet = new HashSet <string>(); List <ITemplateInfo> list = new List <ITemplateInfo>(); if (string.IsNullOrEmpty(locale) || !_localizationMemoryCache.TryGetValue(locale, out IDictionary <string, ILocalizationLocator> value)) { value = new Dictionary <string, ILocalizationLocator>(); } else { hasContentChanges = true; } foreach (ITemplate value2 in _templateMemoryCache.Values) { ILocalizationLocator preferredLocatorForTemplate = GetPreferredLocatorForTemplate(value2.Identity, existingLocatorsForLocale, value); TemplateInfo item = LocalizeTemplate(value2, preferredLocatorForTemplate); list.Add(item); hashSet.Add(value2.Identity); hasContentChanges = true; } foreach (TemplateInfo item3 in templatesForLocale) { if (!hashSet.Contains(item3.Identity)) { ILocalizationLocator preferredLocatorForTemplate2 = GetPreferredLocatorForTemplate(item3.Identity, existingLocatorsForLocale, value); TemplateInfo item2 = LocalizeTemplate(item3, preferredLocatorForTemplate2); list.Add(item2); hashSet.Add(item3.Identity); } } _environmentSettings.SettingsLoader.WriteTemplateCache(list, locale, hasContentChanges); }
private static void UpdateTemplateLocalization(TemplateInfo template, IDictionary <string, ILocalizationLocator> locatorsForLocale) { ILocalizationLocator localizationInfo = null; if (locatorsForLocale == null || !locatorsForLocale.TryGetValue(template.Identity, out localizationInfo)) { return; } template.LocaleConfigPlace = localizationInfo.ConfigPlace ?? null; template.LocaleConfigMountPointId = localizationInfo.MountPointId; }
public void PicksCorrectLocator(string currentCulture, string?expectedLocator) { CultureInfo persistedCulture = CultureInfo.CurrentUICulture; try { if (currentCulture != "invariant") { CultureInfo.CurrentUICulture = new CultureInfo(currentCulture); } else { currentCulture = ""; CultureInfo.CurrentUICulture = CultureInfo.InvariantCulture; } string[] availableLocales = new[] { "cs", "de", "en", "es", "fr", "it", "ja", "ko", "pl", "pt-BR", "ru", "tr", "zh-Hans", "zh-Hant" }; ITemplate template = A.Fake <ITemplate>(); A.CallTo(() => template.Identity).Returns("testIdentity"); List <ILocalizationLocator> locators = new List <ILocalizationLocator>(); foreach (string locale in availableLocales) { ILocalizationLocator locator = A.Fake <ILocalizationLocator>(); A.CallTo(() => locator.Identity).Returns("testIdentity"); A.CallTo(() => locator.Locale).Returns(locale); A.CallTo(() => locator.Name).Returns(locale + " name"); locators.Add(locator); } IMountPoint mountPoint = A.Fake <IMountPoint>(); A.CallTo(() => mountPoint.MountPointUri).Returns("testMount"); ScanResult result = new ScanResult(mountPoint, new[] { template }, locators, Array.Empty <(string AssemblyPath, Type InterfaceType, IIdentifiedComponent Instance)>()); TemplateCache templateCache = new TemplateCache(new[] { result }, new Dictionary <string, DateTime>(), NullLogger.Instance); Assert.Equal(currentCulture, templateCache.Locale); Assert.Equal("testIdentity", templateCache.TemplateInfo.Single().Identity); Assert.Equal(string.IsNullOrEmpty(expectedLocator) ? "" : expectedLocator + " name", templateCache.TemplateInfo.Single().Name); } finally { CultureInfo.CurrentUICulture = persistedCulture; } }
// returns TemplateInfo for all the known templates. // if the locale is matches localization for the template, the loc info is included. private static IList <TemplateInfo> NewTemplateInfoForLocale(string locale) { IList <TemplateInfo> templatesForLocale = new List <TemplateInfo>(); IDictionary <string, ILocalizationLocator> locatorsForLocale; if (string.IsNullOrEmpty(locale) || !_localizationMemoryCache.TryGetValue(locale, out locatorsForLocale)) { locatorsForLocale = null; } foreach (ITemplate template in _templateMemoryCache.Values) { ILocalizationLocator localizationInfo = null; if (locatorsForLocale != null) { locatorsForLocale.TryGetValue(template.Identity, out localizationInfo); } TemplateInfo localizedTemplate = new TemplateInfo { GeneratorId = template.Generator.Id, ConfigPlace = template.Configuration.FullPath, ConfigMountPointId = template.Configuration.MountPoint.Info.MountPointId, Name = template.Name, Tags = template.Tags, ShortName = template.ShortName, Classifications = template.Classifications, Author = template.Author, GroupIdentity = template.GroupIdentity, Identity = template.Identity, DefaultName = template.DefaultName, LocaleConfigPlace = localizationInfo?.ConfigPlace ?? null, LocaleConfigMountPointId = localizationInfo?.MountPointId ?? Guid.Empty }; templatesForLocale.Add(localizedTemplate); } return(templatesForLocale); }
private TemplateInfo LocalizeTemplate(ITemplateInfo template, ILocalizationLocator localizationInfo) { TemplateInfo localizedTemplate = new TemplateInfo { GeneratorId = template.GeneratorId, ConfigPlace = template.ConfigPlace, ConfigMountPointId = template.ConfigMountPointId, Name = localizationInfo?.Name ?? template.Name, Tags = template.Tags, ShortName = template.ShortName, Classifications = template.Classifications, Author = localizationInfo?.Author ?? template.Author, Description = localizationInfo?.Description ?? template.Description, GroupIdentity = template.GroupIdentity, Identity = template.Identity, DefaultName = template.DefaultName, LocaleConfigPlace = localizationInfo?.ConfigPlace ?? null, LocaleConfigMountPointId = localizationInfo?.MountPointId ?? Guid.Empty }; return(localizedTemplate); }
private IReadOnlyDictionary <string, ICacheParameter> LocalizeCacheParameters(ITemplateInfo template, ILocalizationLocator localizationInfo) { if (localizationInfo == null || localizationInfo.ParameterSymbols == null) { return(template.CacheParameters); } IReadOnlyDictionary <string, ICacheParameter> templateCacheParameters = template.CacheParameters; IReadOnlyDictionary <string, IParameterSymbolLocalizationModel> localizedParameterSymbols = localizationInfo.ParameterSymbols; Dictionary <string, ICacheParameter> localizedCacheParams = new Dictionary <string, ICacheParameter>(); foreach (KeyValuePair <string, ICacheParameter> templateParam in templateCacheParameters) { if (localizedParameterSymbols.TryGetValue(templateParam.Key, out IParameterSymbolLocalizationModel localizationForParam)) { // there is loc info for this symbol ICacheParameter localizedParam = new CacheParameter { DataType = templateParam.Value.DataType, DefaultValue = templateParam.Value.DefaultValue, Description = localizationForParam.Description ?? templateParam.Value.Description }; localizedCacheParams.Add(templateParam.Key, localizedParam); } else { localizedCacheParams.Add(templateParam.Key, templateParam.Value); } } return(localizedCacheParams); }
private IReadOnlyDictionary <string, ICacheTag> LocalizeCacheTags(ITemplateInfo template, ILocalizationLocator localizationInfo) { if (localizationInfo == null || localizationInfo.ParameterSymbols == null) { return(template.Tags); } IReadOnlyDictionary <string, ICacheTag> templateTags = template.Tags; IReadOnlyDictionary <string, IParameterSymbolLocalizationModel> localizedParameterSymbols = localizationInfo.ParameterSymbols; Dictionary <string, ICacheTag> localizedCacheTags = new Dictionary <string, ICacheTag>(); foreach (KeyValuePair <string, ICacheTag> templateTag in templateTags) { if (localizedParameterSymbols.TryGetValue(templateTag.Key, out IParameterSymbolLocalizationModel localizationForTag)) { // there is loc for this symbol Dictionary <string, string> localizedChoicesAndDescriptions = new Dictionary <string, string>(); foreach (KeyValuePair <string, string> templateChoice in templateTag.Value.ChoicesAndDescriptions) { if (localizationForTag.ChoicesAndDescriptions.TryGetValue(templateChoice.Key, out string localizedDesc) && !string.IsNullOrWhiteSpace(localizedDesc)) { localizedChoicesAndDescriptions.Add(templateChoice.Key, localizedDesc); } else { localizedChoicesAndDescriptions.Add(templateChoice.Key, templateChoice.Value); } } string tagDescription = localizationForTag.Description ?? templateTag.Value.Description; ICacheTag localizedTag = new CacheTag(tagDescription, localizedChoicesAndDescriptions, templateTag.Value.DefaultValue); localizedCacheTags.Add(templateTag.Key, localizedTag); } else { localizedCacheTags.Add(templateTag.Key, templateTag.Value); } } return(localizedCacheTags); }
private IReadOnlyDictionary <string, ICacheTag> LocalizeCacheTags(ITemplateInfo template, ILocalizationLocator localizationInfo) { if (localizationInfo == null || localizationInfo.ParameterSymbols == null) { return(template.Tags); } IReadOnlyDictionary <string, ICacheTag> templateTags = template.Tags; IReadOnlyDictionary <string, IParameterSymbolLocalizationModel> localizedParameterSymbols = localizationInfo.ParameterSymbols; Dictionary <string, ICacheTag> localizedCacheTags = new Dictionary <string, ICacheTag>(); foreach (KeyValuePair <string, ICacheTag> templateTag in templateTags) { if (!localizedParameterSymbols.TryGetValue(templateTag.Key, out IParameterSymbolLocalizationModel localizationForTag)) { // There is no localization for this symbol. Use the symbol as is. localizedCacheTags.Add(templateTag.Key, templateTag.Value); continue; } // There is localization. Create a localized instance, starting with the choices. var localizedChoices = new Dictionary <string, ParameterChoice>(); foreach (KeyValuePair <string, ParameterChoice> templateChoice in templateTag.Value.Choices) { ParameterChoice localizedChoice = new ParameterChoice( templateChoice.Value.DisplayName, templateChoice.Value.Description); if (localizationForTag.Choices.TryGetValue(templateChoice.Key, out ParameterChoiceLocalizationModel locModel)) { localizedChoice.Localize(locModel); } localizedChoices.Add(templateChoice.Key, localizedChoice); } ICacheTag localizedTag = new CacheTag( localizationForTag.DisplayName ?? templateTag.Value.DisplayName, localizationForTag.Description ?? templateTag.Value.Description, localizedChoices, templateTag.Value.DefaultValue, (templateTag.Value as IAllowDefaultIfOptionWithoutValue)?.DefaultIfOptionWithoutValue); localizedCacheTags.Add(templateTag.Key, localizedTag); } return(localizedCacheTags); }
private IReadOnlyDictionary <string, ICacheParameter> LocalizeCacheParameters(ITemplateInfo template, ILocalizationLocator localizationInfo) { if (localizationInfo == null || localizationInfo.ParameterSymbols == null) { return(template.CacheParameters); } IReadOnlyDictionary <string, ICacheParameter> cacheParameters = template.CacheParameters; IReadOnlyDictionary <string, IParameterSymbolLocalizationModel> parameterSymbols = localizationInfo.ParameterSymbols; Dictionary <string, ICacheParameter> dictionary = new Dictionary <string, ICacheParameter>(); foreach (KeyValuePair <string, ICacheParameter> item in cacheParameters) { if (parameterSymbols.TryGetValue(item.Key, out IParameterSymbolLocalizationModel value)) { ICacheParameter value2 = new CacheParameter { DataType = item.Value.DataType, DefaultValue = item.Value.DefaultValue, Description = value.Description ?? item.Value.Description }; dictionary.Add(item.Key, value2); } else { dictionary.Add(item.Key, item.Value); } } return(dictionary); }
private IReadOnlyDictionary <string, ICacheTag> LocalizeCacheTags(ITemplateInfo template, ILocalizationLocator localizationInfo) { if (localizationInfo == null || localizationInfo.ParameterSymbols == null) { return(template.Tags); } IReadOnlyDictionary <string, ICacheTag> tags = template.Tags; IReadOnlyDictionary <string, IParameterSymbolLocalizationModel> parameterSymbols = localizationInfo.ParameterSymbols; Dictionary <string, ICacheTag> dictionary = new Dictionary <string, ICacheTag>(); foreach (KeyValuePair <string, ICacheTag> item in tags) { if (parameterSymbols.TryGetValue(item.Key, out IParameterSymbolLocalizationModel value)) { Dictionary <string, string> dictionary2 = new Dictionary <string, string>(); foreach (KeyValuePair <string, string> choicesAndDescription in item.Value.ChoicesAndDescriptions) { if (value.ChoicesAndDescriptions.TryGetValue(choicesAndDescription.Key, out string value2) && !string.IsNullOrWhiteSpace(value2)) { dictionary2.Add(choicesAndDescription.Key, value2); } else { dictionary2.Add(choicesAndDescription.Key, choicesAndDescription.Value); } } string description = value.Description ?? item.Value.Description; IAllowDefaultIfOptionWithoutValue allowDefaultIfOptionWithoutValue = item.Value as IAllowDefaultIfOptionWithoutValue; dictionary.Add(value: allowDefaultIfOptionWithoutValue == null ? new CacheTag(description, dictionary2, item.Value.DefaultValue) : new CacheTag(description, dictionary2, item.Value.DefaultValue, allowDefaultIfOptionWithoutValue.DefaultIfOptionWithoutValue), key: item.Key); } else { dictionary.Add(item.Key, item.Value); } } return(dictionary); }
public void AddLocalization(ILocalizationLocator locater) { _localizations.Add(locater); }