Raccolta backbone nelle raccolte

Question

Sto costruendo la mia prima vera applicazione web usando la dorsale e sto lottando con le risorse annidate.

Questa è una versione semplificata della risposta JSON con cui sto lavorando:

{ 
    "id": 1, 
    "title": "Test Survey", 
    "groups": [ 
    { 
     "id": 1, 
     "title": "Basic Questions", 
     "questions": [ 
     { 
      "id": 1, 
      "title": "Which is your favorite color?" 
     }, 
     { 
      "id": 2, 
      "title": "Do you have any other hobbies?" 
     } 
     ] 
    }, 
    { 
     "id": 2, 
     "title": "Working Questions", 
     "questions": [ 
     { 
      "id": 3, 
      "title": "Do you think working exp is very important?" 
     } 
     ] 
    } 
    ] 
} 

theres Fondamentalmente un oggetto Survey che ha molti gruppi, ogni gruppo ha molte domande.

Non riesco a capire un buon modo per ottenere tutti questi dati in modelli/collezioni.

Quello che ho attualmente è:

// Models 
var Question = Backbone.Model.extend({}); 
var Group = Backbone.Model.extend({}); 
var Survey = Backbone.Model.extend({ url: surveyURL }); 

// Collections 
var GroupsCollection = Backbone.Collection.extend({}); 
var QuestionsCollection = Backbone.Collection.extend({}); 

//Views 
var SurveyView = Backbone.View.extend({ 
    .. 
}); 

var GroupsCollectionView = Backbone.View.extend({ 
    .. 
}); 

var QuestionsCollectionView = Backbone.View.extent({ 
    .. 
}); 

var survey = new Survey({ groups: new GroupsCollection({model: Group}) }); 
var groupsView = new GroupsCollectionView({collection: survey.get('groups')}); 

Questo sembra funzionare per la nidificazione gruppi nel modello Survey, ma come faccio a memorizzare le domande in una raccolta e quindi assegnare che a ogni modello della collezione Gruppi ?

Come accennato, sono relativamente nuovo alla dorsale, quindi se sto percorrendo il percorso completamente sbagliato o c'è un modo migliore per farlo, fatemelo sapere.

Cheers.

Answer 1

solito dichiaro le mie collezioni sub come proprietà dei miei oggetti (I toglierle dal attributi hash: nel tuo esempio, questo significa riferimento survey.groups invece di survey.get('groups')) e utilizzare model.parse per popolare di loro.

Con il vostro modello di Survey:

var GroupsCollection = Backbone.Collection.extend({ 
    model: Group 
}); 

var Survey = Backbone.Model.extend({ 
    initialize: function(data) { 
     this.groups = new GroupsCollection(); 
     this.parse(data); 
    }, 
    parse: function(data) { 
     if (data.groups) { 
      this.groups.reset(data.groups); 
     } 
     return _.omit(data, 'groups'); 
    } 
}); 

La classe Group sarebbe stata dichiarata in modo simile. Passare i dati al costruttore:

var s = new Survey({ 
    "id": 1, 
    "title": "Test Survey", 
    "groups": [], 
    ... 
}); 

var g = s.groups.at(0); //first group 
var q = g.questions.at(0); //first question in the first group 

I dati vengono quindi attraversati per creare l'intera gerarchia.

e una demo http://jsfiddle.net/nikoshr/947Vf/

Answer 2

La risposta di cui sopra è stato un po 'pesante per il mio caso che mi portano a questa domanda. Questo può essere utile per chiunque altro cerchi.

Ho creato quattro raccolte. Dovevano essere contenuti in una collezione. Una Vista raccolta contiene altre quattro viste Raccolte, le cui viste secondarie (Viste semplici) restituiscono i dati.

Quando ho creato la collezione di avvolgimento

new Backbone.Collection([collectionA, collectionB, collectionC, collectionD])

ero tornato una collezione che conteneva quattro modelli, tutti di che erano Backbone modelli. Che andava bene fino a quando quei modelli non contenevano le mie collezioni.

Questo problema è stato risolto creando avvolgendo modelli, che contengono ciascuno una delle mie quattro raccolte.

var wrapperModelA = new Backbone.Model({ collection: collectionA }); 
... 
var wrapperModelD = new Backbone.Model({ collection: collectionD }); 

return new Backbone.Collection([wrapperModelA, ... , wrapperModelD]); 

Questo ha preservato le mie raccolte e mi ha permesso di creare una struttura di raccolta annidata senza definire nuove classi.