Ember Daten: Speicher von Beziehungen

Question

Ich brauche auf einmal tief ein Objekt auf den Server zu speichern und nicht in der Lage gewesen, alle Beispiele online zu finden, die die neuesten ember Daten (1.0.0-beta.4) verwenden.

Zum Beispiel mit diesen Modellen: (jsfiddle)

App.Child = DS.Model.extend({ 
    name: DS.attr('string'), 
    age: DS.attr('number'), 
    toys: DS.hasMany('toy', {async:true, embedded:'always'}), 
}); 
App.Toy = DS.Model.extend({ 
    name: DS.attr('string'), 
    child: DS.belongsTo('child') 
}); 

Und dieser Code:

actions: { 
    save: function(){ 
     var store = this.get('store'), 
      child, toy; 

     child = store.createRecord('child', { 
      name: 'Herbert' 
     }); 
     toy = store.createRecord('toy', { 
      name: 'Kazoo' 
     }); 

     child.set('toys', [toy]); 
     child.save(); 
    } 
} 

Es speichert nur die JSON für das Objekt Kind aber keine des Spielzeugs - nicht einmal Seite geladen:

{ 
    child: { 
    age: null 
    name: "Herbert" 
    } 
} 

Muss ich die Spielzeuge manuell speichern t oo? Gibt es trotzdem, dass ich es kann die folgende JSON an den Server senden:

{ 
    child: { 
    age: null 
    name: "Herbert", 
    toys: [{ 
     name: "Kazoo" 
    }] 
    } 
} 

Oder

{ 
    child: { 
    age: null 
    name: "Herbert", 
    toys: [1] 
    } 
} 

See JSFiddle: http://jsfiddle.net/jgillick/LNXyp/2/

Answer 1

ich ein tiefes Objekt erforderlich sein, statt eine Seite geladen ein, so basiert auf kingpin2k Antwort, ich kam mit dieser:

DS.JSONSerializer.reopen({ 
    serializeHasMany: function(record, json, relationship) { 
     var key = relationship.key, 
      property = Ember.get(record, key), 
      relationshipType = DS.RelationshipChange.determineRelationshipType(record.constructor, relationship); 

     if (property && relationshipType === 'manyToNone' || relationshipType === 'manyToMany' || 
      relationshipType === 'manyToOne') { 

      // Add each serialized nested object 
      json[key] = []; 
      property.forEach(function(item, index){ 
       json[key].push(item.serialize()); 
      }); 
     } 
    } 
}); 

wenn Sie jetzt child.serialize() nennen, wird es dieses Objekt zurückgeben:

{ 
    child: { 
    name: "Herbert", 
    toys: [ 
     { 
     name: 'Kazoo' 
     } 
    ] 
    } 
} 

Welche ist das, was ich brauche. Hier ist die jsfiddle mit ihm in Aktion: http://jsfiddle.net/jgillick/LNXyp/8/

Answer 2

Spielzeug nicht beide async und eingebettet immer sein kann, das sind widersprüchliche Optionen. Embedded ist derzeit nur auf dem aktiven Modell-Serializer vorhanden.

toys: DS.hasMany('toy', {embedded:'always'}) 

das Spielzeug ist eine ManyToOne Beziehung, und da die Beziehung auf der belongsTo Seite existiert, ist es effizienter, die Beziehung während des Spielzeugs zu retten ist speichern. Davon abgesehen, wenn Sie es auf einmal erstellen, wollen sie dann in einem großen Teil speichern, das ist, wo überwiegende ins Spiel kommt.

serializeHasMany: function(record, json, relationship) { 
    var key = relationship.key; 

    var relationshipType = DS.RelationshipChange.determineRelationshipType(record.constructor, relationship); 

    if (relationshipType === 'manyToNone' || relationshipType === 'manyToMany' || 
     relationshipType === 'manyToOne') { 
    json[key] = get(record, key).mapBy('id'); 
    // TODO support for polymorphic manyToNone and manyToMany relationships 
    } 
}, 

Und Ihre speichern sollte wie dieses

var store = this.get('store'), 
     child, toy; 

    child = store.createRecord('child', { 
     name: 'Herbert' 
    }); 
    toy = store.createRecord('toy', { 
     name: 'Kazoo' 
    }); 

    child.get('toys').pushObject(toy); 
    child.save().then(function(){ 
     toy.save(); 
    }, 
    function(err){ 
     alert('error', err); 
    }); 

Answer 3

Die Antworten sind nicht mehr aktuell. Ember Daten unterstützt nun eingebettete Datensätze, die Sie genau das tun können, was Sie suchen zu tun, das ist die vollständige Objektgraph in einer großen Nutzlast zu erhalten und zu senden. Zum Beispiel werden, wenn Ihre Modelle wie folgt aufgebaut:

App.Child = DS.Model.extend({ 
    name: DS.attr('string'), 
    age: DS.attr('number'), 
    toys: DS.hasMany('toy') 
}); 
App.Toy = DS.Model.extend({ 
    name: DS.attr('string'), 
    child: DS.belongsTo('child') 
}); 

Sie können eine benutzerdefinierte Serializer für Ihr Kind Modell definieren:

App.ChildSerializer = DS.RESTSerializer.extend(DS.EmbeddedRecordsMixin, { 
    attrs: { 
    toys: {embedded: 'always'} 
    } 
}); 

Dies sagt Ember Daten, die Sie anderen zeigen möchten ‚Spielzeug‘ zu als Teil der "Kind" -Nutzlast enthalten sein.Ihre HTTP-GET-Antwort von Ihrer API sollte wie folgt aussehen:

{ 
    "child": { 
    "id": 1, 
    "name": "Todd Smith", 
    "age": 5, 
    "toys": [ 
     {"id": 1, "name": "boat"}, 
     {"id": 2, "name": "truck"} 
    ] 
    } 
} 

Und wenn Sie Ihr Modell speichern, werden Ember Daten diese an den Server senden:

{ 
    "child":{ 
     "name":"Todd Smith", 
     "age":5, 
     "toys":[ 
     { 
      "id":"1", 
      "name":"boat", 
      "child":"1" 
     }, 
     { 
      "id":"2", 
      "name":"truck", 
      "child":"1" 
     } 
     ] 
    } 
} 

hier ein JSBin ist, das dies demonstriert.

http://emberjs.jsbin.com/cufaxe/3/edit?html,js,output

Im JSbin, wenn Sie die Schaltfläche ‚Speichern‘ klicken, werden Sie den Dev-Inspektor verwenden müssen, um die Anforderung zu sehen, die an den Server gesendet wird.