연결은 한 - 투 - 많은 Restkit

Question

를 사용하여 외래 키에 의해

나는이 모델을 가지고 :

는

extension Notification { 

    @NSManaged var pk: NSNumber? 
    @NSManaged var subtitle: String? 
    @NSManaged var title: String? 
    @NSManaged var user: User? 

} 

extension User { 
    // here's some attributes 
    @NSManaged var pk: NSNumber? 
    @NSManaged var notifications: NSSet? 
    // and here's really some more.. 
} 

처럼 보일 수있는 사용자의 통지를 나열하는 응답 :

[ 
    { 
     "pk": 2, 
     "title": "Hi mate", 
     "subtitle": "O hoy", 
     "user": 2 
    } 
] 

"user": 2는 것을 의미한다 pk = 2 인 사용자에게 속합니다.

이 알림을 사용자에게 올바르게 매핑하려면 어떻게해야합니까?

let mapping = RKEntityMapping(forEntityForName: String(Notification), inManagedObjectStore: RKObjectManager.sharedManager().managedObjectStore) 

mapping.identificationAttributes = [ "pk" ] 

mapping.addAttributeMappingsFromDictionary([ 
    "pk": "pk", 
    "title": "title", 
    "subtitle": "subtitle", 
]) 

mapping.addConnectionForRelationship("user", connectedBy: [ 
    "user.pk": "pk" 
]) 

내가

mapping.addConnectionForRelationship("user", connectedBy: [ 
    "pk" 
]) 

을 할 수 있지만 그때는 Notification 같은 PK와 사용자에게 연결 : 내 시도이다.

내가 오류는 다음과 같습니다

Terminating app due to uncaught exception 'NSInvalidArgumentException', reason: 'Cannot connect relationship: invalid attributes given for source entity 'Notification': user.pk' 

가 어떻게 이것을 달성 할 수 있습니까?

알림에 일시적인 속성 사용자를 추가하고 userPk를 pk에 매핑해야합니까?

편집 : 일시적인 속성을 사용하여 작업하고 있는데 이것이 유일한 방법입니까?

mapping.identificationAttributes = [ "pk" ] 

mapping.addAttributeMappingsFromDictionary([ 
    "pk": "pk", 
    "title": "title", 
    "subtitle": "subtitle", 
    "user": "userPk" 
]) 

mapping.addConnectionForRelationship("user", connectedBy: [ 
    "userPk": "pk" 
]) 

userPk 지금만큼 당신은 사용자의 ID를 얻을로 Notification

Answer 1

에 일시적 속성입니다의 예는, 당신은 방법 addConnectionForRelationship 및 일시적인 속성을 사용해야합니다. 그러나 백엔드에서 ID 대신 사용자 개체를 제공 할 경우 RKEntityMapping에서 addPropertyMapping 메서드를 사용할 수 있습니다. 그러면 다음과 비슷한 패턴을 제안합니다 :

import Foundation 
import CoreData 
import RestKit 

protocol Mappable { 
    static var entityName: String {get} 
    static var identityAttribute: String? {get} 
    static func mapping(managedObjectStore: RKManagedObjectStore) -> RKEntityMapping 
    static func identificationAttributes() -> [String]? 
    static func createPropertyMappings(managedObjectStore: RKManagedObjectStore, objectMapping: RKObjectMapping) -> [RKRelationshipMapping]? 
    static func attributesDictionary() -> Dictionary<String, String>? 
    static func requestDescriptor(managedObjectStore: RKManagedObjectStore) -> RKRequestDescriptor 
} 

class ManagedObject: NSManagedObject, Mappable { 

    //MARK: - ManagedObjectProtocol Methods 
    class func mapping(managedObjectStore: RKManagedObjectStore) -> RKEntityMapping { 
     let mapping = RKEntityMapping(
      forEntityForName: entityName, 
      inManagedObjectStore: managedObjectStore 
     ) 

     if let identityAttribute = identityAttribute { 
      mapping.identificationAttributes = [identityAttribute] 
     } 

     if let attributeMapping = attributes { 
      mapping.addAttributeMappingsFromDictionary(attributeMapping) 
     } 

     if let propertyMappings = createPropertyMappings(managedObjectStore, objectMapping: mapping) { 
      for propertyMapping in propertyMappings { 
       mapping.addPropertyMapping(propertyMapping) 
      } 
     } 

     return mapping 
    } 

    class var entityName: String { 
     fatalError("must override") 
    } 

    class var identityAttribute: String? { 
     //override me 
     return nil 
    } 

    class func attributesDictionary() -> Dictionary<String, String>? { 
     //override me 
     return nil 
    } 

    class func createPropertyMappings(managedObjectStore: RKManagedObjectStore, objectMapping: RKObjectMapping) -> [RKRelationshipMapping]? { 
     //override me if needed 
     return nil 
    } 

    class func requestDescriptor(managedObjectStore: RKManagedObjectStore) -> RKRequestDescriptor { 
     let inversedMapping = mapping(managedObjectStore).inverseMapping() 
     let descriptor = RKRequestDescriptor(mapping: inversedMapping, objectClass: self, rootKeyPath: nil, method: RKRequestMethod.Any) 
     return descriptor 
    } 

} 

class Notification: ManagedObject { 

    //MARK: - ManagedObjectProtocol Methods 
    class var entityName: String { 
     return "Notification" 
    } 

    override class func attributesDictionary() -> Dictionary<String, String>? { 
     let dictionary = [ 
      "pk": "pk", 
      "title": "title", 
      "subtitle": "subtitle" 
     ] 
     return dictionary 
    } 

    override class func createPropertyMappings(managedObjectStore: RKManagedObjectStore, objectMapping: RKObjectMapping) -> [RKRelationshipMapping]? { 
     let bookmarksPropertyMapping = RKRelationshipMapping(
      fromKeyPath: "user", 
      toKeyPath: "user", 
      withMapping: User.mapping(managedObjectStore) 
     ) 

     return [bookmarksPropertyMapping] 
    } 
} 

class User: ManagedObject { 
    //MARK: - ManagedObjectProtocol Methods 
    class var entityName: String { 
     return "User" 
    } 

    override class func attributesDictionary() -> Dictionary<String, String>? { 
     let dictionary = [ 
      "pk": "pk" 
     ] 
     return dictionary 
    } 
}