Refactoring

submodules/TelegramCore/Sources/Settings/AutodownloadSettings.swift

@@ -0,0 +1,53 @@
+import Foundation
+import Postbox
+import TelegramApi
+import SwiftSignalKit
+
+import SyncCore
+
+public func updateAutodownloadSettingsInteractively(accountManager: AccountManager, _ f: @escaping (AutodownloadSettings) -> AutodownloadSettings) -> Signal<Void, NoError> {
+    return accountManager.transaction { transaction -> Void in
+        transaction.updateSharedData(SharedDataKeys.autodownloadSettings, { entry in
+            let currentSettings: AutodownloadSettings
+            if let entry = entry as? AutodownloadSettings {
+                currentSettings = entry
+            } else {
+                currentSettings = AutodownloadSettings.defaultSettings
+            }
+            return f(currentSettings)
+        })
+    }
+}
+
+extension AutodownloadPresetSettings {
+    init(apiAutodownloadSettings: Api.AutoDownloadSettings) {
+        switch apiAutodownloadSettings {
+        case let .autoDownloadSettings(flags, photoSizeMax, videoSizeMax, fileSizeMax, videoUploadMaxbitrate):
+                self.init(disabled: (flags & (1 << 0)) != 0, photoSizeMax: photoSizeMax, videoSizeMax: videoSizeMax, fileSizeMax: fileSizeMax, preloadLargeVideo: (flags & (1 << 1)) != 0, lessDataForPhoneCalls: (flags & (1 << 3)) != 0, videoUploadMaxbitrate: videoUploadMaxbitrate)
+        }
+    }
+}
+
+extension AutodownloadSettings {
+    init(apiAutodownloadSettings: Api.account.AutoDownloadSettings) {
+        switch apiAutodownloadSettings {
+            case let .autoDownloadSettings(low, medium, high):
+                self.init(lowPreset: AutodownloadPresetSettings(apiAutodownloadSettings: low), mediumPreset: AutodownloadPresetSettings(apiAutodownloadSettings: medium), highPreset: AutodownloadPresetSettings(apiAutodownloadSettings: high))
+        }
+    }
+}
+
+func apiAutodownloadPresetSettings(_ autodownloadPresetSettings: AutodownloadPresetSettings) -> Api.AutoDownloadSettings {
+    var flags: Int32 = 0
+    if autodownloadPresetSettings.disabled {
+        flags |= (1 << 0)
+    }
+    if autodownloadPresetSettings.preloadLargeVideo {
+        flags |= (1 << 1)
+    }
+    if autodownloadPresetSettings.lessDataForPhoneCalls {
+        flags |= (1 << 3)
+    }
+    return .autoDownloadSettings(flags: flags, photoSizeMax: autodownloadPresetSettings.photoSizeMax, videoSizeMax: autodownloadPresetSettings.videoSizeMax, fileSizeMax: autodownloadPresetSettings.fileSizeMax, videoUploadMaxbitrate: autodownloadPresetSettings.videoUploadMaxbitrate)
+}
+

submodules/TelegramCore/Sources/Settings/CacheStorageSettings.swift

@@ -0,0 +1,19 @@
+import Foundation
+import Postbox
+import SwiftSignalKit
+
+import SyncCore
+
+public func updateCacheStorageSettingsInteractively(accountManager: AccountManager, _ f: @escaping (CacheStorageSettings) -> CacheStorageSettings) -> Signal<Void, NoError> {
+    return accountManager.transaction { transaction -> Void in
+        transaction.updateSharedData(SharedDataKeys.cacheStorageSettings, { entry in
+            let currentSettings: CacheStorageSettings
+            if let entry = entry as? CacheStorageSettings {
+                currentSettings = entry
+            } else {
+                currentSettings = CacheStorageSettings.defaultSettings
+            }
+            return f(currentSettings)
+        })
+    }
+}

submodules/TelegramCore/Sources/Settings/GlobalNotificationSettings.swift

@@ -0,0 +1,20 @@
+import Foundation
+import Postbox
+import TelegramApi
+
+import SyncCore
+
+extension MessageNotificationSettings {
+    init(apiSettings: Api.PeerNotifySettings) {
+        switch apiSettings {
+            case let .peerNotifySettings(_, showPreviews, _, muteUntil, sound):
+                let displayPreviews: Bool
+                if let showPreviews = showPreviews, case .boolFalse = showPreviews {
+                    displayPreviews = false
+                } else {
+                    displayPreviews = true
+                }
+                self = MessageNotificationSettings(enabled: muteUntil == 0, displayPreviews: displayPreviews, sound: PeerMessageSound(apiSound: sound ?? "2"))
+        }
+    }
+}

submodules/TelegramCore/Sources/Settings/LoggingSettings.swift

@@ -0,0 +1,26 @@
+import Foundation
+import Postbox
+import SwiftSignalKit
+import MtProtoKit
+import SyncCore
+
+public func updateLoggingSettings(accountManager: AccountManager, _ f: @escaping (LoggingSettings) -> LoggingSettings) -> Signal<Void, NoError> {
+    return accountManager.transaction { transaction -> Void in
+        var updated: LoggingSettings?
+        transaction.updateSharedData(SharedDataKeys.loggingSettings, { current in
+            if let current = current as? LoggingSettings {
+                updated = f(current)
+                return updated
+            } else {
+                updated = f(LoggingSettings.defaultSettings)
+                return updated
+            }
+        })
+        
+        if let updated = updated {
+            Logger.shared.logToFile = updated.logToFile
+            Logger.shared.logToConsole = updated.logToConsole
+            Logger.shared.redactSensitiveData = updated.redactSensitiveData
+        }
+    }
+}

submodules/TelegramCore/Sources/Settings/NetworkSettings.swift

@@ -0,0 +1,41 @@
+import Foundation
+import Postbox
+import SwiftSignalKit
+import MtProtoKit
+
+import SyncCore
+
+public func updateNetworkSettingsInteractively(postbox: Postbox, network: Network, _ f: @escaping (NetworkSettings) -> NetworkSettings) -> Signal<Void, NoError> {
+    return postbox.transaction { transaction -> Void in
+        updateNetworkSettingsInteractively(transaction: transaction, network: network, f)
+    }
+}
+
+extension NetworkSettings {
+    var mtNetworkSettings: MTNetworkSettings {
+        return MTNetworkSettings(reducedBackupDiscoveryTimeout: self.reducedBackupDiscoveryTimeout)
+    }
+}
+
+public func updateNetworkSettingsInteractively(transaction: Transaction, network: Network?, _ f: @escaping (NetworkSettings) -> NetworkSettings) {
+    var updateNetwork = false
+    var updatedSettings: NetworkSettings?
+    transaction.updatePreferencesEntry(key: PreferencesKeys.networkSettings, { current in
+        let previous = (current as? NetworkSettings) ?? NetworkSettings.defaultSettings
+        let updated = f(previous)
+        updatedSettings = updated
+        if updated.reducedBackupDiscoveryTimeout != previous.reducedBackupDiscoveryTimeout {
+            updateNetwork = true
+        }
+        if updated.backupHostOverride != previous.backupHostOverride {
+            updateNetwork = true
+        }
+        return updated
+    })
+    
+    if let network = network, updateNetwork, let updatedSettings = updatedSettings {
+        network.context.updateApiEnvironment { current in
+            return current?.withUpdatedNetworkSettings(updatedSettings.mtNetworkSettings)
+        }
+    }
+}

submodules/TelegramCore/Sources/Settings/PeerContactSettings.swift

@@ -0,0 +1,69 @@
+import Foundation
+import Postbox
+import TelegramApi
+import SwiftSignalKit
+import SyncCore
+
+extension PeerStatusSettings {
+    init(apiSettings: Api.PeerSettings) {
+        switch apiSettings {
+            case let .peerSettings(flags, geoDistance):
+                var result = PeerStatusSettings.Flags()
+                if (flags & (1 << 1)) != 0 {
+                    result.insert(.canAddContact)
+                }
+                if (flags & (1 << 0)) != 0 {
+                    result.insert(.canReport)
+                }
+                if (flags & (1 << 2)) != 0 {
+                    result.insert(.canBlock)
+                }
+                if (flags & (1 << 3)) != 0 {
+                    result.insert(.canShareContact)
+                }
+                if (flags & (1 << 4)) != 0 {
+                    result.insert(.addExceptionWhenAddingContact)
+                }
+                if (flags & (1 << 5)) != 0 {
+                    result.insert(.canReportIrrelevantGeoLocation)
+                }
+                if (flags & (1 << 7)) != 0 {
+                    result.insert(.autoArchived)
+                }
+                if (flags & (1 << 8)) != 0 {
+                    result.insert(.suggestAddMembers)
+                }
+                self = PeerStatusSettings(flags: result, geoDistance: geoDistance)
+        }
+    }
+}
+
+public func unarchiveAutomaticallyArchivedPeer(account: Account, peerId: PeerId) {
+    let _ = (account.postbox.transaction { transaction -> Void in
+        updatePeerGroupIdInteractively(transaction: transaction, peerId: peerId, groupId: .root)
+        transaction.updatePeerCachedData(peerIds: Set([peerId]), update: { _, current in
+            if let currentData = current as? CachedUserData, let currentStatusSettings = currentData.peerStatusSettings {
+                var statusSettings = currentStatusSettings
+                statusSettings.flags.remove(.canBlock)
+                statusSettings.flags.remove(.canReport)
+                statusSettings.flags.remove(.autoArchived)
+                return currentData.withUpdatedPeerStatusSettings(statusSettings)
+            } else if let currentData = current as? CachedGroupData, let currentStatusSettings = currentData.peerStatusSettings {
+                var statusSettings = currentStatusSettings
+                statusSettings.flags.remove(.canReport)
+                statusSettings.flags.remove(.autoArchived)
+                return currentData.withUpdatedPeerStatusSettings(statusSettings)
+             } else if let currentData = current as? CachedChannelData, let currentStatusSettings = currentData.peerStatusSettings {
+                 var statusSettings = currentStatusSettings
+                 statusSettings.flags.remove(.canReport)
+                 statusSettings.flags.remove(.autoArchived)
+                 return currentData.withUpdatedPeerStatusSettings(statusSettings)
+             }else {
+                return current
+            }
+        })
+    }
+    |> deliverOnMainQueue).start()
+    
+    let _ = updatePeerMuteSetting(account: account, peerId: peerId, muteInterval: nil).start()
+}

submodules/TelegramCore/Sources/Settings/PrivacySettings.swift

@@ -0,0 +1,200 @@
+import Foundation
+import Postbox
+import TelegramApi
+
+import SyncCore
+
+public final class SelectivePrivacyPeer: Equatable {
+    public let peer: Peer
+    public let participantCount: Int32?
+    
+    public init(peer: Peer, participantCount: Int32?) {
+        self.peer = peer
+        self.participantCount = participantCount
+    }
+    
+    public static func ==(lhs: SelectivePrivacyPeer, rhs: SelectivePrivacyPeer) -> Bool {
+        if !lhs.peer.isEqual(rhs.peer) {
+            return false
+        }
+        if lhs.participantCount != rhs.participantCount {
+            return false
+        }
+        return true
+    }
+    
+    public var userCount: Int {
+        if let participantCount = self.participantCount {
+            return Int(participantCount)
+        } else if let group = self.peer as? TelegramGroup {
+            return group.participantCount
+        } else {
+            return 1
+        }
+    }
+}
+
+public enum SelectivePrivacySettings: Equatable {
+    case enableEveryone(disableFor: [PeerId: SelectivePrivacyPeer])
+    case enableContacts(enableFor: [PeerId: SelectivePrivacyPeer], disableFor: [PeerId: SelectivePrivacyPeer])
+    case disableEveryone(enableFor: [PeerId: SelectivePrivacyPeer])
+    
+    public static func ==(lhs: SelectivePrivacySettings, rhs: SelectivePrivacySettings) -> Bool {
+        switch lhs {
+            case let .enableEveryone(disableFor):
+                if case .enableEveryone(disableFor) = rhs {
+                    return true
+                } else {
+                    return false
+                }
+            case let .enableContacts(enableFor, disableFor):
+                if case .enableContacts(enableFor, disableFor) = rhs {
+                    return true
+                } else {
+                    return false
+                }
+            case let .disableEveryone(enableFor):
+                if case .disableEveryone(enableFor) = rhs {
+                    return true
+                } else {
+                    return false
+            }
+        }
+    }
+    
+    func withEnabledPeers(_ peers: [PeerId: SelectivePrivacyPeer]) -> SelectivePrivacySettings {
+        switch self {
+            case let .disableEveryone(enableFor):
+                return .disableEveryone(enableFor: enableFor.merging(peers, uniquingKeysWith: { lhs, rhs in lhs }))
+            case let .enableContacts(enableFor, disableFor):
+                return .enableContacts(enableFor: enableFor.merging(peers, uniquingKeysWith: { lhs, rhs in lhs }), disableFor: disableFor)
+            case .enableEveryone:
+                return self
+        }
+    }
+    
+    func withDisabledPeers(_ peers: [PeerId: SelectivePrivacyPeer]) -> SelectivePrivacySettings {
+        switch self {
+            case .disableEveryone:
+                return self
+            case let .enableContacts(enableFor, disableFor):
+                return .enableContacts(enableFor: enableFor, disableFor: disableFor.merging(peers, uniquingKeysWith: { lhs, rhs in lhs }))
+            case let .enableEveryone(disableFor):
+                return .enableEveryone(disableFor: disableFor.merging(peers, uniquingKeysWith: { lhs, rhs in lhs }))
+        }
+    }
+}
+
+public struct AccountPrivacySettings: Equatable {
+    public let presence: SelectivePrivacySettings
+    public let groupInvitations: SelectivePrivacySettings
+    public let voiceCalls: SelectivePrivacySettings
+    public let voiceCallsP2P: SelectivePrivacySettings
+    public let profilePhoto: SelectivePrivacySettings
+    public let forwards: SelectivePrivacySettings
+    public let phoneNumber: SelectivePrivacySettings
+    public let phoneDiscoveryEnabled: Bool
+    
+    public let automaticallyArchiveAndMuteNonContacts: Bool
+    public let accountRemovalTimeout: Int32
+    
+    public init(presence: SelectivePrivacySettings, groupInvitations: SelectivePrivacySettings, voiceCalls: SelectivePrivacySettings, voiceCallsP2P: SelectivePrivacySettings, profilePhoto: SelectivePrivacySettings, forwards: SelectivePrivacySettings, phoneNumber: SelectivePrivacySettings, phoneDiscoveryEnabled: Bool, automaticallyArchiveAndMuteNonContacts: Bool, accountRemovalTimeout: Int32) {
+        self.presence = presence
+        self.groupInvitations = groupInvitations
+        self.voiceCalls = voiceCalls
+        self.voiceCallsP2P = voiceCallsP2P
+        self.profilePhoto = profilePhoto
+        self.forwards = forwards
+        self.phoneNumber = phoneNumber
+        self.phoneDiscoveryEnabled = phoneDiscoveryEnabled
+        self.automaticallyArchiveAndMuteNonContacts = automaticallyArchiveAndMuteNonContacts
+        self.accountRemovalTimeout = accountRemovalTimeout
+    }
+    
+    public static func ==(lhs: AccountPrivacySettings, rhs: AccountPrivacySettings) -> Bool {
+        if lhs.presence != rhs.presence {
+            return false
+        }
+        if lhs.groupInvitations != rhs.groupInvitations {
+            return false
+        }
+        if lhs.voiceCalls != rhs.voiceCalls {
+            return false
+        }
+        if lhs.voiceCallsP2P != rhs.voiceCallsP2P {
+            return false
+        }
+        if lhs.profilePhoto != rhs.profilePhoto {
+            return false
+        }
+        if lhs.forwards != rhs.forwards {
+            return false
+        }
+        if lhs.phoneNumber != rhs.phoneNumber {
+            return false
+        }
+        if lhs.phoneDiscoveryEnabled != rhs.phoneDiscoveryEnabled {
+            return false
+        }
+        if lhs.automaticallyArchiveAndMuteNonContacts != rhs.automaticallyArchiveAndMuteNonContacts {
+            return false
+        }
+        if lhs.accountRemovalTimeout != rhs.accountRemovalTimeout {
+            return false
+        }
+        
+        return true
+    }
+}
+
+extension SelectivePrivacySettings {
+    init(apiRules: [Api.PrivacyRule], peers: [PeerId: SelectivePrivacyPeer]) {
+        var current: SelectivePrivacySettings = .disableEveryone(enableFor: [:])
+        
+        var disableFor: [PeerId: SelectivePrivacyPeer] = [:]
+        var enableFor: [PeerId: SelectivePrivacyPeer] = [:]
+        
+        for rule in apiRules {
+            switch rule {
+                case .privacyValueAllowAll:
+                    current = .enableEveryone(disableFor: [:])
+                case .privacyValueAllowContacts:
+                    current = .enableContacts(enableFor: [:], disableFor: [:])
+                case let .privacyValueAllowUsers(users):
+                    for id in users {
+                        if let peer = peers[PeerId(namespace: Namespaces.Peer.CloudUser, id: PeerId.Id._internalFromInt32Value(id))] {
+                            enableFor[peer.peer.id] = peer
+                        }
+                    }
+                case .privacyValueDisallowAll:
+                    break
+                case .privacyValueDisallowContacts:
+                    break
+                case let .privacyValueDisallowUsers(users):
+                    for id in users {
+                        if let peer = peers[PeerId(namespace: Namespaces.Peer.CloudUser, id: PeerId.Id._internalFromInt32Value(id))] {
+                            disableFor[peer.peer.id] = peer
+                        }
+                    }
+                case let .privacyValueAllowChatParticipants(chats):
+                    for id in chats {
+                        for possibleId in [PeerId(namespace: Namespaces.Peer.CloudGroup, id: PeerId.Id._internalFromInt32Value(id)), PeerId(namespace: Namespaces.Peer.CloudChannel, id: PeerId.Id._internalFromInt32Value(id))] {
+                            if let peer = peers[possibleId] {
+                                enableFor[peer.peer.id] = peer
+                            }
+                        }
+                    }
+                case let .privacyValueDisallowChatParticipants(chats):
+                    for id in chats {
+                        for possibleId in [PeerId(namespace: Namespaces.Peer.CloudGroup, id: PeerId.Id._internalFromInt32Value(id)), PeerId(namespace: Namespaces.Peer.CloudChannel, id: PeerId.Id._internalFromInt32Value(id))] {
+                            if let peer = peers[possibleId] {
+                                disableFor[peer.peer.id] = peer
+                            }
+                        }
+                    }
+            }
+        }
+        
+        self = current.withEnabledPeers(enableFor).withDisabledPeers(disableFor)
+    }
+}

submodules/TelegramCore/Sources/Settings/ProxySettings.swift

@@ -0,0 +1,33 @@
+import Foundation
+import Postbox
+import SwiftSignalKit
+import MtProtoKit
+import SyncCore
+
+public func updateProxySettingsInteractively(accountManager: AccountManager, _ f: @escaping (ProxySettings) -> ProxySettings) -> Signal<Bool, NoError> {
+    return accountManager.transaction { transaction -> Bool in
+        return updateProxySettingsInteractively(transaction: transaction, f)
+    }
+}
+
+extension ProxyServerSettings {
+    var mtProxySettings: MTSocksProxySettings {
+        switch self.connection {
+            case let .socks5(username, password):
+                return MTSocksProxySettings(ip: self.host, port: UInt16(clamping: self.port), username: username, password: password, secret: nil)
+            case let .mtp(secret):
+                return MTSocksProxySettings(ip: self.host, port: UInt16(clamping: self.port), username: nil, password: nil, secret: secret)
+        }
+    }
+}
+
+public func updateProxySettingsInteractively(transaction: AccountManagerModifier, _ f: @escaping (ProxySettings) -> ProxySettings) -> Bool {
+    var hasChanges = false
+    transaction.updateSharedData(SharedDataKeys.proxySettings, { current in
+        let previous = (current as? ProxySettings) ?? ProxySettings.defaultSettings
+        let updated = f(previous)
+        hasChanges = previous != updated
+        return updated
+    })
+    return hasChanges
+}