如何使用has_many：通过关联为所有者和成员建模？

Question

In my rails application I have Event and User models. The business rules dictate that an Event has one owner and many members, and the owner must be a member. The inverse would be User having many 'owned events' and 'events' (events he/she is a member of but not the owner). I had originally planned to model this association like so:

class Event < ActiveRecord::Base
  has_many :event_members, dependent: :destroy

  has_one :owner, through: :event_members, source: :user, conditions: { owner: true }
  has_many :members, through: :event_members, source: :user
end

class EventMember < ActiveRecord::Base
  belongs_to :event
  belongs_to :user
end

class User < ActiveRecord::Base
  has_many :owned_events, through: :event_members, conditions: { owner: true }
  has_many :events, through: :event_members
end

I thought that this would ensure one owner and that owner would be included in the members association for free. However, this doesn't work since I can't specify a has_one through a collection - the :event_members association.

Is there a better way to model this? I could add a transient 'owner' attr on Event that queries EventMember by the owner flag - but will that work for setting the owner (ie can I grab the EventMember record that is created and make sure the owner flag is set)?

Answer 1

What about adding an owner attribute on the join model EventMember (also a field of type boolean in the event_members table, with default value of false ). Access the owner and owned_events with methods on each respective model.

class Event < ActiveRecord::Base             
  has_many :event_members
  has_many :members, :through => :event_members, :source => :user

  def owner                                  
    event_members.ownerships.map(&:user).first                                                              
  end                                        
end                                          

class EventMember < ActiveRecord::Base       
  belongs_to :event                          
  belogns_to :user

  scope :ownerships, -> { where(:owner => true) }                          
end                                          

class User < ActiveRecord::Base              
  has_many :event_members                    
  has_many :events, :through => :event_members

  def owned_events                           
    event_members.ownerships.map(&:event)      
  end                                        
end

The Event object may have the responsibility of making a user its owner.

class Event
  def make_owner!(user)
    membership = event_members.where(:user_id = user).first
    membership.owner = true
    membership.save
  end
end

Maybe place logic in there to enforce only one owner and abstract part of make_owner! to EventMember depending on how messy this gets in your application.