encode healthKitLinkage as string

cbaker6 · cbaker6 · commit 2d851205d48b · 2023-04-26T17:33:09.000-04:00
diff --git a/Sources/ParseCareKit/Models/PCKClock.swift b/Sources/ParseCareKit/Models/PCKClock.swift
@@ -29,20 +29,20 @@ public struct PCKClock: ParseObject {
 
     public var uuid: UUID?
 
-    var vector: String?
+    var knowledgeVectorString: String?
 
     /// A knowledge vector indicating the last known state of each other device
     /// by the device that authored this revision record.
     public var knowledgeVector: OCKRevisionRecord.KnowledgeVector? {
         get {
-            try? PCKClock.decodeVector(vector)
+            try? PCKClock.decodeVector(knowledgeVectorString)
         }
         set {
             guard let newValue = newValue else {
-                vector = nil
+                knowledgeVectorString = nil
                 return
             }
-            vector = PCKClock.encodeVector(newValue)
+            knowledgeVectorString = PCKClock.encodeVector(newValue)
         }
     }
 
@@ -54,15 +54,15 @@ public struct PCKClock: ParseObject {
                                      original: object) {
             updated.uuid = object.uuid
         }
-        if updated.shouldRestoreKey(\.vector,
+        if updated.shouldRestoreKey(\.knowledgeVectorString,
                                      original: object) {
-            updated.vector = object.vector
+            updated.knowledgeVectorString = object.knowledgeVectorString
         }
         return updated
     }
 
     static func decodeVector(_ clock: Self) throws -> OCKRevisionRecord.KnowledgeVector {
-        try decodeVector(clock.vector)
+        try decodeVector(clock.knowledgeVectorString)
     }
 
     static func decodeVector(_ vector: String?) throws -> OCKRevisionRecord.KnowledgeVector {
@@ -73,10 +73,8 @@ public struct PCKClock: ParseObject {
         }
 
         do {
-            // swiftlint:disable:next line_length
-            let remoteVector: OCKRevisionRecord.KnowledgeVector = try JSONDecoder().decode(OCKRevisionRecord.KnowledgeVector.self,
-                                                                                          from: data)
-            return remoteVector
+            return try JSONDecoder().decode(OCKRevisionRecord.KnowledgeVector.self,
+                                            from: data)
         } catch {
             Logger.clock.error("Clock.decodeVector(): \(error, privacy: .private). Vector \(data, privacy: .private).")
             throw ParseCareKitError.errorString("Clock.decodeVector(): \(error)")
@@ -88,7 +86,7 @@ public struct PCKClock: ParseObject {
             return nil
         }
         var mutableClock = clock
-        mutableClock.vector = remoteVectorString
+        mutableClock.knowledgeVectorString = remoteVectorString
         return mutableClock
     }
 
@@ -212,7 +210,7 @@ public struct PCKClock: ParseObject {
 extension PCKClock {
     init(uuid: UUID) {
         self.uuid = uuid
-        vector = "{\"processes\":[{\"id\":\"\(uuid)\",\"clock\":0}]}"
+        knowledgeVectorString = "{\"processes\":[{\"id\":\"\(uuid)\",\"clock\":0}]}"
         ACL = PCKUtility.getDefaultACL()
     }
 }
diff --git a/Sources/ParseCareKit/Models/PCKHealthKitTask.swift b/Sources/ParseCareKit/Models/PCKHealthKitTask.swift
@@ -103,8 +103,28 @@ public struct PCKHealthKitTask: PCKVersionable {
 
     public var originalData: Data?
 
+    #if canImport(HealthKit)
     /// A structure specifying how this task is linked with HealthKit.
-    public var healthKitLinkage: OCKHealthKitLinkage?
+    public var healthKitLinkage: OCKHealthKitLinkage? {
+        get {
+            guard let data = healthKitLinkageString?.data(using: .utf8) else {
+                return nil
+            }
+            return try? JSONDecoder().decode(OCKHealthKitLinkage.self,
+                                             from: data)
+        } set {
+            guard let json = try? JSONEncoder().encode(newValue),
+                    let encodedString = String(data: json, encoding: .utf8) else {
+                healthKitLinkageString = nil
+                return
+            }
+            healthKitLinkageString = encodedString
+        }
+    }
+    #endif
+
+    /// A string specifying how this task is linked with HealthKit.
+    public var healthKitLinkageString: String?
 
     /// If true, completion of this task will be factored into the patient's overall adherence. True by default.
     public var impactsAdherence: Bool?
@@ -135,12 +155,18 @@ public struct PCKHealthKitTask: PCKVersionable {
     }
 
     enum CodingKeys: String, CodingKey {
-        case objectId, createdAt, updatedAt
+        case objectId, createdAt, updatedAt,
+             className, ACL, uuid
         case entityId, schemaVersion, createdDate, updatedDate,
              deletedDate, timezone, userInfo, groupIdentifier,
              tags, source, asset, remoteID, notes, logicalClock
         case previousVersionUUIDs, nextVersionUUIDs, effectiveDate
-        case title, carePlan, carePlanUUID, impactsAdherence, instructions, schedule, healthKitLinkage
+        case title, carePlan, carePlanUUID, impactsAdherence,
+             instructions, schedule, healthKitLinkageString
+        case previousVersions, nextVersions
+        #if canImport(HealthKit)
+        case healthKitLinkage
+        #endif
     }
 
     public init() {
@@ -215,18 +241,61 @@ public struct PCKHealthKitTask: PCKVersionable {
     }
 }
 
-extension PCKHealthKitTask {
-    public func encode(to encoder: Encoder) throws {
+public extension PCKHealthKitTask {
+    init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.objectId = try container.decodeIfPresent(String.self, forKey: .objectId)
+        self.createdAt = try container.decodeIfPresent(Date.self, forKey: .createdAt)
+        self.updatedAt = try container.decodeIfPresent(Date.self, forKey: .updatedAt)
+        self.ACL = try container.decodeIfPresent(ParseACL.self, forKey: .ACL)
+        self.healthKitLinkageString = try container.decodeIfPresent(String.self, forKey: .healthKitLinkageString)
+        #if canImport(HealthKit)
+        if healthKitLinkageString == nil {
+            self.healthKitLinkage = try container.decodeIfPresent(OCKHealthKitLinkage.self, forKey: .healthKitLinkage)
+        }
+        #endif
+        self.carePlan = try container.decodeIfPresent(PCKCarePlan.self, forKey: .carePlan)
+        self.carePlanUUID = try container.decodeIfPresent(UUID.self, forKey: .carePlanUUID)
+        self.title = try container.decodeIfPresent(String.self, forKey: .title)
+        self.logicalClock = try container.decodeIfPresent(Int.self, forKey: .logicalClock)
+        self.impactsAdherence = try container.decodeIfPresent(Bool.self, forKey: .impactsAdherence)
+        self.instructions = try container.decodeIfPresent(String.self, forKey: .instructions)
+        self.schedule = try container.decodeIfPresent(OCKSchedule.self, forKey: .schedule)
+        self.entityId = try container.decodeIfPresent(String.self, forKey: .entityId)
+        self.createdDate = try container.decodeIfPresent(Date.self, forKey: .createdDate)
+        self.updatedDate = try container.decodeIfPresent(Date.self, forKey: .updatedDate)
+        self.deletedDate = try container.decodeIfPresent(Date.self, forKey: .deletedDate)
+        self.effectiveDate = try container.decodeIfPresent(Date.self, forKey: .effectiveDate)
+        self.timezone = try container.decodeIfPresent(TimeZone.self, forKey: .timezone)
+        self.previousVersions = try container.decodeIfPresent([Pointer<Self>].self, forKey: .previousVersions)
+        self.nextVersions = try container.decodeIfPresent([Pointer<Self>].self, forKey: .nextVersions)
+        self.previousVersionUUIDs = try container.decodeIfPresent([UUID].self, forKey: .previousVersionUUIDs)
+        self.nextVersionUUIDs = try container.decodeIfPresent([UUID].self, forKey: .nextVersionUUIDs)
+        self.userInfo = try container.decodeIfPresent([String: String].self, forKey: .userInfo)
+        self.remoteID = try container.decodeIfPresent(String.self, forKey: .remoteID)
+        self.source = try container.decodeIfPresent(String.self, forKey: .source)
+        self.asset = try container.decodeIfPresent(String.self, forKey: .asset)
+        self.schemaVersion = try container.decodeIfPresent(OCKSemanticVersion.self, forKey: .schemaVersion)
+        self.groupIdentifier = try container.decodeIfPresent(String.self, forKey: .groupIdentifier)
+        self.tags = try container.decodeIfPresent([String].self, forKey: .tags)
+        self.notes = try container.decodeIfPresent([OCKNote].self, forKey: .notes)
+    }
+
+    func encode(to encoder: Encoder) throws {
         var container = encoder.container(keyedBy: CodingKeys.self)
         if encodingForParse {
             try container.encodeIfPresent(carePlan?.toPointer(), forKey: .carePlan)
+            try container.encodeIfPresent(healthKitLinkageString, forKey: .healthKitLinkageString)
+        } else {
+            #if canImport(HealthKit)
+            try container.encodeIfPresent(healthKitLinkage, forKey: .healthKitLinkage)
+            #endif
         }
         try container.encodeIfPresent(title, forKey: .title)
         try container.encodeIfPresent(carePlanUUID, forKey: .carePlanUUID)
         try container.encodeIfPresent(impactsAdherence, forKey: .impactsAdherence)
         try container.encodeIfPresent(instructions, forKey: .instructions)
         try container.encodeIfPresent(schedule, forKey: .schedule)
-        try container.encodeIfPresent(healthKitLinkage, forKey: .healthKitLinkage)
         try encodeVersionable(to: encoder)
     }
 }
diff --git a/Sources/ParseCareKit/Models/PCKRevisionRecord.swift b/Sources/ParseCareKit/Models/PCKRevisionRecord.swift
@@ -44,18 +44,18 @@ struct PCKRevisionRecord: ParseObject, Equatable, Codable {
     /// by the device that authored this revision record.
     var knowledgeVector: OCKRevisionRecord.KnowledgeVector? {
         get {
-            try? PCKClock.decodeVector(vector)
+            try? PCKClock.decodeVector(knowledgeVectorString)
         }
         set {
             guard let newValue = newValue else {
-                vector = nil
+                knowledgeVectorString = nil
                 return
             }
-            vector = PCKClock.encodeVector(newValue)
+            knowledgeVectorString = PCKClock.encodeVector(newValue)
         }
     }
 
-    var vector: String?
+    var knowledgeVectorString: String?
 
     var storeClassesToSynchronize: [PCKStoreClass: any PCKVersionable.Type]? = try? PCKStoreClass.getConcrete()
 
@@ -112,12 +112,12 @@ struct PCKRevisionRecord: ParseObject, Equatable, Codable {
 
     enum CodingKeys: String, CodingKey {
         case objectId, createdAt, updatedAt, className,
-             ACL, vector, entities,
+             ACL, knowledgeVectorString, entities,
              logicalClock, clock, clockUUID
     }
 
     static func == (lhs: PCKRevisionRecord, rhs: PCKRevisionRecord) -> Bool {
-        lhs.vector == rhs.vector &&
+        lhs.knowledgeVectorString == rhs.knowledgeVectorString &&
         lhs.logicalClock == rhs.logicalClock &&
         lhs.objectId == rhs.objectId &&
         lhs.entities == rhs.entities
@@ -226,7 +226,7 @@ extension PCKRevisionRecord {
         self.createdAt = try container.decodeIfPresent(Date.self, forKey: .createdAt)
         self.updatedAt = try container.decodeIfPresent(Date.self, forKey: .updatedAt)
         self.ACL = try container.decodeIfPresent(ParseACL.self, forKey: .ACL)
-        self.vector = try container.decodeIfPresent(String.self, forKey: .vector)
+        self.knowledgeVectorString = try container.decodeIfPresent(String.self, forKey: .knowledgeVectorString)
         self.entities = try container.decodeIfPresent([PCKEntity].self, forKey: .entities)
         self.clock = try container.decodeIfPresent(PCKClock.self, forKey: .clock)
         self.logicalClock = try container.decodeIfPresent(Int.self, forKey: .logicalClock)
@@ -240,7 +240,7 @@ extension PCKRevisionRecord {
         try container.encodeIfPresent(createdAt, forKey: .createdAt)
         try container.encodeIfPresent(updatedAt, forKey: .updatedAt)
         try container.encodeIfPresent(ACL, forKey: .ACL)
-        try container.encodeIfPresent(vector, forKey: .vector)
+        try container.encodeIfPresent(knowledgeVectorString, forKey: .knowledgeVectorString)
         try container.encodeIfPresent(entities, forKey: .entities)
         try container.encodeIfPresent(clock, forKey: .clock)
         try container.encodeIfPresent(logicalClock, forKey: .logicalClock)
diff --git a/Tests/ParseCareKitTests/EncodingCareKitTests.swift b/Tests/ParseCareKitTests/EncodingCareKitTests.swift
@@ -693,15 +693,17 @@ class ParseCareKitTests: XCTestCase {
         XCTAssertTrue(acl2.getWriteAccess(objectId: objectId))
     }
 
+    #if canImport(HealthKit)
     // swiftlint:disable:next function_body_length
     func testHealthKitTask() async throws {
         let careKitSchedule = OCKScheduleElement(start: Date(),
                                                  end: Date().addingTimeInterval(3000), interval: .init(day: 1))
+        let linkage = OCKHealthKitLinkage(quantityIdentifier: .bodyTemperature,
+                                          quantityType: .discrete,
+                                          unit: .degreeCelsius())
         var careKit = OCKHealthKitTask(id: "myId", title: "hello", carePlanUUID: UUID(),
                                        schedule: .init(composing: [careKitSchedule]),
-                                       healthKitLinkage: .init(quantityIdentifier: .bodyTemperature,
-                                                               quantityType: .discrete,
-                                                               unit: .degreeCelsius()))
+                                       healthKitLinkage: linkage)
         let careKitNote = OCKNote(author: "myId", title: "hello", content: "world")
 
         // Special
@@ -737,7 +739,7 @@ class ParseCareKitTests: XCTestCase {
         XCTAssertEqual(parse.title, careKit.title)
         XCTAssertEqual(parse.carePlanUUID, careKit.carePlanUUID)
         XCTAssertEqual(parse.carePlan?.objectId, careKit.carePlanUUID?.uuidString)
-        // XCTAssertEqual(parse.allergies, careKit.allergies)
+        XCTAssertEqual(parse.healthKitLinkage, careKit.healthKitLinkage)
 
         // Objectable
         XCTAssertEqual(parse.className, "HealthKitTask")
@@ -769,6 +771,7 @@ class ParseCareKitTests: XCTestCase {
 
         // Special
         XCTAssertEqual(parse2.impactsAdherence, careKit.impactsAdherence)
+        XCTAssertEqual(parse2.healthKitLinkage, careKit.healthKitLinkage)
         XCTAssertEqual(parse2.title, careKit.title)
         XCTAssertEqual(parse2.carePlanUUID, careKit.carePlanUUID)
 
@@ -826,6 +829,7 @@ class ParseCareKitTests: XCTestCase {
         XCTAssertEqual(parse.impactsAdherence, cloudDecoded.impactsAdherence)
         XCTAssertEqual(parse.title, cloudDecoded.title)
         XCTAssertEqual(parse.carePlanUUID, cloudDecoded.carePlanUUID)
+        XCTAssertEqual(parse.healthKitLinkage, cloudDecoded.healthKitLinkage)
 
         // Versionable
         XCTAssertNotNil(cloudDecoded.effectiveDate)
@@ -883,6 +887,7 @@ class ParseCareKitTests: XCTestCase {
         XCTAssertTrue(acl2.getReadAccess(objectId: objectId))
         XCTAssertTrue(acl2.getWriteAccess(objectId: objectId))
     }
+    #endif
 
     // swiftlint:disable:next function_body_length
     func testCarePlan() async throws {

Original file line number	Diff line number	Diff line change
`@@ -29,20 +29,20 @@ public struct PCKClock: ParseObject {`
`29`	`29`
`30`	`30`	`public var uuid: UUID?`
`31`	`31`
`32`		`- var vector: String?`
	`32`	`+ var knowledgeVectorString: String?`
`33`	`33`
`34`	`34`	`/// A knowledge vector indicating the last known state of each other device`
`35`	`35`	`/// by the device that authored this revision record.`
`36`	`36`	`public var knowledgeVector: OCKRevisionRecord.KnowledgeVector? {`
`37`	`37`	`get {`
`38`		`- try? PCKClock.decodeVector(vector)`
	`38`	`+ try? PCKClock.decodeVector(knowledgeVectorString)`
`39`	`39`	`}`
`40`	`40`	`set {`
`41`	`41`	`guard let newValue = newValue else {`
`42`		`- vector = nil`
	`42`	`+ knowledgeVectorString = nil`
`43`	`43`	`return`
`44`	`44`	`}`
`45`		`- vector = PCKClock.encodeVector(newValue)`
	`45`	`+ knowledgeVectorString = PCKClock.encodeVector(newValue)`
`46`	`46`	`}`
`47`	`47`	`}`
`48`	`48`
`@@ -54,15 +54,15 @@ public struct PCKClock: ParseObject {`
`54`	`54`	`original: object) {`
`55`	`55`	`updated.uuid = object.uuid`
`56`	`56`	`}`
`57`		`- if updated.shouldRestoreKey(\.vector,`
	`57`	`+ if updated.shouldRestoreKey(\.knowledgeVectorString,`
`58`	`58`	`original: object) {`
`59`		`- updated.vector = object.vector`
	`59`	`+ updated.knowledgeVectorString = object.knowledgeVectorString`
`60`	`60`	`}`
`61`	`61`	`return updated`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`static func decodeVector(_ clock: Self) throws -> OCKRevisionRecord.KnowledgeVector {`
`65`		`- try decodeVector(clock.vector)`
	`65`	`+ try decodeVector(clock.knowledgeVectorString)`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`static func decodeVector(_ vector: String?) throws -> OCKRevisionRecord.KnowledgeVector {`
`@@ -73,10 +73,8 @@ public struct PCKClock: ParseObject {`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`do {`
`76`		`- // swiftlint:disable:next line_length`
`77`		`- let remoteVector: OCKRevisionRecord.KnowledgeVector = try JSONDecoder().decode(OCKRevisionRecord.KnowledgeVector.self,`
`78`		`- from: data)`
`79`		`- return remoteVector`
	`76`	`+ return try JSONDecoder().decode(OCKRevisionRecord.KnowledgeVector.self,`
	`77`	`+ from: data)`
`80`	`78`	`} catch {`
`81`	`79`	`Logger.clock.error("Clock.decodeVector(): \(error, privacy: .private). Vector \(data, privacy: .private).")`
`82`	`80`	`throw ParseCareKitError.errorString("Clock.decodeVector(): \(error)")`
`@@ -88,7 +86,7 @@ public struct PCKClock: ParseObject {`
`88`	`86`	`return nil`
`89`	`87`	`}`
`90`	`88`	`var mutableClock = clock`
`91`		`- mutableClock.vector = remoteVectorString`
	`89`	`+ mutableClock.knowledgeVectorString = remoteVectorString`
`92`	`90`	`return mutableClock`
`93`	`91`	`}`
`94`	`92`
`@@ -212,7 +210,7 @@ public struct PCKClock: ParseObject {`
`212`	`210`	`extension PCKClock {`
`213`	`211`	`init(uuid: UUID) {`
`214`	`212`	`self.uuid = uuid`
`215`		`- vector = "{\"processes\":[{\"id\":\"\(uuid)\",\"clock\":0}]}"`
	`213`	`+ knowledgeVectorString = "{\"processes\":[{\"id\":\"\(uuid)\",\"clock\":0}]}"`
`216`	`214`	`ACL = PCKUtility.getDefaultACL()`
`217`	`215`	`}`
`218`	`216`	`}`