meteorów żelazo Router zagnieżdżonych trasy

Question

Mam dwie kolekcje meteorów z relacji jeden-do-wielu: budynki i przestrzenie

Na mojej stronie budynku, chcę pokazać przestrzenie związane z budynkiem.

Na razie zrobiłem to w ten sposób:

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 

To nie działa jako taki, chyba dlatego, że kontekst danych jest szablonem spacesList nie taki sam jak ten zdefiniowany przez żelazny router do budowania.

Mogę zastąpić "+ każde spacje" przez "+ każdy ../spaces", ale nie wydaje mi się to bardzo ogólne rozwiązanie (co jeśli chcę użyć mojego szablonu listy spacji w innym kontekście?)

Więc starałem się określić kontekst danych w pomocników szablonu takiego:

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

Ale pojawia się komunikat o błędzie:

Spaces is not defined. 

więc jestem nieco zdezorientowany. Jaka jest metoda meteorytów do prawidłowego wdrożenia tras zagnieżdżonych?

Dziękujemy!

Edycja:

definicji zbierania odstępami: /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() 
) 

publikacje: /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

Po niektóre badania, w końcu wymyśliłem rozwiązanie:

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() 

Z dodatkowym publikacji:

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

Błędy były następujące:

• fakt, że definicja miejsca nie był owinięty w funkcji
• znaku @ params._id że Zastąpiłem niezbyt seksownym Router._currentController.params._id, ale nie mogłem znaleźć na to skrótu.

ja nadal nie wiem, czy jest to Meteor (najlepszy) sposób zarządzania zagnieżdżonych trasy ...

lepsza rekomendacja?

Answer 1

Po przejrzeniu wielu różnych opcji, w końcu znalazłem opcję żelaznego routera, którego wcześniej nie zauważyłem. To sprawia, że ​​magia.

Realizacja dróg zagnieżdżonych (przynajmniej w dwóch poziomach (nie spróbować więcej poziomów)) staje się znacznie łatwiejsze przy wykorzystaniu plonów:

Moja trasa to jedno:

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}) 

to są moje szablony:

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 

I wreszcie, mam pomocnika aby zarządzać menu:

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

Jest całkiem sprytny. Ładuje tylko podTemplate po kliknięciu w podmenu. To najlepszy znalazłem ...

Nadzieja to pomaga ...