Added final coupon and item storage support

Author: bummytime

Storage/Storage/Model/Order+CoreDataProperties.swift

@@ -47,8 +47,8 @@ extension Order {
     @NSManaged public var shippingPhone: String?
     @NSManaged public var shippingEmail: String?
     @NSManaged public var shippingState: String?
-    @NSManaged public var coupons: NSSet?
-    @NSManaged public var items: NSSet?
+    @NSManaged public var coupons: Set<OrderCoupon>?
+    @NSManaged public var items: Set<OrderItem>?
 }
 
 // MARK: Generated accessors for coupons

Storage/Storage/Tools/StorageType+Extensions.swift

@@ -25,4 +25,18 @@ public extension StorageType {
         let predicate = NSPredicate(format: "orderID = %ld", orderID)
         return firstObject(ofType: Order.self, matching: predicate)
     }
+
+    /// Retrieves the Stored Order Item.
+    ///
+    public func loadOrderItem(itemID: Int) -> OrderItem? {
+        let predicate = NSPredicate(format: "itemID = %ld", itemID)
+        return firstObject(ofType: OrderItem.self, matching: predicate)
+    }
+
+    /// Retrieves the Stored Order Coupon.
+    ///
+    public func loadCouponItem(couponID: Int) -> OrderCoupon? {
+        let predicate = NSPredicate(format: "couponID = %ld", couponID)
+        return firstObject(ofType: OrderCoupon.self, matching: predicate)
+    }
 }

Yosemite/Yosemite/Model/Order+ReadOnlyConvertible.swift

@@ -52,13 +52,14 @@ extension Storage.Order: ReadOnlyConvertible {
         shippingCountry = order.shippingAddress.country
         shippingPhone = order.shippingAddress.phone
         shippingEmail = order.shippingAddress.email
-
-        // TODO: items, coupons
     }
 
     /// Returns a ReadOnly version of the receiver.
     ///
     public func toReadOnly() -> Yosemite.Order {
+        let orderItems = items?.map { $0.toReadOnly() } ?? [Yosemite.OrderItem]()
+        let orderCoupons = coupons?.map { $0.toReadOnly() } ?? [Yosemite.OrderCouponLine]()
+
         return Order(orderID: Int(orderID),
                      parentID: Int(parentID),
                      customerID: Int(customerID),
@@ -76,12 +77,10 @@ extension Storage.Order: ReadOnlyConvertible {
                      total: total ?? "",
                      totalTax: totalTax ?? "",
                      paymentMethodTitle: paymentMethodTitle ?? "",
-                     items: [],
+                     items: orderItems,
                      billingAddress: createReadOnlyBillingAddress(),
                      shippingAddress: createReadOnlyShippingAddress(),
-                     coupons: [])
-
-        // TODO: ^^^^ items, coupons ^^^^
+                     coupons: orderCoupons)
     }
 
 

Yosemite/Yosemite/Stores/OrderStore.swift

@@ -71,7 +71,7 @@ private extension OrderStore  {
 
 // MARK: - Persistance
 //
-extension OrderStore {
+private extension OrderStore {
 
     /// Updates (OR Inserts) the specified ReadOnly Order Entity into the Storage Layer.
     ///
@@ -81,6 +81,8 @@ extension OrderStore {
         let storage = storageManager.viewStorage
         let storageOrder = storage.loadOrder(orderID: readOnlyOrder.orderID) ?? storage.insertNewObject(ofType: Storage.Order.self)
 
+        // TODO: items & coupons
+
         storageOrder.update(with: readOnlyOrder)
         storage.saveIfNeeded()
     }
@@ -91,12 +93,69 @@ extension OrderStore {
         assert(Thread.isMainThread)
 
         let storage = storageManager.viewStorage
-
         for readOnlyOrder in readOnlyOrders {
             let storageOrder = storage.loadOrder(orderID: readOnlyOrder.orderID) ?? storage.insertNewObject(ofType: Storage.Order.self)
             storageOrder.update(with: readOnlyOrder)
+            handleOrderItems(readOnlyOrder, storageOrder, storage)
+            handleOrderCoupons(readOnlyOrder, storageOrder, storage)
         }
 
         storage.saveIfNeeded()
     }
+
+    /// Updates, inserts, and prunes the provided StorageOrder's items using the provided read-only Order's items
+    ///
+    func handleOrderItems(_ readOnlyOrder: Networking.Order, _ storageOrder: Storage.Order, _ storage: StorageType) {
+        guard !readOnlyOrder.items.isEmpty else {
+            // No items in the read-only order, so remove all the items in Storage.Order
+            storageOrder.items?.forEach { storageOrder.removeFromItems($0) }
+            return
+        }
+
+        // Upsert the items from the read-only order
+        for readOnlyItem in readOnlyOrder.items {
+            if let existingStorageItem = storage.loadOrderItem(itemID: readOnlyItem.itemID) {
+                existingStorageItem.update(with: readOnlyItem)
+            } else {
+                let newStorageItem = storage.insertNewObject(ofType: Storage.OrderItem.self)
+                newStorageItem.update(with: readOnlyItem)
+                storageOrder.addToItems(newStorageItem)
+            }
+        }
+
+        // Now, remove any objects that exist in storageOrder.items but not in readOnlyOrder.items
+        storageOrder.items?.forEach({ storageItem in
+            if readOnlyOrder.items.first(where: { $0.itemID == storageItem.itemID } ) == nil {
+                storageOrder.removeFromItems(storageItem)
+            }
+        })
+    }
+
+    /// Updates, inserts, and prunes the provided StorageOrder's coupons using the provided read-only Order's coupons
+    ///
+    func handleOrderCoupons(_ readOnlyOrder: Networking.Order, _ storageOrder: Storage.Order, _ storage: StorageType) {
+        guard !readOnlyOrder.coupons.isEmpty else {
+            // No coupons in the read-only order, so remove all the coupons in Storage.Order
+            storageOrder.coupons?.forEach { storageOrder.removeFromCoupons($0) }
+            return
+        }
+
+        // Upsert the coupons from the read-only order
+        for readOnlyCoupon in readOnlyOrder.coupons {
+            if let existingStorageCoupon = storage.loadCouponItem(couponID: readOnlyCoupon.couponID) {
+                existingStorageCoupon.update(with: readOnlyCoupon)
+            } else {
+                let newStorageCoupon = storage.insertNewObject(ofType: Storage.OrderCoupon.self)
+                newStorageCoupon.update(with: readOnlyCoupon)
+                storageOrder.addToCoupons(newStorageCoupon)
+            }
+        }
+
+        // Now, remove any objects that exist in storageOrder.coupons but not in readOnlyOrder.coupons
+        storageOrder.coupons?.forEach({ storageCoupon in
+            if readOnlyOrder.coupons.first(where: { $0.couponID == storageCoupon.couponID } ) == nil {
+                storageOrder.removeFromCoupons(storageCoupon)
+            }
+        })
+    }
 }

Yosemite/YosemiteTests/Stores/OrderStoreTests.swift

@@ -78,7 +78,7 @@ class OrderStoreTests: XCTestCase {
         wait(for: [expectation], timeout: Constants.expectationTimeout)
     }
 
-    /// Verifies that `OrderAction.retrieveOrders` effectively persists all of the order fields correctly.
+    /// Verifies that `OrderAction.retrieveOrders` effectively persists all of the order fields correctly across all of the related Order objects (items, coupons, etc).
     ///
     func testRetrieveOrdersEffectivelyPersistsOrderFields() {
         let expectation = self.expectation(description: "Persist order list")
@@ -95,7 +95,7 @@ class OrderStoreTests: XCTestCase {
             let readOnlyStoredOrder = storedOrder?.toReadOnly()
             XCTAssertNotNil(storedOrder)
             XCTAssertNotNil(readOnlyStoredOrder)
-            //XCTAssertEqual(readOnlyStoredOrder, remoteOrder)
+            XCTAssertEqual(readOnlyStoredOrder, remoteOrder)
 
             expectation.fulfill()
         }