[WIP] Business

submodules/TelegramCore/Sources/TelegramEngine/Messages/TimeZones.swift

@@ -0,0 +1,106 @@
+import Foundation
+import Postbox
+import SwiftSignalKit
+import TelegramApi
+import MtProtoKit
+
+public final class TimeZoneList: Codable, Equatable {
+    public final class Item: Codable, Equatable {
+        public let id: String
+        public let title: String
+        public let utcOffset: Int32
+
+        public init(id: String, title: String, utcOffset: Int32) {
+            self.id = id
+            self.title = title
+            self.utcOffset = utcOffset
+        }
+
+        public static func ==(lhs: Item, rhs: Item) -> Bool {
+            if lhs === rhs {
+                return true
+            }
+            if lhs.id != rhs.id {
+                return false
+            }
+            if lhs.title != rhs.title {
+                return false
+            }
+            if lhs.utcOffset != rhs.utcOffset {
+                return false
+            }
+            return true
+        }
+    }
+
+    public let items: [Item]
+    public let hashValue: Int32
+
+    public init(items: [Item], hashValue: Int32) {
+        self.items = items
+        self.hashValue = hashValue
+    }
+
+    public static func ==(lhs: TimeZoneList, rhs: TimeZoneList) -> Bool {
+        if lhs === rhs {
+            return true
+        }
+        if lhs.items != rhs.items {
+            return false
+        }
+        if lhs.hashValue != rhs.hashValue {
+            return false
+        }
+        return true
+    }
+}
+
+func _internal_cachedTimeZoneList(account: Account) -> Signal<TimeZoneList?, NoError> {
+    let viewKey: PostboxViewKey = .preferences(keys: Set([PreferencesKeys.timezoneList()]))
+    return account.postbox.combinedView(keys: [viewKey])
+    |> map { views -> TimeZoneList? in
+        guard let view = views.views[viewKey] as? PreferencesView else {
+            return nil
+        }
+        guard let value = view.values[PreferencesKeys.timezoneList()]?.get(TimeZoneList.self) else {
+            return nil
+        }
+        return value
+    }
+}
+
+func _internal_keepCachedTimeZoneListUpdated(account: Account) -> Signal<Never, NoError> {
+    let updateSignal = _internal_cachedTimeZoneList(account: account)
+    |> take(1)
+    |> mapToSignal { list -> Signal<Never, NoError> in
+        return account.network.request(Api.functions.help.getTimezonesList(hash: list?.hashValue ?? 0))
+        |> map(Optional.init)
+        |> `catch` { _ -> Signal<Api.help.TimezonesList?, NoError> in
+            return .single(nil)
+        }
+        |> mapToSignal { result -> Signal<Never, NoError> in
+            guard let result else {
+                return .complete()
+            }
+            
+            return account.postbox.transaction { transaction in
+                switch result {
+                case let .timezonesList(timezones, hash):
+                    var items: [TimeZoneList.Item] = []
+                    for item in timezones {
+                        switch item {
+                        case let .timezone(id, name, utcOffset):
+                            items.append(TimeZoneList.Item(id: id, title: name, utcOffset: utcOffset))
+                        }
+                    }
+                    transaction.setPreferencesEntry(key: PreferencesKeys.timezoneList(), value: PreferencesEntry(TimeZoneList(items: items, hashValue: hash)))
+                case .timezonesListNotModified:
+                    break
+                }
+            }
+            |> ignoreValues
+        }
+    }
+    
+    return updateSignal
+}