Come gestire le relazioni in backbone.js

Question

Sono bloccato con come progettare la mia applicazione backbone.js per quanto riguarda le relazioni del mio modello.

Se ho un modello di evento, che ha un paio di relazioni, diciamo che un modello utente può avere molti eventi e il modello di evento può avere a sua volta molti commenti e partecipazioni. Un utente può avere molti commenti e la partecipazione può avere un utente e un evento. Wow, che casino!

Event has many Comments 
Event has many Participations 
Event has one User 

User has many Events 
User has many Participations 
User has many Comments 

Comment has one Event 
Comment has one User 

Participation has one User 
Participation has one Event 

Okey, quindi il mio pensiero è stato quello di caricare un elenco di eventi quando l'utente carica la pagina, e quando un utente fa clic su un evento caricare il resto delle informazioni su tale evento (commenti, partecipazioni e utente) .

Quindi la domanda è, dovrei usare una sorta di variabile globale per contenere tutti gli eventi, gli utenti e così via, e quando raccolgo informazioni dal server mettila lì (e controlla lì prima che prenda qualcosa dal server) , forse in una sorta di archivio locale (e come posso farlo usando backbone-relazionale?).

Un'altra idea che ho avuto è di lasciare che ogni evento abbia i propri dati indipendenti, il problema con questo è che probabilmente invierò dati ridondanti ogni volta che clicco su un evento.

Quale modo mi consiglia?

grazie!

Answer 1

In teoria è possibile caricare tutte le raccolte separate e quindi utilizzare il filtro locale sulle raccolte per acquisire i modelli rilevanti durante il rendering.

È necessario considerare i problemi di sicurezza con questo, naturalmente.

Non ero esattamente chiaro, almeno per me, dalla tua domanda, cosa farai con le informazioni che raccogli, ma cercherò di rispondere nel miglior modo possibile.

La mia ipotesi è che si dispone di una sorta di eventi con alcuni dati aggiuntivi e che è necessario visualizzare le informazioni relative a questo. Allora hai bisogno anche di essere in grado di fare cose come aggiungere commenti, ecc

Come ho detto, si potrebbe considerare di fare quanto segue:

var Events = Backbone.Collection.extend({ 
    url: '/events', // You might want to let the app return only an account's events or something, not just ALL events. 
    initialize: function(){ 
     this.fetch(); 
    } 
}); 

var Comments = Backbone.Collection.extend({ 
    url: '/comments', 
    initialize: function(){ 
     _.bindAll(this, 'getEventComments'); 
     this.fetch(); 
    }, 

    getEventComments: function(event_id){ 
     return _.filter(this.models, function(model){ return model.get('event_id') == event_id; }); 
    } 
}); 
//etc 

Utilizzando la funzione di filtro di sottolineatura si può molto rapidamente ottenere il relativo modelli ogni volta che ne hai bisogno (ad esempio durante il rendering).

In un modo questo è lo stesso come lo si fa nello scripting lato server. Alcuni database contengono tutte le tue tabelle con i record, come faranno le tue collezioni qui, e il tuo codice chiede semplicemente al database quelle rilevanti basate su alcuni input.

Infine, continuerò a indicare Require.js in combinazione con Backbone per le persone. Spudoratamente riferendosi ad una risposta che ho dato oggi, check it out, renderà la vita più facile non importa cosa: Backbone Design

Answer 2

Come @mu_is_too_short commentato, Backbone-relazionale potrebbe essere qualcosa che si sono interessati a guardare in. Con Backbone-relational i modelli e le raccolte di submodel vengono creati automaticamente e gli eventi possono essere gestiti attraverso la relazione genitore-figlio.

Ti darò solo un codice di esempio in modo da poterlo assaggiare. Parte del codice di esempio potrebbe essere simile a questa.

utente ha molti eventi:

User = Backbone.RelationalModel.extend({ 
    relations: [ 
     type: Backbone.HasMany, // Type of relationship 
     key: 'events',   // How we reference the sub-models in collection 
     relatedModel: 'Event', // The sub-model type 
     collectionType: 'EventCollection', // The sub-model collection 
     reverseRelation: { 
      key: 'belongsToUser'   // Key we use to refer to the parent 
     } 
    ], 
    // Other Backbone.Model properties and functions 
}); 

Quando si crea un modello di Backbone-relazionale, crea automaticamente una raccolta di sottomodelli per voi dal nome della 'chiave' che si designa. Quindi ogni utente che avrà avrà la propria raccolta di eventi correlati riordinati.

Fondamentalmente, quando si crea o si recupera l'utente, gli si forniscono riferimenti ai relativi modelli di cui ha bisogno. Ad esempio, il tuo ID utente = 1 potrebbe avere bisogno degli eventi 5, 7 e 11. (Sto solo usando gli ID). Finché questi riferimenti sono definiti in forma di matrice, è possibile caricarli in modo pigramente utilizzando i metodi fetchRelated di Relational.

myUser = new User(); 
myUser.set({ 
    name: 'RayMysterio', 
    age: '26', 
    events: [5, 7, 11] // Or this might just come with the User object from your server 
}); 

myUser.fetchRelated('events'); 
// This will go fetch the related events for this user model from the URL you designate. 

myUser.get('events'); 
// The collection of events are treated like an attribute of the User model. 

myUser.get('events').find(function(eventModel){ 
    return // some find condition - or whatever you want to do on that collection 
}); 

Potrebbe essere necessario associare determinati listener ai sottomodelli.

myUser.bind('add:events', function(model, collection) { 
    // Whatever code you want to happen when new models are added to the user events coll 
}); 

Ecc ecc

E 'un bel modo di produrre uno a uno, uno a molti, e le relazioni inverse. Questa è una chiave carina. Quando definisci una relazione tra i modelli e crei un modello.

E.g. si crea una nuova istanza del modello utente.

Backbone-relazionale crea automaticamente il collegamento inverso (il modello di evento ha un attributo definito dalla chiave della relazione inversa 'belongsToUser' (o qualsiasi altra cosa lo si chiami). Questo rende piuttosto comodo attraversare su e giù il modello/sotto- modello gerarchico.

in base alle vostre esigenze relazionali questa sembra una buona misura.

Se volete molti a molti, c'è un modo rotonda di farlo (usando modelli intermedi) ma ho trovato questo è un po 'traballante e lo evito Paul-Uithol ha aggiornato Backbone-Relational per qualche tempo e nuove funzionalità continuano ad essere aggiunte. La curva di apprendimento è stata un po' difficile per me all'inizio, ma una volta che inizi abituarsi ad esso è molto utile.

NOTA: solo per sottolineare, Mosselman ha raccomandato che Require.js ed io siamo anche d'accordo con questo. Ha reso il mio codice molto più gestibile. Puoi armeggiare (avvolgere) il codice relazionale Backbone per renderlo compatibile con AMD e funziona perfettamente con Require.

UPDATE: spina dorsale-relazionale ora supporta require.js dalla versione 0.8.8 il 1 Aprile 2014 - grazie Kenneth