Adding Windows Display Names (#50)

Author: mattjohnsonpint

src/TimeZoneNames.DataBuilder/DataExtractor.cs

@@ -7,6 +7,7 @@
 using System.Xml.Linq;
 using System.Xml.XPath;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 using NodaTime;
 using NodaTime.TimeZones;
 
@@ -16,13 +17,15 @@ public class DataExtractor
     {
         private readonly string _cldrPath;
         private readonly string _nzdPath;
+        private readonly string _tzresPath;
 
         private readonly TimeZoneData _data = new TimeZoneData();
 
         private DataExtractor(string dataPath)
         {
             _cldrPath = Path.Combine(dataPath, "cldr") + "\\";
             _nzdPath = Path.Combine(dataPath, "nzd") + "\\";
+            _tzresPath = Path.Combine(dataPath, "tzres") + "\\";
         }
 
         public static DataExtractor Load(string dataPath, bool overwrite)
@@ -65,7 +68,8 @@ private void LoadData()
             {
                 LoadZoneCountries,
                 LoadZoneAliases,
-                LoadLanguages
+                LoadLanguages,
+                LoadDisplayNames
             };
             Task.WhenAll(actions.Select(Task.Run)).Wait();
 
@@ -78,7 +82,10 @@ private void LoadData()
 
         private void DownloadData(bool overwrite)
         {
-            Task.WaitAll(DownloadCldrAsync(overwrite), DownloadNzdAsync(overwrite));
+            Task.WaitAll(
+                DownloadCldrAsync(overwrite),
+                DownloadNzdAsync(overwrite),
+                DownloadTZResAsync(overwrite));
         }
 
         private async Task DownloadCldrAsync(bool overwrite)
@@ -101,6 +108,16 @@ private async Task DownloadNzdAsync(bool overwrite)
             }
         }
 
+        private async Task DownloadTZResAsync(bool overwrite)
+        {
+            var exists = Directory.Exists(_tzresPath);
+            if (overwrite || !exists)
+            {
+                if (exists) Directory.Delete(_tzresPath, true);
+                await Downloader.DownloadTZResAsync(_tzresPath);
+            }
+        }
+
         private void LoadZoneCountries()
         {
             foreach (var location in _tzdbSource.ZoneLocations.OrderBy(x => GetStandardOffset(x.ZoneId)).ThenBy(x => GetDaylightOffset(x.ZoneId)))
@@ -471,6 +488,21 @@ private static TimeZoneValues GetTimeZoneValues(XContainer element)
             return values;
         }
 
+        private void LoadDisplayNames()
+        {
+            using (var textReader = File.OpenText(_tzresPath + "tzinfo.json"))
+            using (var jsonReader = new JsonTextReader(textReader))
+            {
+                var data = JObject.Load(jsonReader);
+                foreach (var item in data["Languages"])
+                {
+                    var locale = item.Value<string>("Locale").Replace("-", "_");
+                    var timeZones = item["TimeZones"].ToObject<Dictionary<string, string>>();
+                    _data.DisplayNames.Add(locale, timeZones);
+                }
+            }
+        }
+
         private void PatchData()
         {
             //// Fixup Abbreviations

src/TimeZoneNames.DataBuilder/Downloader.cs

@@ -30,6 +30,12 @@ public static async Task DownloadNzdAsync(string dir)
             }
         }
 
+        public static async Task DownloadTZResAsync(string dir)
+        {
+            const string url = "https://raw.githubusercontent.com/tomkludy/TimeZoneWindowsResourceExtractor/master/TZResScraper/tzinfo.json";
+            await DownloadAsync(url, dir);
+        }
+
         private static async Task DownloadAsync(string url, string dir)
         {
             if (!Directory.Exists(dir))

src/TimeZoneNames/TZNames.cs

@@ -91,7 +91,7 @@ public static IDictionary<string, string> GetTimeZonesForCountry(string countryC
                     Id = x,
                     Name = GetNames(x, langKey, false).Generic
                 })
-                .ToDictionary(x => x.Id, x => x.Name);
+                .ToDictionary(x => x.Id, x => x.Name, StringComparer.OrdinalIgnoreCase);
 
             // Append city names only when needed to differentiate zones with the same name
             foreach (var group in results.GroupBy(x => x.Value).Where(x => x.Count() > 1).ToArray())
@@ -161,7 +161,7 @@ private static IDictionary<string, string> GetFixedTimeZoneNames(string language
                     Id = x,
                     Name = GetNames(x, langKey, abbreviations).Generic
                 })
-                .ToDictionary(x => x.Id, x => x.Name);
+                .ToDictionary(x => x.Id, x => x.Name, StringComparer.OrdinalIgnoreCase);
 
             return results;
         }
@@ -229,9 +229,61 @@ public static IDictionary<string, string> GetCountryNames(string languageCode)
             }
 
             return results.OrderBy(x => x.Value, comparer)
-                .ToDictionary(x => x.Key, x => x.Value);
+                .ToDictionary(x => x.Key, x => x.Value, StringComparer.OrdinalIgnoreCase);
         }
 
+        /// <summary>
+        /// Gets the localized names for a given IANA or Windows time zone identifier.
+        /// </summary>
+        /// <param name="timeZoneId">An IANA or Windows time zone identifier.</param>
+        /// <param name="languageCode">The IETF language tag (culture code) to use when localizing the display names.</param>
+        /// <returns>A display name associated with this time zone.</returns>
+        public static string GetDisplayNameForTimeZone(string timeZoneId, string languageCode)
+        {
+            var langKey = GetLanguageKey(languageCode, true);
+            if (langKey == null)
+                throw new ArgumentException("Invalid Language Code", nameof(languageCode));
+
+            var displayNames = Data.DisplayNames[langKey];
+
+            if (displayNames.TryGetValue(timeZoneId, out var displayName))
+                return displayName;
+
+            timeZoneId = TZConvert.IanaToWindows(timeZoneId);
+            if (displayNames.TryGetValue(timeZoneId, out displayName))
+                return displayName;
+
+            return null;
+        }
+
+        /// <summary>
+        /// Get display names suitable for use in a single drop-down list to select a time zone.
+        /// </summary>
+        /// <param name="languageCode">The IETF language tag (culture code) to use when localizing the display names.</param>
+        /// <param name="useIanaZoneIds"><c>true</c> to use IANA time zone keys, otherwise uses Windows time zone keys.</param>
+        /// <returns>A dictionary where the key is the time zone id, and the name is the localized display name.</returns>
+        public static IDictionary<string, string> GetDisplayNames(string languageCode, bool useIanaZoneIds = false)
+        {
+            var langKey = GetLanguageKey(languageCode, true);
+            if (langKey == null)
+                throw new ArgumentException("Invalid Language Code", nameof(languageCode));
+
+            var displayNames = Data.DisplayNames[langKey];
+
+            if (!useIanaZoneIds)
+                return displayNames;
+
+            // Remove obsolete zones before mapping
+            displayNames.Remove("Mid-Atlantic Standard Time");
+            displayNames.Remove("Kamchatka Standard Time");
+
+            var languageCodeParts = languageCode.Split('_', '-');
+            var territoryCode = languageCodeParts.Length < 2 ? "001" : languageCodeParts[1];
+            return displayNames.ToDictionary(x => TZConvert.WindowsToIana(x.Key, territoryCode), x => x.Value, StringComparer.OrdinalIgnoreCase);
+        }
+
+
+
         /// <summary>
         /// Gets a list of all language codes supported by this library.
         /// </summary>
@@ -277,15 +329,32 @@ private static IComparer<string> GetComparer(string langKey)
 #endif
         }
 
-        private static string GetLanguageKey(string languageCode)
+        private static string GetLanguageKey(string languageCode, bool forDisplayNames = false)
         {
             var key = languageCode.ToLowerInvariant().Replace('-', '_');
             while (true)
             {
-                if (Data.CldrLanguageData.ContainsKey(key))
-                    return key;
+                if (forDisplayNames)
+                {
+                    if (Data.DisplayNames.ContainsKey(key))
+                        return key;
+                }
+                else
+                {
+                    if (Data.CldrLanguageData.ContainsKey(key))
+                        return key;
+                }
 
                 key = GetLanguageSubkey(key);
+
+                if (key == null)
+                {
+                    var keys = forDisplayNames ? (IEnumerable<string>)Data.DisplayNames.Keys : Data.CldrLanguageData.Keys;
+                    key = keys.FirstOrDefault(x => x.Split('_')[0].Equals(languageCode, StringComparison.OrdinalIgnoreCase));
+
+                    if (key == null)
+                        throw new Exception("Could not find a language with code " + languageCode);
+                }
             }
         }
 

src/TimeZoneNames/TimeZoneData.cs

@@ -10,20 +10,22 @@ namespace TimeZoneNames
 {
     internal class TimeZoneData
     {
-        public Dictionary<string, string[]> TzdbZoneCountries { get; } = new Dictionary<string, string[]>();
+        public Dictionary<string, string[]> TzdbZoneCountries { get; } = new Dictionary<string, string[]>(StringComparer.OrdinalIgnoreCase);
 
-        public Dictionary<string, string[]> CldrZoneCountries { get; } = new Dictionary<string, string[]>();
+        public Dictionary<string, string[]> CldrZoneCountries { get; } = new Dictionary<string, string[]>(StringComparer.OrdinalIgnoreCase);
 
-        public Dictionary<string, string> CldrMetazones { get; } = new Dictionary<string, string>();
+        public Dictionary<string, string> CldrMetazones { get; } = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
 
-        public Dictionary<string, string> CldrPrimaryZones { get; } = new Dictionary<string, string>();
+        public Dictionary<string, string> CldrPrimaryZones { get; } = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
 
-        public Dictionary<string, string> CldrAliases { get; } = new Dictionary<string, string>();
+        public Dictionary<string, string> CldrAliases { get; } = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
 
-        public Dictionary<string, CldrLanguageData> CldrLanguageData { get; } = new Dictionary<string, CldrLanguageData>();
+        public Dictionary<string, CldrLanguageData> CldrLanguageData { get; } = new Dictionary<string, CldrLanguageData>(StringComparer.OrdinalIgnoreCase);
 
         public List<TimeZoneSelectionData> SelectionZones { get; } = new List<TimeZoneSelectionData>();
 
+        public Dictionary<string, Dictionary<string, string>> DisplayNames = new Dictionary<string, Dictionary<string, string>>(StringComparer.OrdinalIgnoreCase);
+
         [SecuritySafeCritical]
         public static TimeZoneData Load()
         {
@@ -49,13 +51,13 @@ internal class CldrLanguageData
 
         public string FallbackFormat { get; set; }
 
-        public Dictionary<string, TimeZoneValues> ShortNames { get; } = new Dictionary<string, TimeZoneValues>();
+        public Dictionary<string, TimeZoneValues> ShortNames { get; } = new Dictionary<string, TimeZoneValues>(StringComparer.OrdinalIgnoreCase);
 
-        public Dictionary<string, TimeZoneValues> LongNames { get; } = new Dictionary<string, TimeZoneValues>();
+        public Dictionary<string, TimeZoneValues> LongNames { get; } = new Dictionary<string, TimeZoneValues>(StringComparer.OrdinalIgnoreCase);
 
-        public Dictionary<string, string> CountryNames { get; } = new Dictionary<string, string>();
+        public Dictionary<string, string> CountryNames { get; } = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
 
-        public Dictionary<string, string> CityNames { get; } = new Dictionary<string, string>();
+        public Dictionary<string, string> CityNames { get; } = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
     }
 
     internal class TimeZoneSelectionData

src/TimeZoneNames/data.json.gz

@@ -0,0 +1,96 @@
+using System;
+using System.Globalization;
+using System.Linq;
+using TimeZoneConverter;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace TimeZoneNames.Tests
+{
+    public class DisplayNamesTests
+    {
+        private readonly ITestOutputHelper _output;
+
+        public DisplayNamesTests(ITestOutputHelper output)
+        {
+            _output = output;
+        }
+
+        [Fact]
+        public void Can_Get_DisplayNames_For_English()
+        {
+            var displayNames = TZNames.GetDisplayNames("en");
+
+            foreach (var item in displayNames)
+            {
+                _output.WriteLine($"{item.Key} = {item.Value}");
+            }
+
+            Assert.NotEmpty(displayNames);
+        }
+
+        [Fact]
+        public void Can_Get_DisplayNames_For_OS_Culture()
+        {
+            var languageCode = CultureInfo.InstalledUICulture.IetfLanguageTag;
+
+            var displayNames = TZNames.GetDisplayNames(languageCode);
+
+            var expected = TimeZoneInfo.GetSystemTimeZones().ToDictionary(x => x.Id, x => x.DisplayName);
+
+            Assert.Equal(expected, displayNames);
+        }
+
+        [Fact]
+        public void Can_Get_DisplayNames_For_French_Canada_With_Windows_Ids()
+        {
+            var displayNames = TZNames.GetDisplayNames("fr-CA");
+
+            var pacific = displayNames["Pacific Standard Time"];
+            var mountain = displayNames["Mountain Standard Time"];
+            var central = displayNames["Central Standard Time"];
+            var eastern = displayNames["Eastern Standard Time"];
+
+            Assert.Equal("(UTC-08:00) Pacifique (É.-U. et Canada)", pacific);
+            Assert.Equal("(UTC-07:00) Montagnes Rocheuses (É.-U. et Canada)", mountain);
+            Assert.Equal("(UTC-06:00) Centre (É.-U. et Canada)", central);
+            Assert.Equal("(UTC-05:00) Est (É.-U. et Canada)", eastern);
+        }
+
+        [Fact]
+        public void Can_Get_DisplayNames_For_French_Canada_With_IANA_Ids()
+        {
+            var displayNames = TZNames.GetDisplayNames("fr-CA", true);
+
+            var pacific = displayNames["America/Vancouver"];
+            var mountain = displayNames["America/Edmonton"];
+            var central = displayNames["America/Winnipeg"];
+            var eastern = displayNames["America/Toronto"];
+
+            Assert.Equal("(UTC-08:00) Pacifique (É.-U. et Canada)", pacific);
+            Assert.Equal("(UTC-07:00) Montagnes Rocheuses (É.-U. et Canada)", mountain);
+            Assert.Equal("(UTC-06:00) Centre (É.-U. et Canada)", central);
+            Assert.Equal("(UTC-05:00) Est (É.-U. et Canada)", eastern);
+        }
+
+        [Fact]
+        public void Can_Get_DisplayName_For_Every_Windows_Zone()
+        {
+            foreach (var id in TZConvert.KnownWindowsTimeZoneIds)
+            {
+                var displayName = TZNames.GetDisplayNameForTimeZone(id, "en");
+                Assert.NotNull(displayName);
+            }
+        }
+
+        [Fact]
+        public void Can_Get_DisplayName_For_Every_IANA_Zone()
+        {
+            foreach (var id in TZConvert.KnownIanaTimeZoneNames)
+            {
+                var displayName = TZNames.GetDisplayNameForTimeZone(id, "en");
+                Assert.NotNull(displayName);
+            }
+        }
+    }
+}