Added new moderator polling.

Signal/src/Loki/LokiGroupChatPoller.swift

@@ -4,14 +4,14 @@ public final class LokiGroupChatPoller : NSObject {
     private let group: LokiGroupChat
     private var pollForNewMessagesTimer: Timer? = nil
     private var pollForDeletedMessagesTimer: Timer? = nil
-    private var pollForModerationPermissionTimer: Timer? = nil
+    private var pollForModeratorsTimer: Timer? = nil
     private var hasStarted = false
     private let userHexEncodedPublicKey = OWSIdentityManager.shared().identityKeyPair()!.hexEncodedPublicKey
     
     // MARK: Settings
     private let pollForNewMessagesInterval: TimeInterval = 4
     private let pollForDeletedMessagesInterval: TimeInterval = 20
-    private let pollForModerationPermissionInterval: TimeInterval = 10 * 60
+    private let pollForModeratorsInterval: TimeInterval = 10 * 60
     
     // MARK: Lifecycle
     @objc(initForGroup:)
@@ -24,18 +24,18 @@ public final class LokiGroupChatPoller : NSObject {
         if hasStarted { return }
         pollForNewMessagesTimer = Timer.scheduledTimer(withTimeInterval: pollForNewMessagesInterval, repeats: true) { [weak self] _ in self?.pollForNewMessages() }
         pollForDeletedMessagesTimer = Timer.scheduledTimer(withTimeInterval: pollForDeletedMessagesInterval, repeats: true) { [weak self] _ in self?.pollForDeletedMessages() }
-        pollForModerationPermissionTimer = Timer.scheduledTimer(withTimeInterval: pollForModerationPermissionInterval, repeats: true) { [weak self] _ in self?.pollForModerationPermission() }
+        pollForModeratorsTimer = Timer.scheduledTimer(withTimeInterval: pollForModeratorsInterval, repeats: true) { [weak self] _ in self?.pollForModerators() }
         // Perform initial updates
         pollForNewMessages()
         pollForDeletedMessages()
-        pollForModerationPermission()
+        pollForModerators()
         hasStarted = true
     }
     
     @objc public func stop() {
         pollForNewMessagesTimer?.invalidate()
         pollForDeletedMessagesTimer?.invalidate()
-        pollForModerationPermissionTimer?.invalidate()
+        pollForModeratorsTimer?.invalidate()
         hasStarted = false
     }
     
@@ -140,13 +140,7 @@ public final class LokiGroupChatPoller : NSObject {
         }
     }
     
-    private func pollForModerationPermission() {
-        let group = self.group
-        let _ = LokiGroupChatAPI.userHasModerationPermission(for: group.serverID, on: group.server).done { isModerator in
-            let storage = OWSPrimaryStorage.shared()
-            storage.dbReadWriteConnection.readWrite { transaction in
-                storage.setIsModerator(isModerator, for: UInt(group.serverID), on: group.server, in: transaction)
-            }
-        }
+    private func pollForModerators() {
+        let _ = LokiGroupChatAPI.getModerators(for: self.group.serverID, on: self.group.server)
     }
 }

SignalServiceKit/src/Loki/API/LokiGroupChatAPI.swift

@@ -13,6 +13,14 @@ public final class LokiGroupChatAPI : NSObject {
     @objc public static let publicChatMessageType = "network.loki.messenger.publicChat"
     @objc public static let publicChatServerID: UInt64 = 1
     
+    // Mark: Moderators
+    typealias ModeratorArray = Set<String>
+    typealias ChannelDictionary = [UInt64 : ModeratorArray]
+    typealias ServerMapping = [String : ChannelDictionary]
+    
+    // A mapping from server to channel to moderator
+    private static var moderators = ServerMapping()
+    
     // MARK: Convenience
     private static var userDisplayName: String {
         return SSKEnvironment.shared.contactsManager.displayName(forPhoneIdentifier: userHexEncodedPublicKey) ?? "Anonymous"
@@ -251,6 +259,32 @@ public final class LokiGroupChatAPI : NSObject {
         }
     }
     
+    public static func isUserModerator(user hexEncodedPublicString: String, for group: UInt64, on server: String) -> Bool {
+        return self.moderators[server]?[group]?.contains(hexEncodedPublicString) ?? false
+    }
+    
+    public static func getModerators(for group: UInt64, on server: String) -> Promise<Set<String>> {
+        let url = URL(string: "\(server)/loki/v1/channel/\(group)/get_moderators")!
+        let request = TSRequest(url: url)
+        return TSNetworkManager.shared().makePromise(request: request).map { $0.responseObject }.map { rawResponse in
+            guard let json = rawResponse as? JSON, let moderators = json["moderators"] as? [String] else {
+                print("[Loki] Couldn't parse moderators for group chat with ID: \(group) on server: \(server) from: \(rawResponse).")
+                throw Error.parsingFailed
+            }
+            
+            let moderatorSet = Set(moderators);
+            
+            // Update our cache
+            if (self.moderators.keys.contains(server)) {
+                self.moderators[server]![group] = moderatorSet
+            } else {
+                self.moderators[server] = [group : moderatorSet]
+            }
+            
+            return moderatorSet
+        }
+    }
+    
     // MARK: Public API (Obj-C)
     @objc(getMessagesForGroup:onServer:)
     public static func objc_getMessages(for group: UInt64, on server: String) -> AnyPromise {