no message

TelegramCore/ChannelAdminEventLogContext.swift

@@ -7,6 +7,7 @@
 #endif
 
 public struct ChannelAdminEventLogEntry: Comparable {
+    public let stableId: UInt32
     public let event: AdminLogEvent
     public let peers: [PeerId: Peer]
     
@@ -25,6 +26,60 @@ public enum ChannelAdminEventLogUpdateType {
     case load
 }
 
+public struct ChannelAdminEventLogFilter: Equatable {
+    public let query: String?
+    public let events: AdminLogEventsFlags
+    public let adminPeerIds: [PeerId]?
+    
+    public init(query: String? = nil, events: AdminLogEventsFlags = .all, adminPeerIds: [PeerId]? = nil) {
+        self.query = query
+        self.events = events
+        self.adminPeerIds = adminPeerIds
+    }
+    
+    public static func ==(lhs: ChannelAdminEventLogFilter, rhs: ChannelAdminEventLogFilter) -> Bool {
+        if lhs.query != rhs.query {
+            return false
+        }
+        if lhs.events != rhs.events {
+            return false
+        }
+        if let lhsAdminPeerIds = lhs.adminPeerIds, let rhsAdminPeerIds = rhs.adminPeerIds {
+            if lhsAdminPeerIds != rhsAdminPeerIds {
+                return false
+            }
+        } else if (lhs.adminPeerIds != nil) != (rhs.adminPeerIds != nil) {
+            return false
+        }
+        return true
+    }
+    
+    public var isEmpty: Bool {
+        if self.query != nil {
+            return false
+        }
+        if self.events != .all {
+            return false
+        }
+        if self.adminPeerIds != nil {
+            return false
+        }
+        return true
+    }
+    
+    public func withQuery(_ query: String?) -> ChannelAdminEventLogFilter {
+        return ChannelAdminEventLogFilter(query: query, events: self.events, adminPeerIds: self.adminPeerIds)
+    }
+    
+    public func withEvents(_ events: AdminLogEventsFlags) -> ChannelAdminEventLogFilter {
+        return ChannelAdminEventLogFilter(query: self.query, events: events, adminPeerIds: self.adminPeerIds)
+    }
+    
+    public func withAdminPeerIds(_ adminPeerIds: [PeerId]?) -> ChannelAdminEventLogFilter {
+        return ChannelAdminEventLogFilter(query: self.query, events: self.events, adminPeerIds: adminPeerIds)
+    }
+}
+
 public final class ChannelAdminEventLogContext {
     private let queue: Queue = Queue.mainQueue()
     
@@ -32,7 +87,12 @@ public final class ChannelAdminEventLogContext {
     private let network: Network
     private let peerId: PeerId
     
-    private var entries: [ChannelAdminEventLogEntry] = []
+    private var filter: ChannelAdminEventLogFilter = ChannelAdminEventLogFilter()
+    
+    private var nextStableId: UInt32 = 1
+    private var stableIds: [AdminLogEventId: UInt32] = [:]
+    
+    private var entries: ([ChannelAdminEventLogEntry], ChannelAdminEventLogFilter) = ([], ChannelAdminEventLogFilter())
     private var hasEarlier: Bool = true
     private var loadingMoreEarlier: Bool = false
     
@@ -54,10 +114,10 @@ public final class ChannelAdminEventLogContext {
         let queue = self.queue
         return Signal { [weak self] subscriber in
             if let strongSelf = self {
-                subscriber.putNext((strongSelf.entries, strongSelf.hasEarlier, .initial))
+                subscriber.putNext((strongSelf.entries.0, strongSelf.hasEarlier, .initial))
                 
                 let index = strongSelf.subscribers.add({ entries, hasEarlier, type in
-                    subscriber.putNext((strongSelf.entries, strongSelf.hasEarlier, type))
+                    subscriber.putNext((strongSelf.entries.0, strongSelf.hasEarlier, type))
                 })
                 
                 return ActionDisposable {
@@ -73,6 +133,20 @@ public final class ChannelAdminEventLogContext {
         } |> runOn(queue)
     }
     
+    public func setFilter(_ filter: ChannelAdminEventLogFilter) {
+        if self.filter != filter {
+            self.filter = filter
+            self.loadingMoreEarlier = false
+            self.hasEarlier = false
+            
+            for subscriber in self.subscribers.copyItems() {
+                subscriber(self.entries.0, self.hasEarlier, .load)
+            }
+            
+            self.loadMoreEntries()
+        }
+    }
+    
     public func loadMoreEntries() {
         assert(self.queue.isCurrent())
         
@@ -81,44 +155,60 @@ public final class ChannelAdminEventLogContext {
         }
         
         let maxId: AdminLogEventId
-        if let last = self.entries.last {
-            maxId = last.event.id
+        if self.entries.1 == self.filter, let first = self.entries.0.first {
+            maxId = first.event.id
         } else {
             maxId = AdminLogEventId.max
         }
         
         self.loadingMoreEarlier = true
-        self.loadMoreDisposable.set((channelAdminLogEvents(postbox: self.postbox, network: self.network, peerId: self.peerId, maxId: maxId, minId: AdminLogEventId.min, limit: 10, query: nil, filter: nil, admins: nil)
+        self.loadMoreDisposable.set((channelAdminLogEvents(postbox: self.postbox, network: self.network, peerId: self.peerId, maxId: maxId, minId: AdminLogEventId.min, limit: 100, query: self.filter.query, filter: self.filter.events, admins: self.filter.adminPeerIds)
         |> deliverOn(self.queue)).start(next: { [weak self] result in
             if let strongSelf = self {
                 var events = result.events.sorted()
-                if let first = strongSelf.entries.first {
-                    var clipIndex = events.count
-                    for i in (0 ..< events.count).reversed() {
-                        if events[i] >= first.event {
-                            clipIndex = i - 1
+                if strongSelf.entries.1 == strongSelf.filter {
+                    if let first = strongSelf.entries.0.first {
+                        var clipIndex = events.count
+                        for i in (0 ..< events.count).reversed() {
+                            if events[i] >= first.event {
+                                clipIndex = i - 1
+                            }
+                        }
+                        if clipIndex < events.count {
+                            events.removeSubrange(clipIndex ..< events.count)
                         }
                     }
-                    if clipIndex < events.count {
-                        events.removeSubrange(clipIndex ..< events.count)
+                    
+                    var entries: [ChannelAdminEventLogEntry] = events.map { event in
+                        return ChannelAdminEventLogEntry(stableId: strongSelf.stableIdForEventId(event.id), event: event, peers: result.peers)
                     }
+                    entries.append(contentsOf: strongSelf.entries.0)
+                    strongSelf.entries = (entries, strongSelf.filter)
+                } else {
+                    let entries: [ChannelAdminEventLogEntry] = events.map { event in
+                        return ChannelAdminEventLogEntry(stableId: strongSelf.stableIdForEventId(event.id), event: event, peers: result.peers)
+                    }
+                    strongSelf.entries = (entries, strongSelf.filter)
                 }
                 
                 strongSelf.hasEarlier = !events.isEmpty
-                
-                var entries: [ChannelAdminEventLogEntry] = events.map { event in
-                    return ChannelAdminEventLogEntry(event: event, peers: result.peers)
-                    
-                }
-                entries.append(contentsOf: strongSelf.entries)
-                strongSelf.entries = entries
-                
                 strongSelf.loadingMoreEarlier = false
                 
                 for subscriber in strongSelf.subscribers.copyItems() {
-                    subscriber(strongSelf.entries, strongSelf.hasEarlier, .load)
+                    subscriber(strongSelf.entries.0, strongSelf.hasEarlier, .load)
                 }
             }
         }))
     }
+    
+    private func stableIdForEventId(_ id: AdminLogEventId) -> UInt32 {
+        if let value = self.stableIds[id] {
+            return value
+        } else {
+            let value = self.nextStableId
+            self.nextStableId += 1
+            self.stableIds[id] = value
+            return value
+        }
+    }
 }