Question

I am currently trying to create a fairly simple association in Rails, but it is proving more difficult than I thought.

I have 3 models, User, Dealer and Role. User/dealer is many to many. Users can have many roles, but they should be specific to a dealership – i.e. a user can have the roles manager and director at one dealership, manager only at another, and be chairman in another.

The outcome I am looking for is that I will be able to do user.dealer.roles and (e.g. for the first dealer) it would return manager and director. The same would happen if I did dealer.user.roles.

My classes look as follows:

class User  :dealer_users
  has_many :dealer_user_roles, :through => :dealer_users
  has_many :roles, :through => :dealer_user_roles
end

class Dealer  :dealer_users
  has_many :dealer_user_roles, :through => :dealer_users
  has_many :roles, :through => :dealer_user_roles
end

class Role  :dealer_user_roles
  has_many :users, :through => :dealer_users
end

The tables look like (green tables):

I am trying to seed the database using the following code:

dealer = Dealer.where(name: Faker::Company.name).first_or_create
user = User.where(email: Faker::Internet.email).first_or_create
user.first_name = Faker::Name.first_name 
user.last_name = Faker::Name.last_name
user.password = 'password'
user.password_confirmation = 'password'
dealer.users  user.id).first.roles  1 + Random.rand(4))

This results in an error, which is: "Cannot modify association 'User#roles' because it goes through more than one other association."

Can anyone assist by telling me where I am going wrong, and how I can put it right?

Answer 1

Off the top of my head, I would model it as:

# Table name: users
#  id          :integer  not null, primary key
#  name        :string
class User
  has_many :employments
  has_many :dealers, :through => :employments
  has_many :roles, :through => :employments
end

# Table name: dealers
#  id          :integer  not null, primary key
#  name        :string
class Dealer
  has_many :employments
  has_many :users, :through => :employments
  has_many :roles, :through => :employments
end

# Table name: employments
#  id          :integer  not null, primary key
#  user_id     :integer  not null
#  dealer_id   :integer  not null
class Employment
 belongs_to :dealer, :inverse_of => :employments
 belongs_to :user,   :inverse_of => :employments
 has_many :roles
 scope :for_user,   lambda{ |user| where(:user_id => user.id) }
 scope :for_dealer, lambda{ |dealer| where(:dealer_id => dealer.id) }
end

# Table name: roles
#  id             :integer   not null, primary key
#  employment_id  :integer   not null
#  name           :string    not null
class Role
  belongs_to :employment
  scope :at_dealership, lambda{ |dealer| joins(:employment).where(:dealer_id => dealer.id) }
  scope :for_employee,  lambda{ |employee| joins(:employment).where(:user_id => employee.id) }
  # alternately:
  # scope :at_dealership, lambda{ |dealer| joins(:employment).where('employments.dealer_id = ?', dealer.id) }
  # scope :for_employee,  lambda{ |employee| joins(:employment).where('employments.user_id = ?',employee.id) }
end

This makes it easier to deal with, and also puts the roles where they actually belong – on the combination of user/dealer which I’ve called employment.

you can then say

dealer.users.first.roles 
# or
user.dealers.where('some condition').roles

EDIT: with scopes all of these should do what you want.

user = User.first
dealer = user.dealers.first

user.roles.at_dealership(dealer)

dealer.roles.for_employee(user)

dealer.employments.for_user(user).roles

user.employments.for_dealer(dealer).roles