private string GetTranslation(string key, CultureInfo language)
{
var cacheKey = CacheKeyHelper.BuildKey(key);
var localizationResource = ConfigurationContext.Current.CacheManager.Get(cacheKey) as LocalizationResource;
if (localizationResource != null)
{
// if value for the cache key is null - this is non-existing resource (no hit)
return(localizationResource.Translations?.FirstOrDefault(t => t.Language == language.Name)?.Value);
}
var resource = GetResourceFromDb(key);
LocalizationResourceTranslation localization = null;
if (resource == null)
{
// create empty null resource - to indicate non-existing one
resource = LocalizationResource.CreateNonExisting(key);
}
else
{
localization = resource.Translations.FirstOrDefault(t => t.Language == language.Name);
}
ConfigurationContext.Current.CacheManager.Insert(cacheKey, resource);
return(localization?.Value);
}
public string Execute(GetTranslation.Query query)
{
if (!ConfigurationContext.Current.EnableLocalization())
{
return(query.Key);
}
var key = query.Key;
var language = query.Language;
var cacheKey = CacheKeyHelper.BuildKey(key);
var localizationResource = ConfigurationContext.Current.CacheManager.Get(cacheKey) as LocalizationResource;
if (localizationResource != null)
{
return(GetTranslationFromAvailableList(localizationResource.Translations, language, query.UseFallback)?.Value);
}
var resource = GetResourceFromDb(key);
LocalizationResourceTranslation localization = null;
if (resource == null)
{
resource = LocalizationResource.CreateNonExisting(key);
}
else
{
localization = GetTranslationFromAvailableList(resource.Translations, language, query.UseFallback);
}
ConfigurationContext.Current.CacheManager.Insert(cacheKey, resource);
return(localization?.Value);
}
protected virtual string GetTranslation(Query query)
{
var key = query.Key;
var language = query.Language;
var cacheKey = CacheKeyHelper.BuildKey(key);
var localizationResource = ConfigurationContext.Current.CacheManager.Get(cacheKey) as LocalizationResource;
if (localizationResource != null)
{
return(GetTranslationFromAvailableList(localizationResource.Translations, language, query.UseFallback)?.Value);
}
var resource = GetResourceFromDb(key);
LocalizationResourceTranslation localization = null;
// create empty null resource - to indicate non-existing one
if (resource == null)
{
resource = LocalizationResource.CreateNonExisting(key);
}
else
{
localization = GetTranslationFromAvailableList(resource.Translations, language, query.UseFallback);
}
ConfigurationContext.Current.CacheManager.Insert(cacheKey, resource);
return(localization?.Value);
}
public string Execute(GetTranslation.Query query)
{
if (!ConfigurationContext.Current.EnableLocalization())
{
return(query.Key);
}
var key = query.Key;
var language = query.Language;
var cacheKey = CacheKeyHelper.BuildKey(key);
var localizationResource = ConfigurationContext.Current.CacheManager.Get(cacheKey) as LocalizationResource;
if (localizationResource != null)
{
return(GetTranslationFromAvailableList(localizationResource.Translations, language, query.UseFallback)?.Value);
}
LocalizationResourceTranslation localization = null;
LocalizationResource resource;
try
{
resource = new GetResource.Query(key).Execute();
}
catch (KeyNotFoundException)
{
// this can be a case when Episerver initialization infrastructure calls localization provider way too early
// and there is no registration for the GetResourceHandler - so we can fallback to default implementation
// TODO: maybe we should just have default mapping (even if init has not been called)
// (before any of the setup code in the provider is executed). this happens if you have DisplayChannels in codebase
resource = new GetResourceHandler().Execute(new GetResource.Query(query.Key));
}
if (resource == null)
{
resource = LocalizationResource.CreateNonExisting(key);
}
else
{
localization = GetTranslationFromAvailableList(resource.Translations, language, query.UseFallback);
}
ConfigurationContext.Current.CacheManager.Insert(cacheKey, resource);
return(localization?.Value);
}
/// <summary>
/// Place where query handling happens
/// </summary>
/// <param name="query">This is the query instance</param>
/// <returns>
/// You have to return something from the query execution. Of course you can return <c>null</c> as well if you
/// will.
/// </returns>
public string Execute(GetTranslation.Query query)
{
var context = ConfigurationContext.Current;
if (!context.EnableLocalization())
{
return(query.Key);
}
var key = query.Key;
// we can check whether we know this resource at all
// if not - we can break circuit here
if (!ConfigurationContext.Current.BaseCacheManager.KnownResourceKeys.ContainsKey(key))
{
return(null);
}
var cacheKey = CacheKeyHelper.BuildKey(key);
if (context.DiagnosticsEnabled)
{
context.Logger?.Debug($"Executing query for resource key `{query.Key}` (lang: `{query.Language.Name})..");
}
var localizationResource = context.CacheManager.Get(cacheKey) as LocalizationResource;
if (localizationResource == null)
{
if (context.DiagnosticsEnabled)
{
context.Logger?.Info(
$"MISSING: Resource Key (culture: {query.Language.Name}): {query.Key}. Probably class is not decorated with either [LocalizedModel] or [LocalizedResource] attribute.");
}
// resource is not found in the cache, let's check database
localizationResource = GetResourceFromDb(key) ?? LocalizationResource.CreateNonExisting(key);
context.CacheManager.Insert(cacheKey, localizationResource, true);
}
return(localizationResource.Translations.GetValueWithFallback(
query.Language,
context.FallbackCultures));
}
private LocalizationResource GetCachedResourceOrReadFromStorage(Query query)
{
var key = query.Key;
var cacheKey = CacheKeyHelper.BuildKey(key);
if (_configurationContext.CacheManager.Get(cacheKey) is LocalizationResource localizationResource)
{
return(localizationResource);
}
if (_configurationContext.DiagnosticsEnabled)
{
_logger.Info(
$"MISSING: Resource Key (culture: {query.Language.Name}): {key}. Probably class is not decorated with either [LocalizedModel] or [LocalizedResource] attribute.");
}
// resource is not found in the cache, let's check database
localizationResource = GetResourceFromDb(key) ?? LocalizationResource.CreateNonExisting(key);
_configurationContext.CacheManager.Insert(cacheKey, localizationResource, true);
return(localizationResource);
}
public ICollection <DetectedImportChange> DetectChanges(ICollection <LocalizationResource> importingResources, IEnumerable <LocalizationResource> existingResources)
{
var result = new List <DetectedImportChange>();
// deleted deletes
var resourceComparer = new ResourceComparer();
var deletes = existingResources.Except(importingResources, resourceComparer);
result.AddRange(deletes.Select(d => new DetectedImportChange(ChangeType.Delete, LocalizationResource.CreateNonExisting(d.ResourceKey), d)));
foreach (var incomingResource in importingResources.Except(deletes, resourceComparer))
{
// clean up nulls from translations
incomingResource.Translations = incomingResource.Translations.Where(t => t != null).ToList();
var existing = existingResources.FirstOrDefault(r => r.ResourceKey == incomingResource.ResourceKey);
if (existing != null)
{
var comparer = new TranslationComparer(true);
var existingTranslations = existing.Translations.Where(_ => _ != null).ToList();
var differences = incomingResource.Translations.Except(existingTranslations, comparer).Where(_ => _ != null).ToList();
// some of the translations are different - so marking this resource as potential update
if (differences.Any())
{
// here we need to check whether incoming resource is overriding existing translation (exists translation in given language)
// or we are maybe importing exported language that had no translations
// this could happen if you export language with no translations in xliff format
// then new exported target language will have translation as empty string
// these cases we need to filter out
var detectedChangedLanguages = differences.Select(_ => _.Language).Distinct().ToList();
var existingLanguages = existingTranslations.Select(_ => _.Language).Distinct().ToList();
if (!differences.All(r => string.IsNullOrEmpty(r.Value)) || !detectedChangedLanguages.Except(existingLanguages).Any())
{
result.Add(new DetectedImportChange(ChangeType.Update, incomingResource, existing)
{
ChangedLanguages = detectedChangedLanguages
});
}
}
}
else
{
result.Add(new DetectedImportChange(ChangeType.Insert, incomingResource, LocalizationResource.CreateNonExisting(incomingResource.ResourceKey))
{
ChangedLanguages = incomingResource.Translations.Select(t => t.Language).ToList()
});
}
}
return(result);
}
public IEnumerable <DetectedImportChange> DetectChanges(IEnumerable <LocalizationResource> importingResources, IEnumerable <LocalizationResource> existingResources)
{
var result = new List <DetectedImportChange>();
// deleted deletes
var resourceComparer = new ResourceComparer();
var deletes = existingResources.Except(importingResources, resourceComparer);
result.AddRange(deletes.Select(d => new DetectedImportChange(ChangeType.Delete, LocalizationResource.CreateNonExisting(d.ResourceKey), d)));
foreach (var incomingResource in importingResources.Except(deletes, resourceComparer))
{
var existing = existingResources.FirstOrDefault(r => r.ResourceKey == incomingResource.ResourceKey);
if (existing != null)
{
var comparer = new TranslationComparer();
var differences = incomingResource.Translations.Except(existing.Translations, comparer)
.ToList();
// some of the translations are different - so marking this resource as potential update
if (differences.Any())
{
result.Add(new DetectedImportChange(ChangeType.Update, incomingResource, existing)
{
ChangedLanguages = differences.Select(t => t.Language).Distinct().ToList()
});
}
}
else
{
result.Add(new DetectedImportChange(ChangeType.Insert, incomingResource, LocalizationResource.CreateNonExisting(incomingResource.ResourceKey)));
}
}
return(result);
}