How to persist Objects with CoreStore, Alamofire, and SwiftyJSON

PersistedObjectResponse.swift

//
//  PersistedObjectResponse.swift
//  Hoozin-iOS
//
//  Created by Paul Wood on 12/10/15.
//  Copyright © 2015 Paul Wood. All rights reserved.
//

import Foundation
import Alamofire
import CoreStore
import SwiftyJSON

extension Request {
    
    public func persistedObjectResponse<T: ImportableUniqueObject where T.ImportSource==SwiftyJSON.JSON, T:NSManagedObject>
        (completionHandler: Response<T, NSError> -> Void) -> Self {
            let responseSerializer = ResponseSerializer<T, NSError> { request, response, data, error in
                guard error == nil else { return .Failure(error!) }
                
                let JSONResponseSerializer = Request.JSONResponseSerializer(options: .AllowFragments)
                let serializerResult = JSONResponseSerializer.serializeResponse(request, response, data, error)
                
                switch serializerResult {
                case .Success(let value):
                    let json = SwiftyJSON.JSON(value)
                    var uniqueIDValue : T.UniqueIDType?
                    let saveResult = CoreStore.beginSynchronous { (firstTransaction) -> Void in
                        try! firstTransaction.importUniqueObject(Into(T),source:json)
                        uniqueIDValue = try! T.uniqueIDFromImportSource(json, inTransaction: firstTransaction)!
                        firstTransaction.commit()
                    }
                    switch saveResult!{
                    case .Success(_):
                        if let object = CoreStore.fetchOne(From(T), Where(T.uniqueIDKeyPath, isEqualTo: uniqueIDValue)){
                            return .Success(object)
                        }
                        else {
                            let error = Error.errorWithCode(.DataSerializationFailed, failureReason: "Object was not persisted")
                            return .Failure(error)
                        }
                    case .Failure(let error):
                        return .Failure(error)
                    }
                    
                case .Failure(let error):
                    return .Failure(error)
                }
            }
            return response(responseSerializer: responseSerializer, completionHandler: completionHandler)
    }
    
    
    public func persistedObjectsResponse<T: ImportableUniqueObject where T.ImportSource==SwiftyJSON.JSON, T:NSManagedObject>
        (completionHandler: Response<[T], NSError> -> Void) -> Self {
            let responseSerializer = ResponseSerializer<[T], NSError> { request, response, data, error in
                guard error == nil else { return .Failure(error!) }
                
                let JSONResponseSerializer = Request.JSONResponseSerializer(options: .AllowFragments)
                let serializerResult = JSONResponseSerializer.serializeResponse(request, response, data, error)
                var uniqueIDValues : Array<T.UniqueIDType>?

                switch serializerResult {
                case .Success(let value):
                    let json = SwiftyJSON.JSON(value)
                    guard let data = json["data"].array else {
                        let error = Error.errorWithCode(.DataSerializationFailed, failureReason: "Parse Response was incorrectly formatted")
                        return .Failure(error)
                    }
                    let uniqueIDKeyPath = T.uniqueIDKeyPath
                    let saveResult = CoreStore.beginSynchronous({ (transaction) -> Void in
                        let objs = try! transaction.importUniqueObjects(Into(T), sourceArray:data)
                        uniqueIDValues = objs.map({ (o) -> T.UniqueIDType in
                            return o.valueForKeyPath(uniqueIDKeyPath) as! T.UniqueIDType
                        })
                        transaction.commit()
                    })!
                    switch saveResult{
                    case .Success(_):
                        guard let uniqueIDValues = uniqueIDValues else {
                            let error = Error.errorWithCode(.DataSerializationFailed, failureReason: "Parse Response was incorrectly formatted")
                            return .Failure(error)
                        }
                        let whereValues = Where("self.%@ IN %@",uniqueIDKeyPath, uniqueIDValues)
                        if let returnValues : [T] = CoreStore.fetchAll(From(T), whereValues) {
                            return .Success(returnValues)
                        }
                        else {
                            let error = Error.errorWithCode(.DataSerializationFailed, failureReason: "Parse Response was incorrectly formatted")
                            return .Failure(error)
                        }
                    case .Failure(let error):
                        return .Failure(error)
                    }

                case .Failure(let error):
                    return .Failure(error)
                }
            }
            return response(responseSerializer: responseSerializer, completionHandler: completionHandler)
    }
    
}