New: Localization framework

pull/4618/head
Qstick 4 years ago
parent 5389c86cde
commit ffff528ccb

@ -0,0 +1,28 @@
import $ from 'jquery';
function getTranslations() {
let localization = null;
const ajaxOptions = {
async: false,
type: 'GET',
global: false,
dataType: 'json',
url: `${window.Radarr.apiRoot}/localization`,
success: function(data) {
localization = data.strings;
}
};
ajaxOptions.headers = ajaxOptions.headers || {};
ajaxOptions.headers['X-Api-Key'] = window.Radarr.apiKey;
$.ajax(ajaxOptions);
return localization;
}
const translations = getTranslations();
export default function translate(key) {
const formatedKey = key.charAt(0).toLowerCase() + key.slice(1);
return translations[formatedKey] || key;
}

@ -0,0 +1,78 @@
using System;
using FluentAssertions;
using NUnit.Framework;
using NzbDrone.Common.EnvironmentInfo;
using NzbDrone.Core.Configuration;
using NzbDrone.Core.Languages;
using NzbDrone.Core.Localization;
using NzbDrone.Core.Test.Framework;
using NzbDrone.Test.Common;
namespace NzbDrone.Core.Test.Localization
{
[TestFixture]
public class LocalizationServiceFixture : CoreTest<LocalizationService>
{
[SetUp]
public void Setup()
{
Mocker.GetMock<IConfigService>().Setup(m => m.MovieInfoLanguage).Returns((int)Language.English);
Mocker.GetMock<IAppFolderInfo>().Setup(m => m.StartUpFolder).Returns(TestContext.CurrentContext.TestDirectory);
}
[Test]
public void should_get_string_in_dictionary_if_lang_exists_and_string_exists()
{
var localizedString = Subject.GetLocalizedString("BackupNow");
localizedString.Should().Be("Backup Now");
}
[Test]
public void should_get_string_in_default_dictionary_if_no_lang_exists_and_string_exists()
{
var localizedString = Subject.GetLocalizedString("BackupNow", "an");
localizedString.Should().Be("Backup Now");
ExceptionVerification.ExpectedErrors(1);
}
[Test]
public void should_get_string_in_default_dictionary_if_lang_empty_and_string_exists()
{
var localizedString = Subject.GetLocalizedString("BackupNow", "");
localizedString.Should().Be("Backup Now");
}
[Test]
public void should_return_argument_if_string_doesnt_exists()
{
var localizedString = Subject.GetLocalizedString("BadString", "en");
localizedString.Should().Be("BadString");
}
[Test]
public void should_return_argument_if_string_doesnt_exists_default_lang()
{
var localizedString = Subject.GetLocalizedString("BadString");
localizedString.Should().Be("BadString");
}
[Test]
public void should_throw_if_empty_string_passed()
{
Assert.Throws<ArgumentNullException>(() => Subject.GetLocalizedString(""));
}
[Test]
public void should_throw_if_null_string_passed()
{
Assert.Throws<ArgumentNullException>(() => Subject.GetLocalizedString(null));
}
}
}

@ -0,0 +1,167 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Text.Json;
using System.Threading.Tasks;
using NLog;
using NzbDrone.Common.Cache;
using NzbDrone.Common.EnvironmentInfo;
using NzbDrone.Common.Extensions;
using NzbDrone.Core.Configuration;
using NzbDrone.Core.Configuration.Events;
using NzbDrone.Core.Languages;
using NzbDrone.Core.Messaging.Events;
using NzbDrone.Core.Parser;
namespace NzbDrone.Core.Localization
{
public interface ILocalizationService
{
Dictionary<string, string> GetLocalizationDictionary();
string GetLocalizedString(string phrase);
string GetLocalizedString(string phrase, string language);
}
public class LocalizationService : ILocalizationService, IHandleAsync<ConfigSavedEvent>
{
private const string DefaultCulture = "en";
private readonly ICached<Dictionary<string, string>> _cache;
private readonly IConfigService _configService;
private readonly IAppFolderInfo _appFolderInfo;
private readonly Logger _logger;
public LocalizationService(IConfigService configService,
IAppFolderInfo appFolderInfo,
ICacheManager cacheManager,
Logger logger)
{
_configService = configService;
_appFolderInfo = appFolderInfo;
_cache = cacheManager.GetCache<Dictionary<string, string>>(typeof(Dictionary<string, string>), "localization");
_logger = logger;
}
public Dictionary<string, string> GetLocalizationDictionary()
{
var language = IsoLanguages.Get((Language)_configService.MovieInfoLanguage).TwoLetterCode;
return GetLocalizationDictionary(language);
}
public string GetLocalizedString(string phrase)
{
var language = IsoLanguages.Get((Language)_configService.MovieInfoLanguage).TwoLetterCode;
return GetLocalizedString(phrase, language);
}
public string GetLocalizedString(string phrase, string language)
{
if (string.IsNullOrEmpty(phrase))
{
throw new ArgumentNullException(nameof(phrase));
}
if (language.IsNullOrWhiteSpace())
{
language = IsoLanguages.Get((Language)_configService.MovieInfoLanguage).TwoLetterCode;
}
if (language == null)
{
language = DefaultCulture;
}
var dictionary = GetLocalizationDictionary(language);
if (dictionary.TryGetValue(phrase, out var value))
{
return value;
}
return phrase;
}
private Dictionary<string, string> GetLocalizationDictionary(string language)
{
if (string.IsNullOrEmpty(language))
{
throw new ArgumentNullException(nameof(language));
}
var startupFolder = _appFolderInfo.StartUpFolder;
var prefix = Path.Combine(startupFolder, "Localization", "Core");
var key = prefix + language;
return _cache.Get("localization", () => GetDictionary(prefix, language, DefaultCulture + ".json").GetAwaiter().GetResult());
}
private async Task<Dictionary<string, string>> GetDictionary(string prefix, string culture, string baseFilename)
{
if (string.IsNullOrEmpty(culture))
{
throw new ArgumentNullException(nameof(culture));
}
var dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
var baseFilenamePath = Path.Combine(prefix, baseFilename);
var alternativeFilenamePath = Path.Combine(prefix, GetResourceFilename(culture));
await CopyInto(dictionary, baseFilenamePath).ConfigureAwait(false);
await CopyInto(dictionary, alternativeFilenamePath).ConfigureAwait(false);
return dictionary;
}
private async Task CopyInto(IDictionary<string, string> dictionary, string resourcePath)
{
if (!File.Exists(resourcePath))
{
_logger.Error("Missing translation/culture resource: {0}", resourcePath);
return;
}
using (var fs = File.OpenRead(resourcePath))
{
if (fs != null)
{
var dict = await JsonSerializer.DeserializeAsync<Dictionary<string, string>>(fs);
foreach (var key in dict.Keys)
{
dictionary[key] = dict[key];
}
}
else
{
_logger.Error("Missing translation/culture resource: {0}", resourcePath);
}
}
}
private static string GetResourceFilename(string culture)
{
var parts = culture.Split('-');
if (parts.Length == 2)
{
culture = parts[0].ToLowerInvariant() + "-" + parts[1].ToUpperInvariant();
}
else
{
culture = culture.ToLowerInvariant();
}
return culture + ".json";
}
public void HandleAsync(ConfigSavedEvent message)
{
_cache.Clear();
}
}
}

@ -33,6 +33,11 @@
<Link>Resources\Logo\64.png</Link>
</EmbeddedResource>
</ItemGroup>
<ItemGroup>
<Content Include="Localization\Core\**">
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</Content>
</ItemGroup>
<Target Name="CopyRuntimeFilesOnBuild" AfterTargets="AfterBuild">
<Copy SourceFiles="@(RuntimeFiles)" DestinationFolder="$(OutDir)" />
</Target>

@ -0,0 +1,22 @@
using NzbDrone.Core.Localization;
using Radarr.Http;
namespace Radarr.Api.V3.Localization
{
public class LocalizationModule : RadarrRestModule<LocalizationResource>
{
private readonly ILocalizationService _localizationService;
public LocalizationModule(ILocalizationService localizationService)
{
_localizationService = localizationService;
GetResourceSingle = GetLocalizationDictionary;
}
private LocalizationResource GetLocalizationDictionary()
{
return _localizationService.GetLocalizationDictionary().ToResource();
}
}
}

@ -0,0 +1,26 @@
using System.Collections.Generic;
using Radarr.Http.REST;
namespace Radarr.Api.V3.Localization
{
public class LocalizationResource : RestResource
{
public Dictionary<string, string> Strings { get; set; }
}
public static class LocalizationResourceMapper
{
public static LocalizationResource ToResource(this Dictionary<string, string> localization)
{
if (localization == null)
{
return null;
}
return new LocalizationResource
{
Strings = localization,
};
}
}
}
Loading…
Cancel
Save