Implementazione di una relazione molti-a-molti con Backbone-Relational

Question

Ho una semplice applicazione che definisce due classi, uno Person e uno PersonGroup, in cui c'è una relazione molti-a-molti in atto. Una persona non può avere alcun gruppo, o essere assegnato a tutti i gruppi, e qualsiasi cosa nel mezzo.

L'esempio su backbonerelational.org suggerisce di utilizzare un modello intermedio per le relazioni molti-a-molti, tuttavia non riesco a far funzionare questo schema con il recupero (deserializzazione) e il salvataggio (serializzazione).

Quello che voglio fare è utilizzare Backbone di deserializzare un JSON simile al seguente:

{ 
    People: 
    [ 
     { 
      "ID": 1, 
      "Name": "John" 
     }, 
     { 
      "ID": 2, 
      "Name": "Bob" 
     }, 
     { 
      "ID": 3, 
      "Name": "Tim" 
     }, 
    ], 
    PeopleGroups: 
    [ 
     { 
      "ID": 1, 
      "Name": "Owners", 
      "People": 
      [ 
       1, 
       2 
      ], 
     }, 
     { 
      "ID": 2, 
      "Name": "Everyone", 
      "People": 
      [ 
       1, 
       2, 
       3 
      ], 
     }, 
    ] 
} 

sto usando Knockback/Knockout per l'associazione dati in modo che il problema è che ho bisogno di essere in grado di accedere al relazioni per riferimento. Un array di ID non mi fa nulla di buono, a meno che non riesca a creare un Knockback.CollectionObservable per racchiudere la raccolta e risolvere gli ID ai riferimenti.

Answer 1

Ho finito per farlo funzionare come volevo. La relazione Many-to-Many viene mantenuta nel database ma è possibile accedere alle relazioni solo nei miei modelli Backbone in una direzione. Ho deciso che i modelli Person sarebbero autonomi ei modelli PersonGroup avrebbero una raccolta di riferimenti ai modelli Persona a cui sono collegati.

I punti chiave qui che hanno reso tutto funzionante erano specificare includeInJSON: "ID" e rimuovere reverseRelation. Ciò consente comunque di accedere ai riferimenti ai modelli in JavaScript, ma serializza e deserializza correttamente in JSON. I modelli Person semplicemente non hanno accesso a una proprietà di navigazione per i gruppi in cui si trovano, tuttavia lo può esistere in più gruppi.

Ho semplicemente pensato che l'utilizzo di un elenco di ID richiedesse il salto attraverso gli anelli per risolvere i riferimenti, ma Backbone-relazionale sembra utilizzare l'archivio modello globale Backbone per risolvere i riferimenti per ID senza creare modelli duplicati. (ad esempio, tre diversi gruppi possono fare riferimento alla stessa Persona e solo un modello viene mai creato).

var Person = Backbone.RelationalModel.extend(
{ 
    idAttribute: "ID", 
}); 

var PersonGroup = Backbone.RelationalModel.extend(
{ 
    idAttribute: "ID", 

    relations: 
    [ 
     { 
      type: Backbone.HasMany, 
      key: "People", 
      relatedModel: "Person", 
      collectionType: "PersonCollection", 
      includeInJSON: "ID", 
     }, 
    ], 
}); 

Ed ecco il resto l'impianto idraulico se aiuta anyone.You può definire le Backbone.Collections come segue e li ottenere attraverso le richieste API distinte:

var PersonCollection = Backbone.Collection.extend(
{ 
    model: Person, 

    url: "/api/person", 
}); 

var PersonGroupCollection = Backbone.Collection.extend(
{ 
    model: PersonGroup, 

    url: "/api/persongroup", 
}); 

var PersonModels = new PersonCollection(); 

var GroupsModels = new PersonGroupCollection(); 

this.PersonModels.fetch(); 

this.GroupsModels.fetch(); 

this.People = kb.collectionObservable(
    this.PersonModels, 
    { 
     factories: 
     { 
      "models": PersonViewModel, 
     }, 
    } 
); 

this.PersonGroups = kb.collectionObservable(
    this.GroupsModels, 
    { 
     factories: 
     { 
      "models": PersonGroupViewModel, 
      "models.People.models": PersonViewModel, 
     }, 
    } 
); 

ho inserito la specifica Knockback.js raccolte per l'utilizzo dei collegamenti Knockout.js. Viene creato un solo ViewModel per modello in modo che il rilevamento delle modifiche venga propagato attraverso l'intera app.

Answer 2

Questa domanda ha circa due mesi, ma vorrei condividere che ho incontrato problemi simili relativi a relazioni molti-a-molti quando lavoravo con Backbone-relazionale. Questi problemi hanno portato alla stesura di una propria implementazione delle relazioni Backbone che supportano molti-a-molti senza un modello di collegamento tra: Backbone-JJRelational

io rispondo come uno degli autori, ma forse vale la pena di controllare su.
Il JSON avete inviato nella sua interrogazione, per esempio, sarebbe automaticamente deserializzato nel seguente modo:
Ogni PeopleGroups -model ha un attributo People che è una Backbone.Collection contenente gli opportuni People -Modelli e (ovviamente) il vizio -versa, quindi la relazione può essere facilmente accessibile da entrambi i lati (senza un modello di collegamento).
Alcuni concetti di Backbone-JJRelational sono simili a Backbone-relational (global model store, ad esempio).