meteore percorsi nidificati ferro-router

Question

ho due collezioni di meteoriti con una relazione uno-a-molti: edifici e spazi

Sulla mia pagina di costruzione, voglio mostrare gli spazi relativi alla costruzione.

Per ora, l'ho fatto in questo modo:

buildingsRoute.coffee 
    BuildingController = RouteController.extend(template: "buildings") 
    Router.map -> 
     @route "building", 
     path: "/buildings/:_id" 
     waitOn: -> 
      subs.subscribe "allBuildings" 
      subs.subscribe "allSpaces" 

     data: -> 
      building: Buildings.findOne(@params._id) 
      spaces: Spaces.find({building_id: @params._id}) 

building.jade:

template(name="building") 
     +with building 
      .building 
       .page-header.position-relative 
        h1.inline #{name} 
       .row 
        .col-xs-12 
         +spacesList 

template(name="spacesList") 
    .widgets 
     .row 
      h1 Spaces 
      +each spaces 
       .col-xs-12.col-sm-6 
        .widget-box.widget-color-purple 
         .widget-header 
          a(href="{{pathFor 'space'}}") #{name} 
         .widget-body 
          p Content here 

Questo non funziona come tale, credo perché il contesto dati del modello spacesList è non uguale a quello definito dal router di ferro per la costruzione.

ho potuto sostituire "+ ciascuno spazi" con "+ ciascuno ../spaces", ma questo non sembra una soluzione molto generico per me (che cosa se voglio usare il mio modello spaceslist in un altro contesto?)

Così ho provato a definire il contesto dei dati in aiutanti di template in questo modo:

Template.spacesList.helpers 
    spaces: Spaces.find({building_id: @params._id}) 

Ma ottengo il messaggio di errore:

Spaces is not defined. 

Quindi sono un po 'confuso. Qual è il modo meteorologico per implementare correttamente i percorsi nidificati?

Grazie!

EDIT:

Definizione di raccolta Spaces: /models/space.coffee

@Spaces = new Meteor.Collection("spaces", 
    schema: 
    building_id: 
     type: String 
     label: "building_id" 
     max: 50 

    name: 
     type: String 
     label: "Name" 
     optional: true 
     max: 50 

    creation_date: 
     type: Date 
     label: "Creation date" 
     defaultValue: new Date() 
) 

Pubblicazioni: /server/publications.coffee

# Buildings 

    Meteor.publish "allBuildings", -> 
     Buildings.find() 

    Meteor.publish "todayBuildings", -> 
     Buildings.find creation_date: 
     $gte: moment().startOf("day").toDate() 
     $lt: moment().add("days", 1).toDate() 



    # Publish a single item 
    Meteor.publish "singleBuilding", (id) -> 
     Buildings.find id 


    # Spaces 
    # Publish all items 
    Meteor.publish "allSpaces", -> 
     Spaces.find() 

EDIT 2

Dopo alcune ricerche, ho finalmente trovato una soluzione:

Template.spacesList.helpers 
    spaces:() -> 
    if Router._currentController.params._id 
     subs.subscribe "buildingSpaces", Router._currentController.params._id 
     Spaces.find() 
    else 
     subs.subscribe "allBuildings" 
     Spaces.find() 
    nbr_spaces:() -> 
    Spaces.find().count() 

Con una pubblicazione supplementare:

# Publish all items for building 
Meteor.publish "buildingSpaces", (building_id) -> 
    Spaces.find({building_id: building_id}) 

Gli errori erano:

• il fatto che la definizione spazio non è stato avvolto in una funzione
• l'@ params._id che Ho sostituito Router._currentController.params._id non molto sexy ma non ho trovato nessun collegamento per questo.

Io ancora non so se questo è il modo Meteor (migliore) per gestire percorsi nidificati ...

Qualsiasi raccomandazione migliore?

Answer 1

Dopo aver esaminato un sacco di opzioni diverse, ho finalmente trovato un'opzione di iron-router che non avevo notato prima. Questo rende la magia.

L'attuazione di percorsi nidificati (almeno a due livelli (Non ho provato più livelli)) diventa molto più facile con l'uso dei rendimenti:

Il mio percorso è questo:

Router.map -> 
    @route "buildingSpaces", 
    path: "/buildings/:_id/spaces" 
    template: "building" 
    yieldTemplates: { 
     'buildingSpaces': {to: "subTemplate"} 
    } 
    waitOn: -> 
     [subs.subscribe("allSpaces"), 
     subs.subscribe "allBuildings"] 

    data: -> 
     building: Buildings.findOne(@params._id) 
     spaces: Spaces.find({building_id: @params._id}) 

Questi sono i miei modelli:

template(name="building") 
    .animated.fadeIn 
     +with building 
       .building 
        .page-header.position-relative 
         h1.inline #{name} 
        .row 
         .col-xs-12 
          .tabbable 
           ul.nav.nav-tabs 
            li#menu-spaces(class="{{isActive 'buildingSpaces'}}") 
             a(href="{{pathFor 'buildingSpaces'}}") #{nbr_spaces} Spaces 
            li#menu-dashboards(class="{{isActive 'buildingDashboards'}}") 
             a(href="{{pathFor 'buildingDashboards'}}") Dashboards 
           .tab-content 
            +yield "subTemplate" 


template(name="buildingSpaces") 
    .animated.fadeInDown 
     .page-header.position-relative 
      a.btn.btn-info.btn-sm#newSpaceButton 
       i.ace-icon.fa.fa-plus 
       | New space 
     .clearfix 
     +spacesList 

template(name="spacesList") 
    .widgets 
     .row 
      +each spaces 
       .col-xs-12.col-sm-6 
        .widget-box.widget-color-purple 
         .widget-header 
          a(href="{{pathFor 'space'}}") #{name} 
         .widget-body 
          p Content here 
    +insertSpaceForm 

E, infine, ho un aiuto per gestire il mio menu:

Handlebars.registerHelper "isActive", (template) -> 
    currentRoute = Router.current().route.name 
    if currentRoute and template is currentRoute then "active" 
    else "" 

È piuttosto lucido. Carica solo il sottotempo quando si fa clic sul sottomenu. E 'il migliore che ho trovato ...

Spero che questo aiuti ...