Load events via Bonjour

Author: colemancda

Sources/CoreLock/EventsRequest.swift

@@ -43,7 +43,7 @@ public extension EventsNetServiceRequest {
     }
 }
 
-internal extension LockEvent.FetchRequest {
+public extension LockEvent.FetchRequest {
 
     init?(queryItems: [URLQueryItem]) {
         guard let offset = queryItems.first(.offset).flatMap(UInt8.init)

Sources/CoreLockWebServer/Events.swift

@@ -0,0 +1,68 @@
+//
+//  Events.swift
+//  CoreLockWebServer
+//
+//  Created by Alsey Coleman Miller on 10/22/19.
+//
+
+import Foundation
+import CoreLock
+import Kitura
+
+internal extension LockWebServer {
+    
+    func addEventsRoute() {
+        
+        router.get("/event") { [unowned self] (request, response, next) in
+            do {
+                if let statusCode = try self.getEvents(request: request, response: response) {
+                    _ = response.send(status: statusCode)
+                }
+            }
+            catch {
+                self.log?("\(request.urlURL.path) Internal server error. \(error.localizedDescription)")
+                dump(error)
+                _ = response.send(status: .internalServerError)
+            }
+            try response.end()
+        }
+    }
+    
+    private func getEvents(request: RouterRequest, response: RouterResponse) throws -> HTTPStatusCode? {
+        
+        // authenticate
+        guard let (key, secret) = try authenticate(request: request) else {
+            return .unauthorized
+        }
+        
+        log?("Key \(key.identifier) \(key.name) requested events list")
+        
+        var fetchRequest = LockEvent.FetchRequest()
+        
+        if let urlComponents = URLComponents(url: request.urlURL, resolvingAgainstBaseURL: true),
+            let queryItems = urlComponents.queryItems,
+            let queryFetchRequest = LockEvent.FetchRequest(queryItems: queryItems) {
+            var fetchDescription = ""
+            dump(fetchRequest, to: &fetchDescription)
+            log?(fetchDescription)
+            fetchRequest = queryFetchRequest
+        }
+        
+        // enforce permission, non-administrators can only view their own events.
+        if key.permission.isAdministrator == false {
+            var predicate = fetchRequest.predicate ?? .empty
+            predicate.keys = [key.identifier]
+            fetchRequest.predicate = predicate
+        }
+        
+        // execute fetch
+        let list = try events.fetch(fetchRequest)
+        
+        // encrypt
+        let eventsResponse = try EventsResponse(encrypt: list, with: secret, encoder: jsonEncoder)
+        
+        // respond
+        response.send(eventsResponse)
+        return nil
+    }
+}

Sources/CoreLockWebServer/Permissions.swift

@@ -8,7 +8,6 @@
 import Foundation
 import CoreLock
 import Kitura
-import KituraNet
 
 internal extension LockWebServer {
 

Sources/CoreLockWebServer/Server.swift

@@ -60,6 +60,7 @@ public final class LockWebServer {
 
         addLockInformationRoute()
         addPermissionsRoute()
+        addEventsRoute()
         addUpdateRoute()
     }
 

iOS/LockKit/Controller/LockEventsViewController.swift

@@ -167,42 +167,46 @@ public final class LockEventsViewController: TableViewController {
         let locks = self.locks
         let context = Store.shared.backgroundContext
 
-        if Store.shared.lockManager.central.state == .poweredOn {
-            performActivity(queue: .bluetooth, { [weak self] in
-                for lock in locks {
-                    guard let device = try Store.shared.device(for: lock, scanDuration: 1.0) else {
-                        if self?.lock == nil {
-                            continue
-                        } else {
-                            throw CentralError.unknownPeripheral
-                        }
-                    }
-                    let lastEventDate = try context.performErrorBlockAndWait {
-                        try context.find(identifier: lock, type: LockManagedObject.self)
-                            .flatMap { try $0.lastEvent(in: context)?.date }
-                    }
-                    let fetchRequest = FetchRequest(
-                        offset: 0,
-                        limit: nil,
-                        predicate: Predicate(
-                            keys: nil,
-                            start: lastEventDate,
-                            end: nil
-                        )
+        performActivity(queue: .app, { [weak self] in
+            guard let self = self else { return }
+            let expectsLock = self.lock != nil
+            for lock in locks {
+                
+                // fetch request
+                let lastEventDate = try context.performErrorBlockAndWait {
+                    try context.find(identifier: lock, type: LockManagedObject.self)
+                        .flatMap { try $0.lastEvent(in: context)?.date }
+                }
+                let fetchRequest = FetchRequest(
+                    offset: 0,
+                    limit: nil,
+                    predicate: Predicate(
+                        keys: nil,
+                        start: lastEventDate,
+                        end: nil
                     )
-                    do { try Store.shared.listEvents(device, fetchRequest: fetchRequest) }
-                    catch {
-                        if self?.lock == nil {
-                            continue
-                        } else {
-                            throw error
-                        }
+                )
+                // first try via Bonjour
+                if let netService = try Store.shared.netServiceClient.discover(duration: 1.0, timeout: 10.0).first(where: { $0.identifier == lock }) {
+                    
+                    try Store.shared.listEvents(netService, fetchRequest: fetchRequest)
+                    
+                } else if Store.shared.lockManager.central.state == .poweredOn,
+                    let device = try DispatchQueue.bluetooth.sync(execute: { try Store.shared.device(for: lock, scanDuration: 2.0) }) {
+                    
+                    try DispatchQueue.bluetooth.sync {
+                        _ = try Store.shared.listEvents(device, fetchRequest: fetchRequest)
                     }
+                    
+                } else if expectsLock {
+                    throw LockError.notInRange(lock: lock)
+                } else {
+                    continue
                 }
-            }, completion: { (viewController, _) in
-                viewController.needsKeys.removeAll()
-            })
-        }
+            }
+        }, completion: { (viewController, _) in
+            viewController.needsKeys.removeAll()
+        })
     }
 
     private subscript (indexPath: IndexPath) -> EventManagedObject {

iOS/LockKit/Model/Store.swift

@@ -618,6 +618,59 @@ public extension Store {
     }
 }
 
+// MARK: - Bonjour Requests
+
+#if os(iOS)
+
+public extension Store {
+    
+    @discardableResult
+    func listEvents(_ lock: LockNetService,
+                    fetchRequest: LockEvent.FetchRequest? = nil) throws -> Bool {
+        
+        // get lock key
+        guard let lockCache = self[lock: lock.identifier],
+            let keyData = self[key: lockCache.key.identifier]
+            else { return false }
+        
+        let key = KeyCredentials(
+            identifier: lockCache.key.identifier,
+            secret: keyData
+        )
+        
+        let events = try netServiceClient.listEvents(
+            fetchRequest: fetchRequest,
+            for: lock,
+            with: key,
+            timeout: 30
+        )
+        
+        backgroundContext.commit { (context) in
+            try context.insert(events, for: lock.identifier)
+        }
+        
+        #if os(iOS)
+        if preferences.isCloudBackupEnabled {
+            DispatchQueue.cloud.async { [weak self] in
+                // upload to iCloud
+                do {
+                    for event in events {
+                        let value = LockEvent.Cloud(event: event, for: lock.identifier)
+                        try self?.cloud.upload(value)
+                    }
+                } catch {
+                    log("⚠️ Could not upload latest events to iCloud: \(error.localizedDescription)")
+                }
+            }
+        }
+        #endif
+        
+        return true
+    }
+}
+
+#endif
+
 // MARK: - CloudKit Operations
 
 #if os(iOS)