Merge branch 'master' into feature/209-due-by-table-deltas-on-gallery

Author: krugerk

.github/workflows/fastlane-tests.yml

@@ -15,7 +15,7 @@ jobs:
     - uses: maxim-lobanov/setup-xcode@v1
       with:
         xcode-version: latest-stable
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v5
     - name: Use sample configuration
       run: cp BeeKit/Config.swift.sample BeeKit/Config.swift
     - name: Setup ruby and install gems

BeeKit/Managers/DataPointManager.swift

@@ -30,14 +30,14 @@ public actor DataPointManager {
         }
     }
 
-    private func updateDatapoint(goal : Goal, datapoint : DataPoint, datapointValue : NSNumber) async throws {
+    private func updateDatapoint(goal : Goal, datapoint : DataPoint, datapointValue : NSNumber, comment: String) async throws {
         let val = datapoint.value
-        if datapointValue == val {
+        if datapointValue == val && comment == datapoint.comment {
             return
         }
         let params = [
             "value": "\(datapointValue)",
-            "comment": "Auto-updated via Apple Health",
+            "comment": comment,
         ]
         let _ = try await requestManager.put(url: "api/v1/users/{username}/goals/\(goal.slug)/datapoints/\(datapoint.id).json", parameters: params)
     }
@@ -103,37 +103,52 @@ public actor DataPointManager {
         let datapoints = try await datapointsSince(goal: goal, daystamp: try! Daystamp(fromString: firstDaystamp.description))
         let realDatapoints = datapoints.filter{ !$0.isDummy && !$0.isInitial }
 
-        for newDataPoint in healthKitDataPoints {
-            try await self.updateToMatchDataPoint(goal: goal, newDataPoint: newDataPoint, recentDatapoints: realDatapoints)
+        let healthKitDataPointsByDay = Dictionary(grouping: healthKitDataPoints) { $0.daystamp }
+        
+        try await withThrowingTaskGroup(of: Void.self) { group in
+            for (daystamp, dayDataPoints) in healthKitDataPointsByDay {
+                group.addTask {
+                    let existingDatapointsForDay = await self.datapointsMatchingDaystamp(datapoints: realDatapoints, daystamp: daystamp)
+                    try await self.updateToMatchDataPointsForDay(goal: goal, newDataPoints: dayDataPoints, existingDatapoints: existingDatapointsForDay)
+                }
+            }
         }
     }
 
-    private func updateToMatchDataPoint(goal: Goal, newDataPoint : BeeDataPoint, recentDatapoints: [DataPoint]) async throws {
-        var matchingDatapoints = datapointsMatchingDaystamp(datapoints: recentDatapoints, daystamp: newDataPoint.daystamp)
-        if matchingDatapoints.count == 0 {
-            // If there are not already data points for this day, do not add points
-            // from before the creation of the goal. This avoids immediate derailment
-            //on do less goals, and excessive safety buffer on do-more goals.
-            if newDataPoint.daystamp < goal.initDaystamp {
-                return
+    private func updateToMatchDataPointsForDay(goal: Goal, newDataPoints: [BeeDataPoint], existingDatapoints: [DataPoint]) async throws {
+        try await withThrowingTaskGroup(of: Void.self) { group in
+            var processedDatapoints: Set<String> = []
+            
+            for newDataPoint in newDataPoints {
+                let matchingDatapoint = existingDatapoints.first { $0.requestid == newDataPoint.requestid }
+                
+                if let existingDatapoint = matchingDatapoint {
+                    if !isApproximatelyEqual(existingDatapoint.value.doubleValue, newDataPoint.value.doubleValue) || existingDatapoint.comment != newDataPoint.comment {
+                        group.addTask {
+                            self.logger.notice("Updating datapoint for \(goal.id) with requestId \(newDataPoint.requestid, privacy: .public) from \(existingDatapoint.value) to \(newDataPoint.value)")
+                            try await self.updateDatapoint(goal: goal, datapoint: existingDatapoint, datapointValue: newDataPoint.value, comment: newDataPoint.comment)
+                        }
+                    }
+                    processedDatapoints.insert(existingDatapoint.requestid)
+                } else if newDataPoint.daystamp >= goal.initDaystamp {
+                    // If there are not already data points for this requestId, do not add points
+                    // from before the creation of the goal. This avoids immediate derailment
+                    // on do less goals, and excessive safety buffer on do-more goals.
+                    group.addTask {
+                        let urText = "\(newDataPoint.daystamp.day) \(newDataPoint.value) \"\(newDataPoint.comment)\""
+                        self.logger.notice("Creating new datapoint for \(goal.id, privacy: .public) with requestId \(newDataPoint.requestid, privacy: .public): \(newDataPoint.value, privacy: .private)")
+                        try await self.postDatapoint(goal: goal, urText: urText, requestId: newDataPoint.requestid)
+                    }
+                }
             }
-
-            let urText = "\(newDataPoint.daystamp.day) \(newDataPoint.value) \"\(newDataPoint.comment)\""
-            let requestId = newDataPoint.requestid
-
-            logger.notice("Creating new datapoint for \(goal.id, privacy: .public) on \(newDataPoint.daystamp, privacy: .public): \(newDataPoint.value, privacy: .private)")
-
-            try await postDatapoint(goal: goal, urText: urText, requestId: requestId)
-        } else if matchingDatapoints.count >= 1 {
-            let firstDatapoint = matchingDatapoints.remove(at: 0)
-            for datapoint in matchingDatapoints {
-                try await deleteDatapoint(goal: goal, datapoint: datapoint)
-            }
-
-            if !isApproximatelyEqual(firstDatapoint.value.doubleValue, newDataPoint.value.doubleValue) {
-                logger.notice("Updating datapoint for \(goal.id) on \(firstDatapoint.daystamp, privacy: .public) from \(firstDatapoint.value) to \(newDataPoint.value)")
-
-                try await updateDatapoint(goal: goal, datapoint: firstDatapoint, datapointValue: newDataPoint.value)
+            
+            for existingDatapoint in existingDatapoints {
+                if !processedDatapoints.contains(existingDatapoint.requestid) {
+                    group.addTask {
+                        self.logger.notice("Deleting obsolete datapoint for \(goal.id) with requestId \(existingDatapoint.requestid, privacy: .public)")
+                        try await self.deleteDatapoint(goal: goal, datapoint: existingDatapoint)
+                    }
+                }
             }
         }
     }

BeeKit/Managers/GoalManager.swift

@@ -74,8 +74,8 @@ public actor GoalManager {
         // We must fetch the user object first, and then fetch goals afterwards, to guarantee User.updated_at is
         // a safe timestamp for future fetches without losing data
         let userResponse = JSON(try await requestManager.get(url: "api/v1/users/{username}.json")!)
-        let goalResponse = JSON(try await requestManager.get(url: "api/v1/users/{username}/goals.json")!)
-        
+        let goalResponse = JSON(try await requestManager.get(url: "api/v1/users/{username}/goals.json", parameters: ["emaciated": "true"])!)
+
         // The user may have logged out during the network operation. If so we have nothing to do
         modelContext.refreshAllObjects()
         guard let user = modelContext.object(with: user.objectID) as? User else { return }
@@ -97,7 +97,7 @@ public actor GoalManager {
     /// Perform an incremental refresh of goals for regular updates
     private func refreshGoalsIncremental(user: User) async throws {
         logger.notice("Doing incremental update since \(user.updatedAt, privacy: .public)")
-        let userResponse = JSON(try await requestManager.get(url: "api/v1/users/{username}.json", parameters: ["diff_since": user.updatedAt.timeIntervalSince1970 + 1])!)
+        let userResponse = JSON(try await requestManager.get(url: "api/v1/users/{username}.json", parameters: ["diff_since": user.updatedAt.timeIntervalSince1970 + 1, "emaciated": "true"])!)
         let goalResponse = userResponse["goals"]
         let deletedGoals = userResponse["deleted_goals"]
 
@@ -126,7 +126,8 @@ public actor GoalManager {
     public func refreshGoal(_ goalID: NSManagedObjectID) async throws {
         let goal = try modelContext.existingObject(with: goalID) as! Goal
 
-        let responseObject = try await requestManager.get(url: "/api/v1/users/\(currentUserManager.username!)/goals/\(goal.slug)?datapoints_count=5")
+        let responseObject = try await requestManager.get(url: "/api/v1/users/\(currentUserManager.username!)/goals/\(goal.slug)",
+                                                          parameters: ["datapoints_count": "5", "emaciated": "true"])
         let goalJSON = JSON(responseObject!)
 
         // The goal may have changed during the network operation, reload latest version

BeeKit/Managers/RefreshManager.swift

@@ -0,0 +1,36 @@
+// Part of BeeSwift. Copyright Beeminder
+
+import Foundation
+import OSLog
+
+public class RefreshManager {
+    private let logger = Logger(subsystem: "com.beeminder.beeminder", category: "RefreshManager")
+    private let healthStoreManager: HealthStoreManager
+    private let goalManager: GoalManager
+    
+    public init(healthStoreManager: HealthStoreManager, goalManager: GoalManager) {
+        self.healthStoreManager = healthStoreManager
+        self.goalManager = goalManager
+    }
+    
+    @MainActor
+    public func refreshGoalsAndHealthKitData() async {
+        await withTaskGroup(of: Void.self) { group in
+            group.addTask {
+                do {
+                    let _ = try await self.healthStoreManager.updateAllGoalsWithRecentData(days: 7)
+                } catch {
+                    self.logger.error("Error updating from healthkit: \(error)")
+                }
+            }
+            
+            group.addTask {
+                do {
+                    try await self.goalManager.refreshGoals()
+                } catch {
+                    self.logger.error("Error refreshing goals: \(error)")
+                }
+            }
+        }
+    }
+}

BeeKit/ServiceLocator.swift

@@ -21,4 +21,5 @@ public class ServiceLocator {
     public static let dataPointManager = DataPointManager(requestManager: requestManager, container: persistentContainer)
     public static let healthStoreManager = HealthStoreManager(goalManager: goalManager, container: persistentContainer)
     public static let versionManager = VersionManager(requestManager: requestManager)
+    public static let refreshManager = RefreshManager(healthStoreManager: healthStoreManager, goalManager: goalManager)
 }