Refactoring

submodules/TelegramCore/Sources/TelegramEngine/Localization/Countries.swift

@@ -0,0 +1,165 @@
+import Foundation
+import Postbox
+import SwiftSignalKit
+import TelegramApi
+
+import SyncCore
+
+public struct Country: PostboxCoding, Equatable {
+    public static func == (lhs: Country, rhs: Country) -> Bool {
+        return lhs.id == rhs.id && lhs.name == rhs.name && lhs.localizedName == rhs.localizedName && lhs.countryCodes == rhs.countryCodes && lhs.hidden == rhs.hidden
+    }
+    
+    public struct CountryCode: PostboxCoding, Equatable {
+        public let code: String
+        public let prefixes: [String]
+        public let patterns: [String]
+        
+        public init(code: String, prefixes: [String], patterns: [String]) {
+            self.code = code
+            self.prefixes = prefixes
+            self.patterns = patterns
+        }
+        
+        public init(decoder: PostboxDecoder) {
+            self.code = decoder.decodeStringForKey("c", orElse: "")
+            self.prefixes = decoder.decodeStringArrayForKey("pfx")
+            self.patterns = decoder.decodeStringArrayForKey("ptrn")
+        }
+        
+        public func encode(_ encoder: PostboxEncoder) {
+            encoder.encodeString(self.code, forKey: "c")
+            encoder.encodeStringArray(self.prefixes, forKey: "pfx")
+            encoder.encodeStringArray(self.patterns, forKey: "ptrn")
+        }
+    }
+    
+    public let id: String
+    public let name: String
+    public let localizedName: String?
+    public let countryCodes: [CountryCode]
+    public let hidden: Bool
+    
+    public init(id: String, name: String, localizedName: String?, countryCodes: [CountryCode], hidden: Bool) {
+        self.id = id
+        self.name = name
+        self.localizedName = localizedName
+        self.countryCodes = countryCodes
+        self.hidden = hidden
+    }
+    
+    public init(decoder: PostboxDecoder) {
+        self.id = decoder.decodeStringForKey("c", orElse: "")
+        self.name = decoder.decodeStringForKey("n", orElse: "")
+        self.localizedName = decoder.decodeOptionalStringForKey("ln")
+        self.countryCodes = decoder.decodeObjectArrayForKey("cc").map { $0 as! CountryCode }
+        self.hidden = decoder.decodeBoolForKey("h", orElse: false)
+    }
+    
+    public func encode(_ encoder: PostboxEncoder) {
+        encoder.encodeString(self.id, forKey: "c")
+        encoder.encodeString(self.name, forKey: "n")
+        if let localizedName = self.localizedName {
+            encoder.encodeString(localizedName, forKey: "ln")
+        } else {
+            encoder.encodeNil(forKey: "ln")
+        }
+        encoder.encodeObjectArray(self.countryCodes, forKey: "cc")
+        encoder.encodeBool(self.hidden, forKey: "h")
+    }
+}
+
+public final class CountriesList: PreferencesEntry, Equatable {
+    public let countries: [Country]
+    public let hash: Int32
+ 
+    public init(countries: [Country], hash: Int32) {
+        self.countries = countries
+        self.hash = hash
+    }
+    
+    public init(decoder: PostboxDecoder) {
+        self.countries = decoder.decodeObjectArrayForKey("c").map { $0 as! Country }
+        self.hash = decoder.decodeInt32ForKey("h", orElse: 0)
+    }
+    
+    public func encode(_ encoder: PostboxEncoder) {
+        encoder.encodeObjectArray(self.countries, forKey: "c")
+        encoder.encodeInt32(self.hash, forKey: "h")
+    }
+    
+    public func isEqual(to: PreferencesEntry) -> Bool {
+        if let to = to as? CountriesList {
+            return self == to
+        } else {
+            return false
+        }
+    }
+    
+    public static func ==(lhs: CountriesList, rhs: CountriesList) -> Bool {
+        return lhs.countries == rhs.countries && lhs.hash == rhs.hash
+    }
+}
+
+
+func _internal_getCountriesList(accountManager: AccountManager, network: Network, langCode: String?, forceUpdate: Bool = false) -> Signal<[Country], NoError> {
+    let fetch: ([Country]?, Int32?) -> Signal<[Country], NoError> = { current, hash in
+        return network.request(Api.functions.help.getCountriesList(langCode: langCode ?? "", hash: hash ?? 0))
+        |> retryRequest
+        |> mapToSignal { result -> Signal<[Country], NoError> in
+            switch result {
+                case let .countriesList(apiCountries, hash):
+                    let result = apiCountries.compactMap { Country(apiCountry: $0) }
+                    if result == current {
+                        return .complete()
+                    } else {
+                        let _ = accountManager.transaction { transaction in
+                            transaction.updateSharedData(SharedDataKeys.countriesList, { _ in
+                                return CountriesList(countries: result, hash: hash)
+                            })
+                        }.start()
+                        return .single(result)
+                    }
+                case .countriesListNotModified:
+                    return .complete()
+            }
+        }
+    }
+    
+    if forceUpdate {
+        return fetch(nil, nil)
+    } else {
+        return accountManager.sharedData(keys: [SharedDataKeys.countriesList])
+        |> take(1)
+        |> map { sharedData -> ([Country], Int32) in
+            if let countriesList = sharedData.entries[SharedDataKeys.countriesList] as? CountriesList {
+                return (countriesList.countries, countriesList.hash)
+            } else {
+                return ([], 0)
+            }
+        } |> mapToSignal { current, hash -> Signal<[Country], NoError> in
+            return .single(current)
+            |> then(fetch(current, hash))
+        }
+    }
+}
+
+extension Country.CountryCode {
+    init(apiCountryCode: Api.help.CountryCode) {
+        switch apiCountryCode {
+            case let .countryCode(_, countryCode, apiPrefixes, apiPatterns):
+                let prefixes: [String] = apiPrefixes.flatMap { $0 } ?? []
+                let patterns: [String] = apiPatterns.flatMap { $0 } ?? []
+                self.init(code: countryCode, prefixes: prefixes, patterns: patterns)
+        }
+    }
+}
+
+extension Country {
+    init(apiCountry: Api.help.Country) {
+        switch apiCountry {
+            case let .country(flags, iso2, defaultName, name, countryCodes):
+                self.init(id: iso2, name: defaultName, localizedName: name, countryCodes: countryCodes.map { Country.CountryCode(apiCountryCode: $0) }, hidden: (flags & 1 << 0) != 0)
+        }
+    }
+}

submodules/TelegramCore/Sources/TelegramEngine/Localization/TelegramEngineLocalization.swift

@@ -0,0 +1,30 @@
+import SwiftSignalKit
+import Postbox
+
+public extension TelegramEngine {
+    final class Localization {
+        private let account: Account
+
+        init(account: Account) {
+            self.account = account
+        }
+
+        public func getCountriesList(accountManager: AccountManager, langCode: String?, forceUpdate: Bool = false) -> Signal<[Country], NoError> {
+            return _internal_getCountriesList(accountManager: accountManager, network: self.account.network, langCode: langCode, forceUpdate: forceUpdate)
+        }
+    }
+}
+
+public extension TelegramEngineUnauthorized {
+    final class Localization {
+        private let account: UnauthorizedAccount
+
+        init(account: UnauthorizedAccount) {
+            self.account = account
+        }
+
+        public func getCountriesList(accountManager: AccountManager, langCode: String?, forceUpdate: Bool = false) -> Signal<[Country], NoError> {
+        	return _internal_getCountriesList(accountManager: accountManager, network: self.account.network, langCode: langCode, forceUpdate: forceUpdate)
+	    }
+    }
+}