Ассоциации активных записей: has_and_belongs_to_many, has_many: сквозная или полиморфная ассоциация?

Question

Приложение Ruby on Rails, над которым я работаю, позволяет users создавать и обмениваться agendas с другими users.

Кроме того, мы должны быть в состоянии:

• Отображать список agendas для каждого user, на его профиле
• Показать список users, связанный с agenda, на странице
в повестку дня в
• При совместном использовании повестки дня с другим пользователем определите role для этого пользователя и покажите роль этого пользователя в списке, указанном выше, выше

Я собирался пойти с has_and_belongs_to_many ассоциации между user и agenda моделей, как это:

class User < ActiveRecord::Base 
    has_and_belongs_to_many :agendas 
end 

class Agenda < ActiveRecord::Base 
    has_and_belongs_to_many :users 
end 

Но тогда я задавался ли это позволит мне получить и отобразить @user.agenda.user.role список roles на данный страницы повестки дня данного пользователя.

И я думал, что я должен, вероятно, пойти с has_many :through ассоциации вместо этого, таких как:

class User < ActiveRecord::Base 
    has_many :roles 
    has_many :agendas, through: :roles 
end 

class Role < ActiveRecord::Base 
    belongs_to :user 
    belongs_to :agenda 
end 

class Agenda < ActiveRecord::Base 
    has_many :roles 
    has_many :users, through: :roles 
end 

И хотя я был довольно комфортно об идее user, имеющих нескольких roles (по одному для каждого agenda), я я не уверен в идее agenda, имеющей несколько roles (по одному для каждого user?).

Наконец, чтобы добавить к путанице, я прочитал о полиморфной ассоциации и думал, что это может быть жизнеспособным решением, если сделано таким образом, к примеру:

class Role < ActiveRecord::Base 
    belongs_to :definition, polymorphic: true 
end 

class User < ActiveRecord::Base 
    has_many :roles, as: :definition 
end 

class Agenda < ActiveRecord::Base 
    has_many :roles, as: :definition 
end 

ли какой-либо из перечисленных выше решений звука правых для ситуации?

UPDATE: Выполнение некоторых исследований, я наткнулся на эту статью (с 2012 года), объясняя, что has_many :through был «умнее», чем выбор has_and_belongs_to_many. В моем случае я все еще не уверен в том, что у agenda будет много roles.

ОБНОВЛЕНИЕ 2: Как было предложено в комментариях от @engineersmnkyn, способом решения этого было бы пойти с двумя таблицами соединений. Я попытался реализовать следующий код:

class User < ActiveRecord::Base 
    has_many :agendas, through: :jointable 
end 

class Agenda < ActiveRecord::Base 

end 

class Role < ActiveRecord::Base 

end 

class Jointable < ActiveRecord::Base 
    belongs_to :user 
    belongs_to :agenda 
    has_many :agendaroles through :jointable2 
end 

class Jointable2 < ActiveRecord::Base 
    belongs_to :roles 
    belongs_to :useragenda 
end 

Я не уверен в синтаксисе. Я на правильном пути? И как мне определить модели Agenda и Role?

UPDATE 3: Что делать, если я пошел что-то вроде:

class User < ActiveRecord::Base 
     has_many :roles 
     has_many :agendas, through: :roles 
    end 

    class Role < ActiveRecord::Base 
     belongs_to :user 
     belongs_to :agenda 
    end 

    class Agenda < ActiveRecord::Base 
     has_many :roles 
     has_many :users, through: :roles 
    end 

, а затем, в файле миграции, идти с чем-то вроде:

class CreateRoles < ActiveRecord::Migration 
    def change 
    create_table :roles do |t| 
     t.belongs_to :user, index: true 
     t.belongs_to :agenda, index: true 
     t.string :privilege 
     t.timestamps 
    end 
    end 
end 

Смогу ли я позвонить @ user.agenda.privilege, чтобы получить привилегию («роль» создателя, редактора или зрителя) данного пользователя для данной повестки дня?

С другой стороны, мог бы я позвонить @ Agenda.user.privilege?

Answer 1

Хорошо, я предоставлю, сказав, что я не тестировал это, но я думаю, что один из этих двух вариантов должен хорошо работать для вас.

Также, если эти таблицы соединения никогда не нуждаются в функциональности помимо отношений, тогда has_and_belongs_to_many будет хорошо и сжато.

Основные Rails правило:

Если вам нужно работать с моделью отношений как своего собственного лица, использовать has_many: через. Используйте has_and_belongs_to_many при работе с устаревшими схемами или когда вы никогда не работаете напрямую с самими отношениями.

Во-первых, используя свой пример (http://repl.it/tNS):

class User < ActiveRecord::Base 
    has_many :user_agendas 
    has_many :agendas, through: :user_agendas 
    has_many :user_agenda_roles, through: :user_agendas 
    has_many :roles, through: :user_agenda_roles 

    def agenda_roles(agenda) 
    roles.where(user_agenda_roles:{agenda:agenda}) 
    end 
end 

class Agenda < ActiveRecord::Base 
    has_many :user_agendas 
    has_many :users, through: :user_agendas 
    has_many :user_agenda_roles, through: :user_agendas 
    has_many :roles, through: :user_agenda_roles 

    def user_roles(user) 
     roles.where(user_agenda_roles:{user: user}) 
    end 
end 

class Role < ActiveRecord::Base 
    has_many :user_agenda_roles 
end 

class UserAgenda < ActiveRecord::Base 
    belongs_to :user 
    belongs_to :agenda 
    has_many :user_agenda_roles 
    has_many :roles, through: :user_agenda_roles 
end 

class UserAgendaRoles < ActiveRecord::Base 
    belongs_to :role 
    belongs_to :user_agenda 
end 

Это использует таблицы объединения, чтобы держать связь пользователя < => Повестка дня, а затем таблицу, чтобы присоединиться к UserAgenda => Роль.

Второй вариант - использовать таблицу соединений, чтобы сохранить связь пользователя < => Повестка дня и другая таблица соединений для обработки отношений пользователя < => Повестка дня < => Роль. Эта опция будет немного больше настроена с точки зрения CRUD для таких вещей, как проверка того, является ли пользователь пользователем для этой Повестки, но обеспечивает небольшую гибкость.

class User < ActiveRecord::Base 
    has_many :user_agendas 
    has_many :agendas, through: :user_agendas 
    has_many :user_agenda_roles 
    has_many :roles, through: :user_agenda_roles 

    def agenda_roles(agenda) 
     roles.where(user_agenda_roles:{agenda: agenda}) 
    end 

end 

class Agenda < ActiveRecord::Base 
    has_many :user_agendas 
    has_many :users, through: :user_agendas 
    has_many :user_agenda_roles 
    has_many :roles, through: :user_agenda_roles 

    def user_roles(user) 
     roles.where(user_agenda_roles:{user: user}) 
    end 
end 

class Role < ActiveRecord::Base 
    has_many :user_agenda_roles 
end 

class UserAgenda < ActiveRecord::Base 
    belongs_to :user 
    belongs_to :agenda 
end 

class UserAgendaRoles < ActiveRecord::Base 
    belongs_to :role 
    belongs_to :user 
    belongs_to :agenda 
end 

Я знаю, что это длинный ответ, но я хотел показать вам более одного способа решить проблему в этом случае. Надеюсь, что это поможет