Associazioni polimorfiche di brace

Question

Qualcuno ha trovato una risposta per associazioni polimorfiche e dati di braci?

Avremmo bisogno di un modo per essere in grado di interrogare il tipo all'altra estremità della relazione da quello che posso dire.

Qualcuno ci pensa su questo?

Answer 1

Quindi ho qualcosa. Non è finito, o completamente pulito, ma funziona. Fondamentalmente, io uso un mixin per bypassare completamente le associazioni Ember. Sono sicuro che questo potrebbe essere inserito nell'adattatore o nello store, ma per ora funziona.

modelli polimorfici venire attraverso il JSON con un'itemId e itemType:

App.Follow = DS.Model.extend 
    user: DS.belongsTo('App.User') 
    itemId: DS.attr("number") 
    itemType: DS.attr("string") 

aggiungo un mixin ai modelli che sono associati con esso:

App.Hashtag = DS.Model.extend App.Polymorphicable, 
    follows:(-> 
    name: DS.attr("string") 
    @polymorphicFilter(App.Follow, "Hashtag") 
).property('changeCount') #changeCount gives us something to bind to 

    followers: (-> 
    @get('follows').map((item)->item.get('user')) 
).property('follows') 

Il mixin implementa tre metodi, uno che aggiorna il changeCount, uno che restituisce il tipo del modello e il metodo polymorphicFilter che filtra un modello per itemType e id:

App.Polymorphicable = Ember.Mixin.create 
    changeCount: 1 

    polymorphicFilter: (model, itemType)-> 
    App.store.filter model, 
     (data) => 
     if data.get('itemId') 
      @get('id') is data.get('itemId').toString() and data.get('itemType') is itemType 

    itemType:()-> 
    @constructor.toString().split('.')[1] 

    updatePolymorphicRelationships:()-> 
    @incrementProperty('changeCount') 

Lo strato di controllo è protetto da tutto questo jankyness, tranne che per dover chiamare updatePolymorphicRelationship per assicurarsi che il fuoco attacchi:

App.HashtagController = Ember.ObjectController.extend 
    follow:()-> 
    App.Follow.createRecord({ 
     user: @get('currentUserController.content') 
     itemId: @get('id') 
     itemType: @get('content').itemType() 
    }) 
    #this provides a way to bind and update. Could be refactored into a didSave() 
    #callback on the polymorphic model. 
    @get('content').updatePolymorphicRelationships() 
    App.store.commit() 

Questo è quello che ho finora. Sto cercando di mantenere le cose nel livello del modello poiché è solo un gradino rimosso dal livello dell'adattatore. Se sembra che Ember Data non guarderà i polimorfismi in futuro, allora avrebbe senso portare tutto a un livello più alto, ma per ora funziona e lascia i miei controllori (relativamente) puliti.

Answer 2

associazioni polimorfici sono ora supportati nei dati brace

https://github.com/emberjs/data/commit/e4f7c3707217c6ccc0453deee9ecb34bd65c28b9

Answer 3

Con le ultime tempora-data costruire ora è possibile utilizzare le associazioni polimorfiche:

È necessario configurare i modelli per rendere più polimorfa:

/* polymorphic hasMany */ 
App.User = DS.Model.extend({ 
messages: DS.hasMany(App.Message, {polymorphic: true}) 
}); 

App.Message = DS.Model.extend({ 
    created_at: DS.attr('date'), 
    user: DS.belongsTo(App.User) 
}); 

App.Post = App.Message.extend({ 
    title: DS.attr('string') 
}); 

/* polymorphic belongsTo */ 
App.Comment = App.Message.extend({ 
    body: DS.attr('string'), 
    message: DS.belongsTo(App.Message, {polymorphic: true}) 
}); 

È inoltre necessario configurare le proprietà alias sul tuo RESTAdapter

DS.RESTAdapter.configure('App.Post' { 
    alias: 'post' 
}); 
DS.RESTAdapter.configure('App.Comment' { 
    alias: 'comment' 
}); 

Il risultato atteso dal server dovrebbe essere simile a questo:

{ 
    user: { 
     id: 3, 
     // For a polymorphic hasMany 
     messages: [ 
      {id: 1, type: "post"}, 
      {id: 1, type: "comment"} 
     ] 
    }, 

    comment: { 
     id: 1, 
     // For a polymorphic belongsTo 
     message_id: 1, 
     message_type: "post" 
    } 
} 

maggiori informazioni in this github thread