< Summary - Jellyfin

Information
Class: Emby.Server.Implementations.Localization.LocalizationManager
Assembly: Emby.Server.Implementations
File(s): /srv/git/jellyfin/Emby.Server.Implementations/Localization/LocalizationManager.cs
Line coverage
95%
Covered lines: 96
Uncovered lines: 5
Coverable lines: 101
Total lines: 545
Line coverage: 95%
Branch coverage
89%
Covered branches: 73
Total branches: 82
Branch coverage: 89%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage history 0 25 50 75 100

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.cctor()100%11100%
.ctor(...)100%11100%
GetCultures()100%11100%
FindLanguageInfo(...)100%1010100%
GetCountries()50%44100%
GetParentalRatings()85%202094.44%
GetParentalRatingsDictionary(...)100%44100%
GetRatingScore(...)96.66%3030100%
GetLocalizedString(...)100%11100%
GetLocalizedString(...)66.66%7675%
GetLocalizationDictionary(...)100%11100%
GetResourceFilename(...)100%22100%
TryGetISO6392TFromB(...)83.33%7671.42%

File(s)

/srv/git/jellyfin/Emby.Server.Implementations/Localization/LocalizationManager.cs

#LineLine coverage
 1using System;
 2using System.Collections.Concurrent;
 3using System.Collections.Frozen;
 4using System.Collections.Generic;
 5using System.Diagnostics.CodeAnalysis;
 6using System.IO;
 7using System.Linq;
 8using System.Reflection;
 9using System.Text.Json;
 10using System.Threading.Tasks;
 11using Jellyfin.Extensions;
 12using Jellyfin.Extensions.Json;
 13using MediaBrowser.Controller.Configuration;
 14using MediaBrowser.Model.Entities;
 15using MediaBrowser.Model.Globalization;
 16using Microsoft.Extensions.Logging;
 17
 18namespace Emby.Server.Implementations.Localization
 19{
 20    /// <summary>
 21    /// Class LocalizationManager.
 22    /// </summary>
 23    public class LocalizationManager : ILocalizationManager
 24    {
 25        private const string DefaultCulture = "en-US";
 26        private const string RatingsPath = "Emby.Server.Implementations.Localization.Ratings.";
 27        private const string CulturesPath = "Emby.Server.Implementations.Localization.iso6392.txt";
 28        private const string CountriesPath = "Emby.Server.Implementations.Localization.countries.json";
 229        private static readonly Assembly _assembly = typeof(LocalizationManager).Assembly;
 230        private static readonly string[] _unratedValues = ["n/a", "unrated", "not rated", "nr"];
 31
 32        private readonly IServerConfigurationManager _configurationManager;
 33        private readonly ILogger<LocalizationManager> _logger;
 34
 5335        private readonly Dictionary<string, Dictionary<string, ParentalRatingScore?>> _allParentalRatings = new(StringCo
 36
 5337        private readonly ConcurrentDictionary<string, Dictionary<string, string>> _dictionaries = new(StringComparer.Ord
 38
 5339        private readonly JsonSerializerOptions _jsonOptions = JsonDefaults.Options;
 40
 5341        private List<CultureDto> _cultures = [];
 42
 43        private FrozenDictionary<string, string> _iso6392BtoT = null!;
 44
 45        /// <summary>
 46        /// Initializes a new instance of the <see cref="LocalizationManager" /> class.
 47        /// </summary>
 48        /// <param name="configurationManager">The configuration manager.</param>
 49        /// <param name="logger">The logger.</param>
 50        public LocalizationManager(
 51            IServerConfigurationManager configurationManager,
 52            ILogger<LocalizationManager> logger)
 53        {
 5354            _configurationManager = configurationManager;
 5355            _logger = logger;
 5356        }
 57
 58        /// <summary>
 59        /// Loads all resources into memory.
 60        /// </summary>
 61        /// <returns><see cref="Task" />.</returns>
 62        public async Task LoadAll()
 63        {
 64            // Extract from the assembly
 65            foreach (var resource in _assembly.GetManifestResourceNames())
 66            {
 67                if (!resource.StartsWith(RatingsPath, StringComparison.Ordinal))
 68                {
 69                    continue;
 70                }
 71
 72                using var stream = _assembly.GetManifestResourceStream(resource);
 73                if (stream is not null)
 74                {
 75                    var ratingSystem = await JsonSerializer.DeserializeAsync<ParentalRatingSystem>(stream, _jsonOptions)
 76                                ?? throw new InvalidOperationException($"Invalid resource path: '{CountriesPath}'");
 77
 78                    var dict = new Dictionary<string, ParentalRatingScore?>();
 79                    if (ratingSystem.Ratings is not null)
 80                    {
 81                        foreach (var ratingEntry in ratingSystem.Ratings)
 82                        {
 83                            foreach (var ratingString in ratingEntry.RatingStrings)
 84                            {
 85                                dict[ratingString] = ratingEntry.RatingScore;
 86                            }
 87                        }
 88
 89                        _allParentalRatings[ratingSystem.CountryCode] = dict;
 90                    }
 91                }
 92            }
 93
 94            await LoadCultures().ConfigureAwait(false);
 95        }
 96
 97        /// <summary>
 98        /// Gets the cultures.
 99        /// </summary>
 100        /// <returns><see cref="IEnumerable{CultureDto}" />.</returns>
 101        public IEnumerable<CultureDto> GetCultures()
 1102            => _cultures;
 103
 104        private async Task LoadCultures()
 105        {
 106            List<CultureDto> list = [];
 107            Dictionary<string, string> iso6392BtoTdict = new Dictionary<string, string>();
 108
 109            using var stream = _assembly.GetManifestResourceStream(CulturesPath);
 110            if (stream is null)
 111            {
 112                throw new InvalidOperationException($"Invalid resource path: '{CulturesPath}'");
 113            }
 114            else
 115            {
 116                using var reader = new StreamReader(stream);
 117                await foreach (var line in reader.ReadAllLinesAsync().ConfigureAwait(false))
 118                {
 119                    if (string.IsNullOrWhiteSpace(line))
 120                    {
 121                        continue;
 122                    }
 123
 124                    var parts = line.Split('|');
 125                    if (parts.Length != 5)
 126                    {
 127                        throw new InvalidDataException($"Invalid culture data found at: '{line}'");
 128                    }
 129
 130                    string name = parts[3];
 131                    string displayname = parts[3];
 132                    if (string.IsNullOrWhiteSpace(displayname))
 133                    {
 134                        continue;
 135                    }
 136
 137                    string twoCharName = parts[2];
 138                    if (string.IsNullOrWhiteSpace(twoCharName))
 139                    {
 140                        continue;
 141                    }
 142                    else if (twoCharName.Contains('-', StringComparison.OrdinalIgnoreCase))
 143                    {
 144                        name = twoCharName;
 145                    }
 146
 147                    string[] threeLetterNames;
 148                    if (string.IsNullOrWhiteSpace(parts[1]))
 149                    {
 150                        threeLetterNames = [parts[0]];
 151                    }
 152                    else
 153                    {
 154                        threeLetterNames = [parts[0], parts[1]];
 155
 156                        // In cases where there are two TLN the first one is ISO 639-2/T and the second one is ISO 639-2
 157                        // We need ISO 639-2/T for the .NET cultures so we cultivate a dictionary for the translation B-
 158                        iso6392BtoTdict.TryAdd(parts[1], parts[0]);
 159                    }
 160
 161                    list.Add(new CultureDto(name, displayname, twoCharName, threeLetterNames));
 162                }
 163
 164                _cultures = list;
 165                _iso6392BtoT = iso6392BtoTdict.ToFrozenDictionary(StringComparer.OrdinalIgnoreCase);
 166            }
 167        }
 168
 169        /// <inheritdoc />
 170        public CultureDto? FindLanguageInfo(string language)
 171        {
 172            // TODO language should ideally be a ReadOnlySpan but moq cannot mock ref structs
 708173            for (var i = 0; i < _cultures.Count; i++)
 174            {
 353175                var culture = _cultures[i];
 353176                if (language.Equals(culture.DisplayName, StringComparison.OrdinalIgnoreCase)
 353177                    || language.Equals(culture.Name, StringComparison.OrdinalIgnoreCase)
 353178                    || culture.ThreeLetterISOLanguageNames.Contains(language, StringComparison.OrdinalIgnoreCase)
 353179                    || language.Equals(culture.TwoLetterISOLanguageName, StringComparison.OrdinalIgnoreCase))
 180                {
 5181                    return culture;
 182                }
 183            }
 184
 1185            return default;
 186        }
 187
 188        /// <inheritdoc />
 189        public IReadOnlyList<CountryInfo> GetCountries()
 190        {
 1191            using var stream = _assembly.GetManifestResourceStream(CountriesPath) ?? throw new InvalidOperationException
 192
 1193            return JsonSerializer.Deserialize<IReadOnlyList<CountryInfo>>(stream, _jsonOptions) ?? [];
 1194        }
 195
 196        /// <inheritdoc />
 197        public IReadOnlyList<ParentalRating> GetParentalRatings()
 198        {
 199            // Use server default language for ratings
 200            // Fall back to empty list if there are no parental ratings for that language
 2201            var ratings = GetParentalRatingsDictionary()?.Select(x => new ParentalRating(x.Key, x.Value)).ToList() ?? []
 202
 203            // Add common ratings to ensure them being available for selection
 204            // Based on the US rating system due to it being the main source of rating in the metadata providers
 205            // Unrated
 2206            if (!ratings.Any(x => x is null))
 207            {
 2208                ratings.Add(new("Unrated", null));
 209            }
 210
 211            // Minimum rating possible
 2212            if (ratings.All(x => x.RatingScore?.Score != 0))
 213            {
 0214                ratings.Add(new("Approved", new(0, null)));
 215            }
 216
 217            // Matches PG (this has different age restrictions depending on country)
 2218            if (ratings.All(x => x.RatingScore?.Score != 10))
 219            {
 1220                ratings.Add(new("10", new(10, null)));
 221            }
 222
 223            // Matches PG-13
 2224            if (ratings.All(x => x.RatingScore?.Score != 13))
 225            {
 1226                ratings.Add(new("13", new(13, null)));
 227            }
 228
 229            // Matches TV-14
 2230            if (ratings.All(x => x.RatingScore?.Score != 14))
 231            {
 1232                ratings.Add(new("14", new(14, null)));
 233            }
 234
 235            // Catchall if max rating of country is less than 21
 236            // Using 21 instead of 18 to be sure to allow access to all rated content except adult and banned
 2237            if (!ratings.Any(x => x.RatingScore?.Score >= 21))
 238            {
 2239                ratings.Add(new ParentalRating("21", new(21, null)));
 240            }
 241
 242            // A lot of countries don't explicitly have a separate rating for adult content
 2243            if (ratings.All(x => x.RatingScore?.Score != 1000))
 244            {
 2245                ratings.Add(new ParentalRating("XXX",  new(1000, null)));
 246            }
 247
 248            // A lot of countries don't explicitly have a separate rating for banned content
 2249            if (ratings.All(x => x.RatingScore?.Score != 1001))
 250            {
 2251                ratings.Add(new ParentalRating("Banned",  new(1001, null)));
 252            }
 253
 2254            return [.. ratings.OrderBy(r => r.RatingScore?.Score).ThenBy(r => r.RatingScore?.SubScore)];
 255        }
 256
 257        /// <summary>
 258        /// Gets the parental ratings dictionary.
 259        /// </summary>
 260        /// <param name="countryCode">The optional two letter ISO language string.</param>
 261        /// <returns><see cref="Dictionary{String, ParentalRatingScore}" />.</returns>
 262        private Dictionary<string, ParentalRatingScore?>? GetParentalRatingsDictionary(string? countryCode = null)
 263        {
 264            // Fallback to server default if no country code is specified.
 18265            if (string.IsNullOrEmpty(countryCode))
 266            {
 16267                countryCode = _configurationManager.Configuration.MetadataCountryCode;
 268            }
 269
 18270            if (_allParentalRatings.TryGetValue(countryCode, out var countryValue))
 271            {
 17272                return countryValue;
 273            }
 274
 1275            return null;
 276        }
 277
 278        /// <inheritdoc />
 279        public ParentalRatingScore? GetRatingScore(string rating, string? countryCode = null)
 280        {
 25281            ArgumentException.ThrowIfNullOrEmpty(rating);
 282
 283            // Handle unrated content
 25284            if (_unratedValues.Contains(rating.AsSpan(), StringComparison.OrdinalIgnoreCase))
 285            {
 4286                return null;
 287            }
 288
 289            // Convert ints directly
 290            // This may override some of the locale specific age ratings (but those always map to the same age)
 21291            if (int.TryParse(rating, out var ratingAge))
 292            {
 6293                return new(ratingAge, null);
 294            }
 295
 296            // Fairly common for some users to have "Rated R" in their rating field
 15297            rating = rating.Replace("Rated :", string.Empty, StringComparison.OrdinalIgnoreCase)
 15298                            .Replace("Rated:", string.Empty, StringComparison.OrdinalIgnoreCase)
 15299                            .Replace("Rated ", string.Empty, StringComparison.OrdinalIgnoreCase)
 15300                            .Trim();
 301
 302            // Use rating system matching the language
 15303            if (!string.IsNullOrEmpty(countryCode))
 304            {
 1305                var ratingsDictionary = GetParentalRatingsDictionary(countryCode);
 1306                if (ratingsDictionary is not null && ratingsDictionary.TryGetValue(rating, out ParentalRatingScore? valu
 307                {
 1308                    return value;
 309                }
 310            }
 311            else
 312            {
 313                // Fall back to server default language for ratings check
 314                // If it has no ratings, use the US ratings
 14315                var ratingsDictionary = GetParentalRatingsDictionary() ?? GetParentalRatingsDictionary("us");
 14316                if (ratingsDictionary is not null && ratingsDictionary.TryGetValue(rating, out ParentalRatingScore? valu
 317                {
 8318                    return value;
 319                }
 320            }
 321
 322            // If we don't find anything, check all ratings systems
 386323            foreach (var dictionary in _allParentalRatings.Values)
 324            {
 188325                if (dictionary.TryGetValue(rating, out var value))
 326                {
 2327                    return value;
 328                }
 329            }
 330
 331            // Try splitting by : to handle "Germany: FSK-18"
 4332            if (rating.Contains(':', StringComparison.OrdinalIgnoreCase))
 333            {
 2334                var ratingLevelRightPart = rating.AsSpan().RightPart(':');
 2335                if (ratingLevelRightPart.Length != 0)
 336                {
 1337                    return GetRatingScore(ratingLevelRightPart.ToString());
 338                }
 339            }
 340
 341            // Handle prefix country code to handle "DE-18"
 3342            if (rating.Contains('-', StringComparison.OrdinalIgnoreCase))
 343            {
 2344                var ratingSpan = rating.AsSpan();
 345
 346                // Extract culture from country prefix
 2347                var culture = FindLanguageInfo(ratingSpan.LeftPart('-').ToString());
 348
 2349                var ratingLevelRightPart = ratingSpan.RightPart('-');
 2350                if (ratingLevelRightPart.Length != 0)
 351                {
 352                    // Check rating system of culture
 1353                    return GetRatingScore(ratingLevelRightPart.ToString(), culture?.TwoLetterISOLanguageName);
 354                }
 355            }
 356
 2357            return null;
 2358        }
 359
 360        /// <inheritdoc />
 361        public string GetLocalizedString(string phrase)
 362        {
 544363            return GetLocalizedString(phrase, _configurationManager.Configuration.UICulture);
 364        }
 365
 366        /// <inheritdoc />
 367        public string GetLocalizedString(string phrase, string culture)
 368        {
 544369            if (string.IsNullOrEmpty(culture))
 370            {
 0371                culture = _configurationManager.Configuration.UICulture;
 372            }
 373
 544374            if (string.IsNullOrEmpty(culture))
 375            {
 0376                culture = DefaultCulture;
 377            }
 378
 544379            var dictionary = GetLocalizationDictionary(culture);
 380
 544381            if (dictionary.TryGetValue(phrase, out var value))
 382            {
 522383                return value;
 384            }
 385
 22386            return phrase;
 387        }
 388
 389        private Dictionary<string, string> GetLocalizationDictionary(string culture)
 390        {
 544391            ArgumentException.ThrowIfNullOrEmpty(culture);
 392
 393            const string Prefix = "Core";
 394
 544395            return _dictionaries.GetOrAdd(
 544396                culture,
 544397                static (key, localizationManager) => localizationManager.GetDictionary(Prefix, key, DefaultCulture + ".j
 544398                this);
 399        }
 400
 401        private async Task<Dictionary<string, string>> GetDictionary(string prefix, string culture, string baseFilename)
 402        {
 403            ArgumentException.ThrowIfNullOrEmpty(culture);
 404
 405            var dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
 406
 407            var namespaceName = GetType().Namespace + "." + prefix;
 408
 409            await CopyInto(dictionary, namespaceName + "." + baseFilename).ConfigureAwait(false);
 410            await CopyInto(dictionary, namespaceName + "." + GetResourceFilename(culture)).ConfigureAwait(false);
 411
 412            return dictionary;
 413        }
 414
 415        private async Task CopyInto(IDictionary<string, string> dictionary, string resourcePath)
 416        {
 417            using var stream = _assembly.GetManifestResourceStream(resourcePath);
 418            // If a Culture doesn't have a translation the stream will be null and it defaults to en-us further up the c
 419            if (stream is null)
 420            {
 421                _logger.LogError("Missing translation/culture resource: {ResourcePath}", resourcePath);
 422                return;
 423            }
 424
 425            var dict = await JsonSerializer.DeserializeAsync<Dictionary<string, string>>(stream, _jsonOptions).Configure
 426            foreach (var key in dict.Keys)
 427            {
 428                dictionary[key] = dict[key];
 429            }
 430        }
 431
 432        private static string GetResourceFilename(string culture)
 433        {
 25434            var parts = culture.Split('-');
 435
 25436            if (parts.Length == 2)
 437            {
 24438                culture = parts[0].ToLowerInvariant() + "-" + parts[1].ToUpperInvariant();
 439            }
 440            else
 441            {
 1442                culture = culture.ToLowerInvariant();
 443            }
 444
 25445            return culture + ".json";
 446        }
 447
 448        /// <inheritdoc />
 449        public IEnumerable<LocalizationOption> GetLocalizationOptions()
 450        {
 451            yield return new LocalizationOption("Afrikaans", "af");
 452            yield return new LocalizationOption("العربية", "ar");
 453            yield return new LocalizationOption("Беларуская", "be");
 454            yield return new LocalizationOption("Български", "bg-BG");
 455            yield return new LocalizationOption("বাংলা (বাংলাদেশ)", "bn");
 456            yield return new LocalizationOption("Català", "ca");
 457            yield return new LocalizationOption("Čeština", "cs");
 458            yield return new LocalizationOption("Cymraeg", "cy");
 459            yield return new LocalizationOption("Dansk", "da");
 460            yield return new LocalizationOption("Deutsch", "de");
 461            yield return new LocalizationOption("English (United Kingdom)", "en-GB");
 462            yield return new LocalizationOption("English", "en-US");
 463            yield return new LocalizationOption("Ελληνικά", "el");
 464            yield return new LocalizationOption("Esperanto", "eo");
 465            yield return new LocalizationOption("Español", "es");
 466            yield return new LocalizationOption("Español americano", "es_419");
 467            yield return new LocalizationOption("Español (Argentina)", "es-AR");
 468            yield return new LocalizationOption("Español (Dominicana)", "es_DO");
 469            yield return new LocalizationOption("Español (México)", "es-MX");
 470            yield return new LocalizationOption("Eesti", "et");
 471            yield return new LocalizationOption("Basque", "eu");
 472            yield return new LocalizationOption("فارسی", "fa");
 473            yield return new LocalizationOption("Suomi", "fi");
 474            yield return new LocalizationOption("Filipino", "fil");
 475            yield return new LocalizationOption("Français", "fr");
 476            yield return new LocalizationOption("Français (Canada)", "fr-CA");
 477            yield return new LocalizationOption("Galego", "gl");
 478            yield return new LocalizationOption("Schwiizerdütsch", "gsw");
 479            yield return new LocalizationOption("עִבְרִית", "he");
 480            yield return new LocalizationOption("हिन्दी", "hi");
 481            yield return new LocalizationOption("Hrvatski", "hr");
 482            yield return new LocalizationOption("Magyar", "hu");
 483            yield return new LocalizationOption("Bahasa Indonesia", "id");
 484            yield return new LocalizationOption("Íslenska", "is");
 485            yield return new LocalizationOption("Italiano", "it");
 486            yield return new LocalizationOption("日本語", "ja");
 487            yield return new LocalizationOption("Qazaqşa", "kk");
 488            yield return new LocalizationOption("한국어", "ko");
 489            yield return new LocalizationOption("Lietuvių", "lt");
 490            yield return new LocalizationOption("Latviešu", "lv");
 491            yield return new LocalizationOption("Македонски", "mk");
 492            yield return new LocalizationOption("മലയാളം", "ml");
 493            yield return new LocalizationOption("मराठी", "mr");
 494            yield return new LocalizationOption("Bahasa Melayu", "ms");
 495            yield return new LocalizationOption("Norsk bokmål", "nb");
 496            yield return new LocalizationOption("नेपाली", "ne");
 497            yield return new LocalizationOption("Nederlands", "nl");
 498            yield return new LocalizationOption("Norsk nynorsk", "nn");
 499            yield return new LocalizationOption("ਪੰਜਾਬੀ", "pa");
 500            yield return new LocalizationOption("Polski", "pl");
 501            yield return new LocalizationOption("Pirate", "pr");
 502            yield return new LocalizationOption("Português", "pt");
 503            yield return new LocalizationOption("Português (Brasil)", "pt-BR");
 504            yield return new LocalizationOption("Português (Portugal)", "pt-PT");
 505            yield return new LocalizationOption("Românește", "ro");
 506            yield return new LocalizationOption("Русский", "ru");
 507            yield return new LocalizationOption("Slovenčina", "sk");
 508            yield return new LocalizationOption("Slovenščina", "sl-SI");
 509            yield return new LocalizationOption("Shqip", "sq");
 510            yield return new LocalizationOption("Српски", "sr");
 511            yield return new LocalizationOption("Svenska", "sv");
 512            yield return new LocalizationOption("தமிழ்", "ta");
 513            yield return new LocalizationOption("తెలుగు", "te");
 514            yield return new LocalizationOption("ภาษาไทย", "th");
 515            yield return new LocalizationOption("Türkçe", "tr");
 516            yield return new LocalizationOption("Українська", "uk");
 517            yield return new LocalizationOption("اُردُو", "ur_PK");
 518            yield return new LocalizationOption("Tiếng Việt", "vi");
 519            yield return new LocalizationOption("汉语 (简体字)", "zh-CN");
 520            yield return new LocalizationOption("漢語 (繁體字)", "zh-TW");
 521            yield return new LocalizationOption("廣東話 (香港)", "zh-HK");
 522        }
 523
 524        /// <inheritdoc />
 525        public bool TryGetISO6392TFromB(string isoB, [NotNullWhen(true)] out string? isoT)
 526        {
 527            // Unlikely case the dictionary is not (yet) initialized properly
 3528            if (_iso6392BtoT is null)
 529            {
 0530                isoT = null;
 0531                return false;
 532            }
 533
 3534            var result = _iso6392BtoT.TryGetValue(isoB, out isoT) && !string.IsNullOrEmpty(isoT);
 535
 536            // Ensure the ISO code being null if the result is false
 3537            if (!result)
 538            {
 1539                isoT = null;
 540            }
 541
 3542            return result;
 543        }
 544    }
 545}
Generated by: ReportGenerator 5.4.11.0
8/25/2025 - 12:11:25 AM
GitHub | reportgenerator.io

Methods/Properties

.cctor()
.ctor(MediaBrowser.Controller.Configuration.IServerConfigurationManager,Microsoft.Extensions.Logging.ILogger`1<Emby.Server.Implementations.Localization.LocalizationManager>)
GetCultures()
FindLanguageInfo(System.String)
GetCountries()
GetParentalRatings()
GetParentalRatingsDictionary(System.String)
GetRatingScore(System.String,System.String)
GetLocalizedString(System.String)
GetLocalizedString(System.String,System.String)
GetLocalizationDictionary(System.String)
GetResourceFilename(System.String)
TryGetISO6392TFromB(System.String,System.String&)