Merge commit '2266e38d691b345f49ae3c2cf9cc669c808b31d6'

submodules/TelegramCore/Sources/AccountManager.swift

@@ -170,6 +170,8 @@ private var declaredEncodables: Void = {
     declareEncodable(ValidationMessageAttribute.self, f: { ValidationMessageAttribute(decoder: $0) })
     declareEncodable(EmojiSearchQueryMessageAttribute.self, f: { EmojiSearchQueryMessageAttribute(decoder: $0) })
     declareEncodable(CachedPeerInvitationImporters.self, f: { CachedPeerInvitationImporters(decoder: $0) })
+    declareEncodable(CachedPeerExportedInvitations.self, f: { CachedPeerExportedInvitations(decoder: $0) })
+    declareEncodable(ExportedInvitation.self, f: { ExportedInvitation(decoder: $0) })
     
     return
 }()

submodules/TelegramCore/Sources/InvitationLinks.swift

@@ -6,53 +6,45 @@ import MtProtoKit
 
 import SyncCore
 
-public func ensuredExistingPeerExportedInvitation(account: Account, peerId: PeerId, revokeExisted: Bool = false) -> Signal<ExportedInvitation?, NoError> {
+public func revokePersistentPeerExportedInvitation(account: Account, peerId: PeerId) -> Signal<ExportedInvitation?, NoError> {
     return account.postbox.transaction { transaction -> Signal<ExportedInvitation?, NoError> in
         if let peer = transaction.getPeer(peerId), let inputPeer = apiInputPeer(peer) {
             let flags: Int32 = (1 << 2)
             if let _ = peer as? TelegramChannel {
-                if let cachedData = transaction.getPeerCachedData(peerId: peerId) as? CachedChannelData, cachedData.exportedInvitation != nil && !revokeExisted {
-                    return .single(cachedData.exportedInvitation)
-                } else {
-                    return account.network.request(Api.functions.messages.exportChatInvite(flags: flags, peer: inputPeer, expireDate: nil, usageLimit: nil))
-                    |> retryRequest
-                    |> mapToSignal { result -> Signal<ExportedInvitation?, NoError> in
-                        return account.postbox.transaction { transaction -> ExportedInvitation? in
-                            if let invitation = ExportedInvitation(apiExportedInvite: result) {
-                                transaction.updatePeerCachedData(peerIds: Set([peerId]), update: { _, current in
-                                    if let current = current as? CachedChannelData {
-                                        return current.withUpdatedExportedInvitation(invitation)
-                                    } else {
-                                        return CachedChannelData().withUpdatedExportedInvitation(invitation)
-                                    }
-                                })
-                                return invitation
-                            } else {
-                                return nil
-                            }
+                return account.network.request(Api.functions.messages.exportChatInvite(flags: flags, peer: inputPeer, expireDate: nil, usageLimit: nil))
+                |> retryRequest
+                |> mapToSignal { result -> Signal<ExportedInvitation?, NoError> in
+                    return account.postbox.transaction { transaction -> ExportedInvitation? in
+                        if let invitation = ExportedInvitation(apiExportedInvite: result) {
+                            transaction.updatePeerCachedData(peerIds: Set([peerId]), update: { _, current in
+                                if let current = current as? CachedChannelData {
+                                    return current.withUpdatedExportedInvitation(invitation)
+                                } else {
+                                    return CachedChannelData().withUpdatedExportedInvitation(invitation)
+                                }
+                            })
+                            return invitation
+                        } else {
+                            return nil
                         }
                     }
                 }
             } else if let _ = peer as? TelegramGroup {
-                if let cachedData = transaction.getPeerCachedData(peerId: peerId) as? CachedGroupData, cachedData.exportedInvitation != nil && !revokeExisted {
-                    return .complete()
-                } else {
-                    return account.network.request(Api.functions.messages.exportChatInvite(flags: flags, peer: inputPeer, expireDate: nil, usageLimit: nil))
-                    |> retryRequest
-                    |> mapToSignal { result -> Signal<ExportedInvitation?, NoError> in
-                        return account.postbox.transaction { transaction -> ExportedInvitation? in
-                            if let invitation = ExportedInvitation(apiExportedInvite: result) {
-                                transaction.updatePeerCachedData(peerIds: Set([peerId]), update: { _, current in
-                                    if let current = current as? CachedGroupData {
-                                        return current.withUpdatedExportedInvitation(invitation)
-                                    } else {
-                                        return current
-                                    }
-                                })
-                                return invitation
-                            } else {
-                                return nil
-                            }
+                return account.network.request(Api.functions.messages.exportChatInvite(flags: flags, peer: inputPeer, expireDate: nil, usageLimit: nil))
+                |> retryRequest
+                |> mapToSignal { result -> Signal<ExportedInvitation?, NoError> in
+                    return account.postbox.transaction { transaction -> ExportedInvitation? in
+                        if let invitation = ExportedInvitation(apiExportedInvite: result) {
+                            transaction.updatePeerCachedData(peerIds: Set([peerId]), update: { _, current in
+                                if let current = current as? CachedGroupData {
+                                    return current.withUpdatedExportedInvitation(invitation)
+                                } else {
+                                    return current
+                                }
+                            })
+                            return invitation
+                        } else {
+                            return nil
                         }
                     }
                 }
@@ -65,8 +57,12 @@ public func ensuredExistingPeerExportedInvitation(account: Account, peerId: Peer
     } |> switchToLatest
 }
 
-public func createPeerExportedInvitation(account: Account, peerId: PeerId, expireDate: Int32?, usageLimit: Int32?) -> Signal<ExportedInvitation?, NoError> {
-    return account.postbox.transaction { transaction -> Signal<ExportedInvitation?, NoError> in
+public enum CreatePeerExportedInvitationError {
+    case generic
+}
+
+public func createPeerExportedInvitation(account: Account, peerId: PeerId, expireDate: Int32?, usageLimit: Int32?) -> Signal<ExportedInvitation?, CreatePeerExportedInvitationError> {
+    return account.postbox.transaction { transaction -> Signal<ExportedInvitation?, CreatePeerExportedInvitationError> in
         if let peer = transaction.getPeer(peerId), let inputPeer = apiInputPeer(peer) {
             var flags: Int32 = 0
             if let _ = expireDate {
@@ -76,7 +72,7 @@ public func createPeerExportedInvitation(account: Account, peerId: PeerId, expir
                 flags |= (1 << 1)
             }
             return account.network.request(Api.functions.messages.exportChatInvite(flags: flags, peer: inputPeer, expireDate: expireDate, usageLimit: usageLimit))
-            |> retryRequest
+            |> mapError { _ in return CreatePeerExportedInvitationError.generic }
             |> map { result -> ExportedInvitation? in
                 if let invitation = ExportedInvitation(apiExportedInvite: result) {
                     return invitation
@@ -87,59 +83,9 @@ public func createPeerExportedInvitation(account: Account, peerId: PeerId, expir
         } else {
             return .complete()
         }
-    } |> switchToLatest
-}
-
-public struct ExportedInvitations : Equatable {
-    public let list: [ExportedInvitation]?
-    public let totalCount: Int32
-}
-
-public func peerExportedInvitations(account: Account, peerId: PeerId, revoked: Bool, offsetLink: String? = nil) -> Signal<ExportedInvitations?, NoError> {
-    return account.postbox.transaction { transaction -> Signal<ExportedInvitations?, NoError> in
-        if let peer = transaction.getPeer(peerId), let inputPeer = apiInputPeer(peer) {
-            var flags: Int32 = 0
-            if let _ = offsetLink {
-                flags |= (1 << 2)
-            }
-            if revoked {
-                flags |= (1 << 3)
-            }
-            return account.network.request(Api.functions.messages.getExportedChatInvites(flags: flags, peer: inputPeer, adminId: nil, offsetLink: offsetLink, limit: 50))
-            |> map(Optional.init)
-            |> `catch` { _ -> Signal<Api.messages.ExportedChatInvites?, NoError> in
-                return .single(nil)
-            }
-            |> mapToSignal { result -> Signal<ExportedInvitations?, NoError> in
-                return account.postbox.transaction { transaction -> ExportedInvitations? in
-                    if let result = result, case let .exportedChatInvites(count, apiInvites, users) = result {
-                        var peers: [Peer] = []
-                        var peersMap: [PeerId: Peer] = [:]
-                        for user in users {
-                            let telegramUser = TelegramUser(user: user)
-                            peers.append(telegramUser)
-                            peersMap[telegramUser.id] = telegramUser
-                        }
-                        updatePeers(transaction: transaction, peers: peers, update: { _, updated -> Peer in
-                            return updated
-                        })
-                        
-                        var invites: [ExportedInvitation] = []
-                        for apiInvite in apiInvites {
-                            if let invite = ExportedInvitation(apiExportedInvite: apiInvite) {
-                                invites.append(invite)
-                            }
-                        }
-                        return ExportedInvitations(list: invites, totalCount: count)
-                    } else {
-                        return nil
-                    }
-                }
-            }
-        } else {
-            return .single(nil)
-        }
-    } |> switchToLatest
+    }
+    |> castError(CreatePeerExportedInvitationError.self)
+    |> switchToLatest
 }
 
 public enum EditPeerExportedInvitationError {
@@ -218,6 +164,59 @@ public func revokePeerExportedInvitation(account: Account, peerId: PeerId, link:
     |> switchToLatest
 }
 
+public struct ExportedInvitations : Equatable {
+    public let list: [ExportedInvitation]?
+    public let totalCount: Int32
+}
+
+public func peerExportedInvitations(account: Account, peerId: PeerId, revoked: Bool, offsetLink: ExportedInvitation? = nil) -> Signal<ExportedInvitations?, NoError> {
+    return account.postbox.transaction { transaction -> Signal<ExportedInvitations?, NoError> in
+        if let peer = transaction.getPeer(peerId), let inputPeer = apiInputPeer(peer) {
+            var flags: Int32 = 0
+            if let _ = offsetLink {
+                flags |= (1 << 2)
+            }
+            if revoked {
+                flags |= (1 << 3)
+            }
+            return account.network.request(Api.functions.messages.getExportedChatInvites(flags: flags, peer: inputPeer, adminId: nil, offsetDate: offsetLink?.date, offsetLink: offsetLink?.link, limit: 50))
+            |> map(Optional.init)
+            |> `catch` { _ -> Signal<Api.messages.ExportedChatInvites?, NoError> in
+                return .single(nil)
+            }
+            |> mapToSignal { result -> Signal<ExportedInvitations?, NoError> in
+                return account.postbox.transaction { transaction -> ExportedInvitations? in
+                    if let result = result, case let .exportedChatInvites(count, apiInvites, users) = result {
+                        var peers: [Peer] = []
+                        var peersMap: [PeerId: Peer] = [:]
+                        for user in users {
+                            let telegramUser = TelegramUser(user: user)
+                            peers.append(telegramUser)
+                            peersMap[telegramUser.id] = telegramUser
+                        }
+                        updatePeers(transaction: transaction, peers: peers, update: { _, updated -> Peer in
+                            return updated
+                        })
+                        
+                        var invites: [ExportedInvitation] = []
+                        for apiInvite in apiInvites {
+                            if let invite = ExportedInvitation(apiExportedInvite: apiInvite) {
+                                invites.append(invite)
+                            }
+                        }
+                        return ExportedInvitations(list: invites, totalCount: count)
+                    } else {
+                        return nil
+                    }
+                }
+            }
+        } else {
+            return .single(nil)
+        }
+    } |> switchToLatest
+}
+
+
 public enum DeletePeerExportedInvitationError {
     case generic
 }
@@ -251,6 +250,320 @@ public func deleteAllRevokedPeerExportedInvitations(account: Account, peerId: Pe
     |> switchToLatest
 }
 
+private let cachedPeerExportedInvitationsCollectionSpec = ItemCacheCollectionSpec(lowWaterItemCount: 10, highWaterItemCount: 20)
+
+public struct PeerExportedInvitationsState: Equatable {
+    public var invitations: [ExportedInvitation]
+    public var isLoadingMore: Bool
+    public var hasLoadedOnce: Bool
+    public var canLoadMore: Bool
+    public var count: Int32
+}
+
+final class CachedPeerExportedInvitations: PostboxCoding {
+    let invitations: [ExportedInvitation]
+    let canLoadMore: Bool
+    let count: Int32
+    
+    public static func key(peerId: PeerId, revoked: Bool) -> ValueBoxKey {
+        let key = ValueBoxKey(length: 8 + 4)
+        key.setInt64(0, value: peerId.toInt64())
+        key.setInt32(8, value: revoked ? 1 : 0)
+        return key
+    }
+    
+    init(invitations: [ExportedInvitation], canLoadMore: Bool, count: Int32) {
+        self.invitations = invitations
+        self.canLoadMore = canLoadMore
+        self.count = count
+    }
+    
+    public init(decoder: PostboxDecoder) {
+        self.invitations = decoder.decodeObjectArrayForKey("invitations")
+        self.canLoadMore = decoder.decodeBoolForKey("canLoadMore", orElse: false)
+        self.count = decoder.decodeInt32ForKey("count", orElse: 0)
+    }
+    
+    public func encode(_ encoder: PostboxEncoder) {
+        encoder.encodeObjectArray(self.invitations, forKey: "invitations")
+        encoder.encodeBool(self.canLoadMore, forKey: "canLoadMore")
+        encoder.encodeInt32(self.count, forKey: "count")
+    }
+}
+
+private final class PeerExportedInvitationsContextImpl {
+    private let queue: Queue
+    private let account: Account
+    private let peerId: PeerId
+    private let revoked: Bool
+    private var forceUpdate: Bool
+    private let disposable = MetaDisposable()
+    private let updateDisposable = MetaDisposable()
+    private var isLoadingMore: Bool = false
+    private var hasLoadedOnce: Bool = false
+    private var canLoadMore: Bool = true
+    private var loadedFromCache: Bool = false
+    private var results: [ExportedInvitation] = []
+    private var count: Int32
+    private var populateCache: Bool = true
+    
+    let state = Promise<PeerExportedInvitationsState>()
+    
+    init(queue: Queue, account: Account, peerId: PeerId, revoked: Bool, forceUpdate: Bool) {
+        self.queue = queue
+        self.account = account
+        self.peerId = peerId
+        self.revoked = revoked
+        self.forceUpdate = forceUpdate
+        
+        self.count = 0
+        
+        self.isLoadingMore = true
+        self.disposable.set((account.postbox.transaction { transaction -> CachedPeerExportedInvitations? in
+            return transaction.retrieveItemCacheEntry(id: ItemCacheEntryId(collectionId: Namespaces.CachedItemCollection.cachedPeerExportedInvitations, key: CachedPeerExportedInvitations.key(peerId: peerId, revoked: revoked))) as? CachedPeerExportedInvitations
+        }
+        |> deliverOn(self.queue)).start(next: { [weak self] cachedResult in
+            guard let strongSelf = self else {
+                return
+            }
+            strongSelf.isLoadingMore = false
+            if let cachedResult = cachedResult {
+                strongSelf.results = cachedResult.invitations
+                strongSelf.count = cachedResult.count
+                strongSelf.hasLoadedOnce = true
+                strongSelf.canLoadMore = cachedResult.canLoadMore
+                strongSelf.loadedFromCache = true
+            }
+            strongSelf.loadMore()
+        }))
+                
+        self.loadMore()
+    }
+    
+    deinit {
+        self.disposable.dispose()
+        self.updateDisposable.dispose()
+    }
+    
+    func reload() {
+        self.forceUpdate = true
+        self.loadMore()
+    }
+    
+    func loadMore() {
+        if self.isLoadingMore {
+            return
+        }
+        self.isLoadingMore = true
+        let account = self.account
+        let peerId = self.peerId
+        let revoked = self.revoked
+        var lastResult = self.results.last
+        
+        if self.forceUpdate {
+            self.forceUpdate = false
+            lastResult = nil
+        }
+        if !self.forceUpdate && self.loadedFromCache {
+            self.populateCache = false
+            self.loadedFromCache = false
+        }
+        let populateCache = self.populateCache
+        
+        self.disposable.set((self.account.postbox.transaction { transaction -> Api.InputPeer? in
+            return transaction.getPeer(peerId).flatMap(apiInputPeer)
+        }
+        |> mapToSignal { inputPeer -> Signal<([ExportedInvitation], Int32), NoError> in
+            if let inputPeer = inputPeer {
+                let offsetLink = lastResult?.link
+                let offsetDate = lastResult?.date
+                var flags: Int32 = 0
+                if let _ = offsetLink {
+                    flags |= (1 << 2)
+                }
+                if revoked {
+                    flags |= (1 << 3)
+                }
+                let signal = account.network.request(Api.functions.messages.getExportedChatInvites(flags: flags, peer: inputPeer, adminId: nil, offsetDate: offsetDate, offsetLink: offsetLink, limit: lastResult == nil ? 50 : 100))
+                |> map(Optional.init)
+                |> `catch` { _ -> Signal<Api.messages.ExportedChatInvites?, NoError> in
+                    return .single(nil)
+                }
+                |> mapToSignal { result -> Signal<([ExportedInvitation], Int32), NoError> in
+                    return account.postbox.transaction { transaction -> ([ExportedInvitation], Int32) in
+                        guard let result = result else {
+                            return ([], 0)
+                        }
+                        switch result {
+                        case let .exportedChatInvites(count, invites, users):
+                            var peers: [Peer] = []
+                            for apiUser in users {
+                                peers.append(TelegramUser(user: apiUser))
+                            }
+                            updatePeers(transaction: transaction, peers: peers, update: { _, updated in
+                                return updated
+                            })
+                            let invitations: [ExportedInvitation] = invites.compactMap { ExportedInvitation(apiExportedInvite: $0) }
+                            if populateCache {
+                                transaction.putItemCacheEntry(id: ItemCacheEntryId(collectionId: Namespaces.CachedItemCollection.cachedPeerExportedInvitations, key: CachedPeerExportedInvitations.key(peerId: peerId, revoked: revoked)), entry: CachedPeerExportedInvitations(invitations: invitations, canLoadMore: count >= 50, count: count), collectionSpec: cachedPeerExportedInvitationsCollectionSpec)
+                            }
+                            return (invitations, count)
+                        }
+                    }
+                }
+                return signal
+            } else {
+                return .single(([], 0))
+            }
+        }
+        |> deliverOn(self.queue)).start(next: { [weak self] invitations, updatedCount in
+            guard let strongSelf = self else {
+                return
+            }
+            if strongSelf.populateCache {
+                strongSelf.populateCache = false
+                strongSelf.results.removeAll()
+            }
+            var existingLinks = Set(strongSelf.results.map { $0.link })
+            for invitation in invitations {
+                if !existingLinks.contains(invitation.link) {
+                    strongSelf.results.append(invitation)
+                    existingLinks.insert(invitation.link)
+                }
+            }
+            strongSelf.isLoadingMore = false
+            strongSelf.hasLoadedOnce = true
+            strongSelf.canLoadMore = !invitations.isEmpty
+            if strongSelf.canLoadMore {
+                strongSelf.count = max(updatedCount, Int32(strongSelf.results.count))
+            } else {
+                strongSelf.count = Int32(strongSelf.results.count)
+            }
+            strongSelf.updateState()
+            
+            if strongSelf.forceUpdate {
+                strongSelf.loadMore()
+            }
+        }))
+        self.updateState()
+    }
+    
+    public func add(_ invite: ExportedInvitation) {
+        var results = self.results
+        results.removeAll(where: { $0.link == invite.link})
+        results.insert(invite, at: 0)
+        self.results = results
+        self.updateState()
+        self.updateCache()
+    }
+    
+    public func update(_ invite: ExportedInvitation) {
+        var results = self.results
+        if let index = self.results.firstIndex(where: { $0.link == invite.link }) {
+            results[index] = invite
+        }
+        self.results = results
+        self.updateState()
+        self.updateCache()
+    }
+    
+    public func remove(_ invite: ExportedInvitation) {
+        var results = self.results
+        results.removeAll(where: { $0.link == invite.link})
+        self.results = results
+        self.updateState()
+        self.updateCache()
+    }
+    
+    public func clear() {
+        self.results = []
+        self.count = 0
+        self.updateState()
+        self.updateCache()
+    }
+    
+    private func updateCache() {
+        guard self.hasLoadedOnce && !self.isLoadingMore else {
+            return
+        }
+        
+        let peerId = self.peerId
+        let revoked = self.revoked
+        let invitations = Array(self.results.prefix(50))
+        let canLoadMore = self.canLoadMore
+        let count = self.count
+        self.updateDisposable.set(self.account.postbox.transaction({ transaction in
+            transaction.putItemCacheEntry(id: ItemCacheEntryId(collectionId: Namespaces.CachedItemCollection.cachedPeerExportedInvitations, key: CachedPeerExportedInvitations.key(peerId: peerId, revoked: revoked)), entry: CachedPeerExportedInvitations(invitations: invitations, canLoadMore: canLoadMore, count: count), collectionSpec: cachedPeerExportedInvitationsCollectionSpec)
+        }).start())
+    }
+    
+    private func updateState() {
+        self.state.set(.single(PeerExportedInvitationsState(invitations: self.results, isLoadingMore: self.isLoadingMore, hasLoadedOnce: self.hasLoadedOnce, canLoadMore: self.canLoadMore, count: self.count)))
+    }
+}
+
+public final class PeerExportedInvitationsContext {
+    private let queue: Queue = Queue()
+    private let impl: QueueLocalObject<PeerExportedInvitationsContextImpl>
+    
+    public var state: Signal<PeerExportedInvitationsState, NoError> {
+        return Signal { subscriber in
+            let disposable = MetaDisposable()
+            self.impl.with { impl in
+                disposable.set(impl.state.get().start(next: { value in
+                    subscriber.putNext(value)
+                }))
+            }
+            return disposable
+        }
+    }
+    
+    public init(account: Account, peerId: PeerId, revoked: Bool, forceUpdate: Bool) {
+        let queue = self.queue
+        self.impl = QueueLocalObject(queue: queue, generate: {
+            return PeerExportedInvitationsContextImpl(queue: queue, account: account, peerId: peerId, revoked: revoked, forceUpdate: forceUpdate)
+        })
+    }
+    
+    public func reload() {
+        self.impl.with { impl in
+            impl.reload()
+        }
+    }
+    
+    public func loadMore() {
+        self.impl.with { impl in
+            impl.loadMore()
+        }
+    }
+    
+    public func add(_ invite: ExportedInvitation) {
+        self.impl.with { impl in
+            impl.add(invite)
+        }
+    }
+    
+    public func update(_ invite: ExportedInvitation) {
+        self.impl.with { impl in
+            impl.update(invite)
+        }
+    }
+    
+    public func remove(_ invite: ExportedInvitation) {
+        self.impl.with { impl in
+            impl.remove(invite)
+        }
+    }
+    
+    public func clear() {
+        self.impl.with { impl in
+            impl.clear()
+        }
+    }
+}
+
+
+
 private let cachedPeerInvitationImportersCollectionSpec = ItemCacheCollectionSpec(lowWaterItemCount: 10, highWaterItemCount: 20)
 
 public struct PeerInvitationImportersState: Equatable {
@@ -262,7 +575,7 @@ public struct PeerInvitationImportersState: Equatable {
     public var isLoadingMore: Bool
     public var hasLoadedOnce: Bool
     public var canLoadMore: Bool
-    public var count: Int
+    public var count: Int32
 }
 
 final class CachedPeerInvitationImporters: PostboxCoding {
@@ -330,8 +643,9 @@ private final class PeerInvitationImportersContextImpl {
     private var isLoadingMore: Bool = false
     private var hasLoadedOnce: Bool = false
     private var canLoadMore: Bool = true
+    private var loadedFromCache = false
     private var results: [PeerInvitationImportersState.Importer] = []
-    private var count: Int
+    private var count: Int32
     private var populateCache: Bool = true
     
     let state = Promise<PeerInvitationImportersState>()
@@ -342,7 +656,7 @@ private final class PeerInvitationImportersContextImpl {
         self.peerId = peerId
         self.link = invite.link
         
-        let count = invite.count.flatMap { Int($0) } ?? 0
+        let count = invite.count ?? 0
         self.count = count
         
         self.isLoadingMore = true
@@ -371,6 +685,7 @@ private final class PeerInvitationImportersContextImpl {
                 strongSelf.results = cachedPeers
                 strongSelf.hasLoadedOnce = true
                 strongSelf.canLoadMore = canLoadMore
+                strongSelf.loadedFromCache = true
             }
             strongSelf.loadMore()
         }))
@@ -390,12 +705,18 @@ private final class PeerInvitationImportersContextImpl {
         let account = self.account
         let peerId = self.peerId
         let link = self.link
-        let lastResult = self.results.last
         let populateCache = self.populateCache
+        
+        var lastResult = self.results.last
+        if self.loadedFromCache {
+            self.loadedFromCache = false
+            lastResult = nil
+        }
+        
         self.disposable.set((self.account.postbox.transaction { transaction -> Api.InputPeer? in
             return transaction.getPeer(peerId).flatMap(apiInputPeer)
         }
-        |> mapToSignal { inputPeer -> Signal<([PeerInvitationImportersState.Importer], Int), NoError> in
+        |> mapToSignal { inputPeer -> Signal<([PeerInvitationImportersState.Importer], Int32), NoError> in
             if let inputPeer = inputPeer {
                 let offsetUser = lastResult?.peer.peer.flatMap { apiInputUser($0) } ?? .inputUserEmpty
                 let offsetDate = lastResult?.date ?? 0
@@ -404,8 +725,8 @@ private final class PeerInvitationImportersContextImpl {
                 |> `catch` { _ -> Signal<Api.messages.ChatInviteImporters?, NoError> in
                     return .single(nil)
                 }
-                |> mapToSignal { result -> Signal<([PeerInvitationImportersState.Importer], Int), NoError> in
-                    return account.postbox.transaction { transaction -> ([PeerInvitationImportersState.Importer], Int) in
+                |> mapToSignal { result -> Signal<([PeerInvitationImportersState.Importer], Int32), NoError> in
+                    return account.postbox.transaction { transaction -> ([PeerInvitationImportersState.Importer], Int32) in
                         guard let result = result else {
                             return ([], 0)
                         }
@@ -434,7 +755,7 @@ private final class PeerInvitationImportersContextImpl {
                             if populateCache {
                                 transaction.putItemCacheEntry(id: ItemCacheEntryId(collectionId: Namespaces.CachedItemCollection.cachedPeerInvitationImporters, key: CachedPeerInvitationImporters.key(peerId: peerId, link: link)), entry: CachedPeerInvitationImporters(importers: resultImporters, count: count), collectionSpec: cachedPeerInvitationImportersCollectionSpec)
                             }
-                            return (resultImporters, Int(count))
+                            return (resultImporters, count)
                         }
                     }
                 }
@@ -462,9 +783,9 @@ private final class PeerInvitationImportersContextImpl {
             strongSelf.hasLoadedOnce = true
             strongSelf.canLoadMore = !importers.isEmpty
             if strongSelf.canLoadMore {
-                strongSelf.count = max(updatedCount, strongSelf.results.count)
+                strongSelf.count = max(updatedCount, Int32(strongSelf.results.count))
             } else {
-                strongSelf.count = strongSelf.results.count
+                strongSelf.count = Int32(strongSelf.results.count)
             }
             strongSelf.updateState()
         }))

submodules/TelegramCore/Sources/RequestUserPhotos.swift

@@ -14,6 +14,14 @@ public struct TelegramPeerPhoto {
     public let index: Int
     public let totalCount: Int
     public let messageId: MessageId?
+    public init(image: TelegramMediaImage, reference: TelegramMediaImageReference?, date: Int32, index: Int, totalCount: Int, messageId: MessageId?) {
+        self.image = image
+        self.reference = reference
+        self.date = date
+        self.index = index
+        self.totalCount = totalCount
+        self.messageId = messageId
+    }
 }
 
 public func requestPeerPhotos(postbox: Postbox, network: Network, peerId: PeerId) -> Signal<[TelegramPeerPhoto], NoError> {

submodules/TelegramCore/Sources/SearchStickers.swift

@@ -5,6 +5,26 @@ import SwiftSignalKit
 
 import SyncCore
 
+private struct SearchStickersConfiguration {
+    static var defaultValue: SearchStickersConfiguration {
+        return SearchStickersConfiguration(cacheTimeout: 86400)
+    }
+    
+    public let cacheTimeout: Int32
+    
+    fileprivate init(cacheTimeout: Int32) {
+        self.cacheTimeout = cacheTimeout
+    }
+    
+    static func with(appConfiguration: AppConfiguration) -> SearchStickersConfiguration {
+        if let data = appConfiguration.data, let value = data["stickers_emoji_cache_time"] as? Int32 {
+            return SearchStickersConfiguration(cacheTimeout: value)
+        } else {
+            return .defaultValue
+        }
+    }
+}
+
 public final class FoundStickerItem: Equatable {
     public let file: TelegramMediaFile
     public let stringRepresentations: [String]
@@ -140,7 +160,15 @@ public func searchStickers(account: Account, query: String, scope: SearchSticker
             result.append(contentsOf: installedItems)
         }
         
-        let cached = transaction.retrieveItemCacheEntry(id: ItemCacheEntryId(collectionId: Namespaces.CachedItemCollection.cachedStickerQueryResults, key: CachedStickerQueryResult.cacheKey(query))) as? CachedStickerQueryResult
+        var cached = transaction.retrieveItemCacheEntry(id: ItemCacheEntryId(collectionId: Namespaces.CachedItemCollection.cachedStickerQueryResults, key: CachedStickerQueryResult.cacheKey(query))) as? CachedStickerQueryResult
+        
+        let currentTime = Int32(CFAbsoluteTimeGetCurrent() + kCFAbsoluteTimeIntervalSince1970)
+        let appConfiguration: AppConfiguration = transaction.getPreferencesEntry(key: PreferencesKeys.appConfiguration) as? AppConfiguration ?? AppConfiguration.defaultValue
+        let searchStickersConfiguration = SearchStickersConfiguration.with(appConfiguration: appConfiguration)
+        
+        if let currentCached = cached, currentTime > currentCached.timestamp + searchStickersConfiguration.cacheTimeout {
+            cached = nil
+        }
         
         return (result, cached)
     } |> mapToSignal { localItems, cached -> Signal<[FoundStickerItem], NoError> in
@@ -199,7 +227,8 @@ public func searchStickers(account: Account, query: String, scope: SearchSticker
                         result.append(contentsOf: animatedItems)
                         result.append(contentsOf: items)
                         
-                        transaction.putItemCacheEntry(id: ItemCacheEntryId(collectionId: Namespaces.CachedItemCollection.cachedStickerQueryResults, key: CachedStickerQueryResult.cacheKey(query)), entry: CachedStickerQueryResult(items: files, hash: hash), collectionSpec: collectionSpec)
+                        let currentTime = Int32(CFAbsoluteTimeGetCurrent() + kCFAbsoluteTimeIntervalSince1970)
+                        transaction.putItemCacheEntry(id: ItemCacheEntryId(collectionId: Namespaces.CachedItemCollection.cachedStickerQueryResults, key: CachedStickerQueryResult.cacheKey(query)), entry: CachedStickerQueryResult(items: files, hash: hash, timestamp: currentTime), collectionSpec: collectionSpec)
                     
                         return result
                     case .stickersNotModified:

submodules/TelegramCore/Sources/Suggestions.swift

@@ -6,6 +6,7 @@ import SyncCore
 
 public enum ServerProvidedSuggestion: String {
     case autoarchivePopular = "AUTOARCHIVE_POPULAR"
+    case newcomerTicks = "NEWCOMER_TICKS"
 }
 
 public func getServerProvidedSuggestions(postbox: Postbox) -> Signal<[ServerProvidedSuggestion], NoError> {
@@ -22,12 +23,7 @@ public func getServerProvidedSuggestions(postbox: Postbox) -> Signal<[ServerProv
             return []
         }
         return list.compactMap { item -> ServerProvidedSuggestion? in
-            switch item {
-            case "AUTOARCHIVE_POPULAR":
-                return .autoarchivePopular
-            default:
-                return nil
-            }
+            return ServerProvidedSuggestion(rawValue: item)
         }
     }
     |> distinctUntilChanged

submodules/TelegramCore/Sources/UpdateCachedPeerData.swift

@@ -205,10 +205,7 @@ func fetchAndUpdateCachedPeerData(accountPeerId: PeerId, peerId rawPeerId: PeerI
                                     
                                     let peerStatusSettings = PeerStatusSettings(apiSettings: userFull.settings)
                                     
-                                    var hasScheduledMessages = false
-                                    if (userFull.flags & 1 << 12) != 0 {
-                                        hasScheduledMessages = true
-                                    }
+                                    let hasScheduledMessages = (userFull.flags & 1 << 12) != 0
                                 
                                     return previous.withUpdatedAbout(userFull.about).withUpdatedBotInfo(botInfo).withUpdatedCommonGroupCount(userFull.commonChatsCount).withUpdatedIsBlocked(isBlocked).withUpdatedVoiceCallsAvailable(voiceCallsAvailable).withUpdatedVideoCallsAvailable(videoCallsAvailable).withUpdatedCallsPrivate(callsPrivate).withUpdatedCanPinMessages(canPinMessages).withUpdatedPeerStatusSettings(peerStatusSettings).withUpdatedPinnedMessageId(pinnedMessageId).withUpdatedHasScheduledMessages(hasScheduledMessages)
                             }
@@ -257,7 +254,7 @@ func fetchAndUpdateCachedPeerData(accountPeerId: PeerId, peerId rawPeerId: PeerI
                                 
                                 let photo: TelegramMediaImage? = chatFull.chatPhoto.flatMap(telegramMediaImageFromApiPhoto)
                                 
-                                let exportedInvitation = chatFull.exportedInvite.flatMap(ExportedInvitation.init(apiExportedInvite:))
+                                let exportedInvitation = chatFull.exportedInvite.flatMap { ExportedInvitation(apiExportedInvite: $0) }
                                 let pinnedMessageId = chatFull.pinnedMsgId.flatMap({ MessageId(peerId: peerId, namespace: Namespaces.Message.Cloud, id: $0) })
                             
                                 var peers: [Peer] = []