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);
}
private LocalizationResource FromEntity(LocalizationResourceEntity firstOrDefault)
{
if (firstOrDefault == null)
{
return(null);
}
var result = new LocalizationResource(firstOrDefault.RowKey, _enableInvariantCultureFallback)
{
Author = firstOrDefault.Author,
ModificationDate = firstOrDefault.ModificationDate,
FromCode = firstOrDefault.FromCode,
IsModified = firstOrDefault.IsModified,
IsHidden = firstOrDefault.IsHidden
};
var translationEntities = JsonConvert.DeserializeObject <LocalizationResourceTranslationEntity[]>(firstOrDefault.Translations);
if (translationEntities.Any())
{
result.Translations.AddRange(translationEntities.Select(te => FromTranslationEntity(te, result)));
}
return(result);
}
public void CompareInvariantCultures_UsingExcept_NoChanges()
{
var incomingResource = new LocalizationResource("key")
{
Translations = new List <LocalizationResourceTranslation>
{
new LocalizationResourceTranslation
{
Language = "",
Value = "incoming value"
}
}
};
var existingResource = new LocalizationResource("key")
{
Translations = new List <LocalizationResourceTranslation>
{
new LocalizationResourceTranslation
{
Language = "",
Value = "existing value"
}
}
};
var sut = new TranslationComparer(true);
var differences = incomingResource.Translations.Except(existingResource.Translations, sut).ToList();
Assert.Empty(differences);
}
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);
}
/// <summary>
/// Parses the specified file content.
/// </summary>
/// <param name="fileContent">Content of the file.</param>
/// <returns>
/// Returns list of resources from the file
/// </returns>
public ParseResult Parse(string fileContent)
{
var resources = new List <LocalizationResource>();
var csvConfig = new CsvConfiguration(CultureInfo.InvariantCulture);
using (var stream = AsStream(fileContent))
using (var reader = new StreamReader(stream, Encoding.UTF8))
using (var csv = new CsvReader(reader, csvConfig))
{
var records = csv.GetRecords <dynamic>().ToList();
var languages = GetLanguages(records);
foreach (var record in records)
{
var dict = (IDictionary <string, object>)record;
var resourceKey = dict["ResourceKey"] as string;
var resource = new LocalizationResource(resourceKey, false);
resource.Translations.AddRange(CreateTranslations(record, languages));
resources.Add(resource);
}
return(new ParseResult(resources, languages));
}
}
public void Initialize(LocalizationResourceInitializationContext context)
{
_resource = context.Resource;
_applicationConfigurationClient = context.ServiceProvider.GetRequiredService <ICachedApplicationConfigurationClient>();
_logger = context.ServiceProvider.GetService <ILogger <RemoteLocalizationContributor> >()
?? NullLogger <RemoteLocalizationContributor> .Instance;
}
/// <summary>
/// Adds the translation for the resource.
/// </summary>
/// <param name="resource">The resource.</param>
/// <param name="translation">The translation.</param>
/// <exception cref="ArgumentNullException">
/// resource
/// or
/// translation
/// </exception>
public void AddTranslation(LocalizationResource resource, LocalizationResourceTranslation translation)
{
if (resource == null)
{
throw new ArgumentNullException(nameof(resource));
}
if (translation == null)
{
throw new ArgumentNullException(nameof(translation));
}
using (var conn = new SqlConnection(Settings.DbContextConnectionString))
{
conn.Open();
var cmd = new SqlCommand(
"INSERT INTO [dbo].[LocalizationResourceTranslations] ([Language], [ResourceId], [Value], [ModificationDate]) VALUES (@language, @resourceId, @translation, @modificationDate)",
conn);
cmd.Parameters.AddWithValue("language", translation.Language);
cmd.Parameters.AddWithValue("resourceId", translation.ResourceId);
cmd.Parameters.AddWithValue("translation", translation.Value);
cmd.Parameters.AddWithValue("modificationDate", translation.ModificationDate);
cmd.ExecuteNonQuery();
}
}
/// <summary>
/// Updates the translation for the resource.
/// </summary>
/// <param name="resource">The resource.</param>
/// <param name="translation">The translation.</param>
/// <exception cref="ArgumentNullException">
/// resource
/// or
/// translation
/// </exception>
public void UpdateTranslation(LocalizationResource resource, LocalizationResourceTranslation translation)
{
if (resource == null)
{
throw new ArgumentNullException(nameof(resource));
}
if (translation == null)
{
throw new ArgumentNullException(nameof(translation));
}
using (var conn = new SqlConnection(Settings.DbContextConnectionString))
{
conn.Open();
var cmd = new SqlCommand(
"UPDATE [dbo].[LocalizationResourceTranslations] SET [Value] = @translation, [ModificationDate] = @modificationDate WHERE [Id] = @id",
conn);
cmd.Parameters.AddWithValue("translation", translation.Value);
cmd.Parameters.AddWithValue("id", translation.Id);
cmd.Parameters.AddWithValue("modificationDate", DateTime.UtcNow);
cmd.ExecuteNonQuery();
}
}
public void CompareUsingInvariant_UsingExcept_NewLanguageDetected()
{
var incomingResource = new LocalizationResource("key", false);
incomingResource.Translations.AddRange(
new List <LocalizationResourceTranslation>
{
new LocalizationResourceTranslation {
Language = "", Value = "incoming value"
},
new LocalizationResourceTranslation {
Language = "en", Value = "incoming EN value"
}
});
var existingResource = new LocalizationResource("key", false);
existingResource.Translations.Add(new LocalizationResourceTranslation {
Language = "", Value = "existing value"
});
var sut = new TranslationComparer(true);
var differences = incomingResource.Translations.Except(existingResource.Translations, sut).ToList();
Assert.NotEmpty(differences);
}
/// <summary>
/// Initializes a new instance of the <see cref="DetectedImportChange"/> class.
/// </summary>
/// <param name="changeType">Type of the change.</param>
/// <param name="importing">The importing.</param>
/// <param name="existing">The existing.</param>
public DetectedImportChange(ChangeType changeType, LocalizationResource importing, LocalizationResource existing)
{
ChangeType = changeType;
ImportingResource = importing;
ExistingResource = existing;
ChangedLanguages = new List <string>();
}
public void BothListsFilledWithTranslations_SameKeys_Duplicate_Translation_Throws()
{
var merger = new ResourceListMerger();
var resource1English = new LocalizationResource("key1");
resource1English.Translations.Add(new LocalizationResourceTranslation
{
Language = "en",
Value = "hello"
});
var resource1Norsk = new LocalizationResource("key1");
resource1Norsk.Translations.Add(new LocalizationResourceTranslation
{
Language = "no",
Value = "hei"
});
var list1 = new List <LocalizationResource>
{
resource1English
};
var list2 = new List <LocalizationResource>
{
resource1Norsk,
//Duplicate translation that makes the merger throw
resource1Norsk
};
Assert.Throws(typeof(NotSupportedException), () => merger.Merge(list1, list2));
}
private void RegisterIfNotExist(LanguageEntities db, string resourceKey, string resourceValue, string defaultCulture, string author = "type-scanner")
{
var existingResource = db.LocalizationResources.Include(r => r.Translations).FirstOrDefault(r => r.ResourceKey == resourceKey);
if (existingResource != null)
{
existingResource.FromCode = true;
// if resource is not modified - we can sync default value from code
if (existingResource.IsModified.HasValue && !existingResource.IsModified.Value)
{
existingResource.ModificationDate = DateTime.UtcNow;
var defaultTranslation = existingResource.Translations.FirstOrDefault(t => t.Language == defaultCulture);
if (defaultTranslation != null)
{
defaultTranslation.Value = resourceValue;
}
}
var fromCodeTranslation = existingResource.Translations.FirstOrDefault(t => t.Language == ConfigurationContext.CultureForTranslationsFromCode);
if (fromCodeTranslation != null)
{
fromCodeTranslation.Value = resourceValue;
}
else
{
fromCodeTranslation = new LocalizationResourceTranslation
{
Language = ConfigurationContext.CultureForTranslationsFromCode,
Value = resourceValue
};
existingResource.Translations.Add(fromCodeTranslation);
}
}
else
{
// create new resource
var resource = new LocalizationResource(resourceKey)
{
ModificationDate = DateTime.UtcNow,
Author = author,
FromCode = true,
IsModified = false
};
resource.Translations.Add(new LocalizationResourceTranslation
{
Language = defaultCulture,
Value = resourceValue
});
resource.Translations.Add(new LocalizationResourceTranslation
{
Language = ConfigurationContext.CultureForTranslationsFromCode,
Value = resourceValue
});
db.LocalizationResources.Add(resource);
}
}
/// <summary>
/// Checks if item already present in database.
/// </summary>
public bool IsPresent(LocalizationResource resource)
{
var isPresent = _unitOfWork.Get <LocalizationResource>().Any(entry => ((entry.ResourceKey == resource.ResourceKey)
&&
(entry.ResourceCultureCode == resource.ResourceCultureCode)));
return(isPresent);
}
public static LocalizationResource AddVirtualJson(
[NotNull] this LocalizationResource localizationResource,
[NotNull] string virtualPath)
{
Check.NotNull(localizationResource, nameof(localizationResource));
Check.NotNull(virtualPath, nameof(virtualPath));
localizationResource.Contributors.Add(new JsonVirtualFileLocalizationResourceContributor(virtualPath.EnsureStartsWith('/')));
return(localizationResource);
}
private Lazy <Dictionary <string, string> > GetResourceDictionary(LocalizationResource resource, LocalizationLocale?locale)
{
return(resource switch
{
LocalizationResource.OrdbokConcepts => locale switch
{
LocalizationLocale.NoNb => _ordbokConceptsDictionaryNb,
LocalizationLocale.NoNn => _ordbokConceptsDictionaryNn,
_ => _ordbokConceptsDictionaryNb
},
/// <summary>
/// 添加Json本地磁盘文件支持
/// </summary>
/// <param name="localizationResource"></param>
/// <param name="jsonFilePath"></param>
/// <returns></returns>
public static LocalizationResource AddPhysicalJson(
[NotNull] this LocalizationResource localizationResource,
[NotNull] string jsonFilePath)
{
Check.NotNull(localizationResource, nameof(localizationResource));
Check.NotNull(jsonFilePath, nameof(jsonFilePath));
localizationResource.Contributors.Add(new JsonPhysicalFileLocalizationResourceContributor(jsonFilePath));
return(localizationResource);
}
/// <summary>
/// Inserts the resource in database.
/// </summary>
/// <param name="resource">The resource.</param>
/// <exception cref="ArgumentNullException">resource</exception>
public void InsertResource(LocalizationResource resource)
{
if (resource == null)
{
throw new ArgumentNullException(nameof(resource));
}
var table = GetTable();
table.Execute(TableOperation.Insert(ToEntity(resource)));
}
public string GetString(string key, LocalizationResource resource, string?locale)
{
var localizationLocale = locale?.ToLower() switch
{
"bob" => LocalizationLocale.NoNb,
"nob" => LocalizationLocale.NoNn,
_ => LocalizationLocale.NoNb
};
return(GetString(key, resource, localizationLocale));
}
/// <summary>
/// 添加Xml本地磁盘文件支持
/// </summary>
/// <param name="localizationResource"></param>
/// <param name="xmlFilePath"></param>
/// <returns></returns>
public static LocalizationResource AddPhysicalXml(
[NotNull] this LocalizationResource localizationResource,
[NotNull] string xmlFilePath)
{
Check.NotNull(localizationResource, nameof(localizationResource));
Check.NotNull(xmlFilePath, nameof(xmlFilePath));
localizationResource.Contributors.Add(new XmlPhysicalFileLocalizationResourceContributor(xmlFilePath));
return(localizationResource);
}
private LocalizationResourceTranslation FromTranslationEntity(
LocalizationResourceTranslationEntity translationEntity,
LocalizationResource localizationResource)
{
return(new LocalizationResourceTranslation
{
Language = translationEntity.Language,
Value = translationEntity.Translation,
ModificationDate = translationEntity.ModificationDate,
LocalizationResource = localizationResource
});
}
private ITableEntity ToEntity(LocalizationResource resource)
{
return(new LocalizationResourceEntity(resource.ResourceKey)
{
Author = resource.Author,
ModificationDate = DateTime.UtcNow,
FromCode = resource.FromCode,
IsModified = resource.IsModified ?? true,
IsHidden = resource.IsHidden ?? false,
Translations = JsonConvert.SerializeObject(resource.Translations.Select(ToTranslationEntity).ToList()),
ETag = "*"
});
}
private LocalizationResourceTranslation CreateTranslationFromSqlReader(
NpgsqlDataReader reader,
LocalizationResource result)
{
return(new LocalizationResourceTranslation
{
Id = reader.GetInt32(reader.GetOrdinal("TranslationId")),
ResourceId = result.Id,
Value = reader.GetStringSafe("Translation"),
Language = reader.GetStringSafe("Language") ?? string.Empty,
ModificationDate = reader.GetDateTime(reader.GetOrdinal("TranslationModificationDate")),
LocalizationResource = result
});
}
public static LocalizationResource AddBaseTypes(
[NotNull] this LocalizationResource localizationResource,
[NotNull] params Type[] types)
{
Check.NotNull(localizationResource, nameof(localizationResource));
Check.NotNull(types, nameof(types));
foreach (var type in types)
{
localizationResource.BaseResourceTypes.AddIfNotContains(type);
}
return(localizationResource);
}
/// <summary>
/// Deletes the resource.
/// </summary>
/// <param name="resource">The resource.</param>
/// <exception cref="ArgumentNullException">resource</exception>
public void DeleteResource(LocalizationResource resource)
{
if (resource == null)
{
throw new ArgumentNullException(nameof(resource));
}
var table = GetTable();
var entity = new DynamicTableEntity(LocalizationResourceEntity.PartitionKey, resource.ResourceKey)
{
ETag = "*"
};
table.Execute(TableOperation.Delete(entity));
}
/// <summary>
/// Updates the translation for the resource.
/// </summary>
/// <param name="resource">The resource.</param>
/// <param name="translation">The translation.</param>
/// <exception cref="ArgumentNullException">
/// resource
/// or
/// translation
/// </exception>
public void UpdateTranslation(LocalizationResource resource, LocalizationResourceTranslation translation)
{
if (resource == null)
{
throw new ArgumentNullException(nameof(resource));
}
if (translation == null)
{
throw new ArgumentNullException(nameof(translation));
}
var table = GetTable();
table.Execute(TableOperation.Replace(ToEntity(resource)));
}
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);
}
public string GetString(string key, LocalizationResource resource, LocalizationLocale?locale)
{
var dictionary = GetResourceDictionary(resource, locale);
if (dictionary.Value == null)
{
return(key);
}
if (dictionary.Value.ContainsKey(key))
{
return(dictionary.Value[key]);
}
// Temporarily mark elements that are missing from localization file
return($"?{key}?");
}
private static void AddTranslationScript(LocalizationResource existingResource, string language, StringBuilder buffer, DiscoveredResource resource)
{
var existingTranslation = existingResource.Translations.FirstOrDefault(t => t.Language == language);
if (existingTranslation == null)
{
buffer.Append($@"
insert into localizationresourcetranslations (resourceid, [language], [value]) values ({existingResource.Id}, '{language}', N'{resource.Translation.Replace("'", "''")}')
");
}
else if (!existingTranslation.Value.Equals(resource.Translation))
{
buffer.Append($@"
update localizationresourcetranslations set [value] = N'{resource.Translation.Replace("'", "''")}' where resourceid={existingResource.Id} and [language]='{language}'
");
}
}
/// <summary>
/// Deletes the resource.
/// </summary>
/// <param name="resource">The resource.</param>
/// <exception cref="ArgumentNullException">resource</exception>
public void DeleteResource(LocalizationResource resource)
{
if (resource == null)
{
throw new ArgumentNullException(nameof(resource));
}
using (var conn = new SqlConnection(Settings.DbContextConnectionString))
{
conn.Open();
var cmd = new SqlCommand("DELETE FROM [dbo].[LocalizationResources] WHERE [Id] = @id", conn);
cmd.Parameters.AddWithValue("id", resource.Id);
cmd.ExecuteNonQuery();
}
}
public void BothListsFilledWithTranslations_SameKeys_JoinedList()
{
var merger = new ResourceListMerger();
var resource1English = new LocalizationResource("key1");
resource1English.Translations.Add(new LocalizationResourceTranslation
{
Language = "en",
Value = "hello"
});
var resource1Norsk = new LocalizationResource("key1");
resource1English.Translations.Add(new LocalizationResourceTranslation
{
Language = "no",
Value = "hei"
});
var list1 = new List<LocalizationResource>
{
resource1English
};
var list2 = new List<LocalizationResource>
{
resource1Norsk
};
var result = merger.Merge(list1, list2);
Assert.NotEmpty(result);
Assert.Single(result);
var finalResource = result.First();
Assert.Equal(2, finalResource.Translations.Count);
}
private void RegisterIfNotExist(LanguageEntities db, string resourceKey, string resourceValue, string author = "type-scanner")
{
var existingResource = db.LocalizationResources.Include(r => r.Translations).FirstOrDefault(r => r.ResourceKey == resourceKey);
var defaultTranslationCulture = DetermineDefaultCulture();
if(existingResource != null)
{
existingResource.FromCode = true;
// if resource is not modified - we can sync default value from code
if(existingResource.IsModified.HasValue && !existingResource.IsModified.Value)
{
var defaultTranslation = existingResource.Translations.FirstOrDefault(t => t.Language == defaultTranslationCulture);
if(defaultTranslation != null)
{
defaultTranslation.Value = resourceValue;
}
}
var fromCodeTranslation = existingResource.Translations.FirstOrDefault(t => t.Language == ConfigurationContext.CultureForTranslationsFromCode);
if(fromCodeTranslation != null)
{
fromCodeTranslation.Value = resourceValue;
}
else
{
fromCodeTranslation = new LocalizationResourceTranslation
{
Language = ConfigurationContext.CultureForTranslationsFromCode,
Value = resourceValue
};
existingResource.Translations.Add(fromCodeTranslation);
}
existingResource.ModificationDate = DateTime.UtcNow;
}
else
{
// create new resource
var resource = new LocalizationResource(resourceKey)
{
ModificationDate = DateTime.UtcNow,
Author = author,
FromCode = true,
IsModified = false
};
resource.Translations.Add(new LocalizationResourceTranslation
{
Language = defaultTranslationCulture,
Value = resourceValue
});
resource.Translations.Add(new LocalizationResourceTranslation
{
Language = ConfigurationContext.CultureForTranslationsFromCode,
Value = resourceValue
});
db.LocalizationResources.Add(resource);
}
}
private static void AddNewResource(LanguageEntities db, LocalizationResource localizationResource)
{
db.LocalizationResources.Add(localizationResource);
db.LocalizationResourceTranslations.AddRange(localizationResource.Translations);
}
private static void ParseResource(IEnumerable<XElement> resourceElements,
string cultureId,
string cultureName,
ICollection<LocalizationResource> result,
string keyPrefix)
{
foreach (var element in resourceElements)
{
var resourceKey = keyPrefix + "/" + element.Name.LocalName;
if (element.Attributes().Any(a => a.Name.LocalName != "comment"
&& a.Name.LocalName != "file"
&& a.Name.LocalName != "notapproved"
&& a.Name.LocalName != "changed"))
{
var attribute = element.FirstAttribute;
resourceKey += $"[@{attribute.Name.LocalName}='{attribute.Value}']";
}
if (element.HasElements)
{
ParseResource(element.Elements(), cultureId, cultureName, result, resourceKey);
}
else
{
var resourceTranslation = element.Value.Trim();
if (string.IsNullOrEmpty(resourceTranslation))
{
continue;
}
var existingResource = result.FirstOrDefault(r => r.ResourceKey == resourceKey);
if (existingResource != null)
{
var existingTranslation = existingResource.Translations.FirstOrDefault(t => t.Language == cultureId);
if (existingTranslation != null)
{
throw new NotSupportedException($"Found duplicate translations for resource with key: {resourceKey} for culture: {cultureId}");
}
existingResource.Translations.Add(new LocalizationResourceTranslation
{
Language = cultureId,
Value = resourceTranslation
});
}
else
{
var resourceEntry = new LocalizationResource
{
ResourceKey = resourceKey,
ModificationDate = DateTime.Now,
Author = "migration-tool"
};
resourceEntry.Translations.Add(new LocalizationResourceTranslation
{
Language = cultureId,
Value = resourceTranslation
});
result.Add(resourceEntry);
}
}
}
}
