3

So I have these tables:

create_table :users do |t|
  t.string :username
  t.string :email
  t.string :password_digest

  t.timestamps
end

create_table :rooms do |t|
  t.string :name
  t.string :password
  t.integer :size
  t.integer :current_size

  t.timestamps
end

create_table :rooms_users do |t|
  t.belongs_to :user, index: true
  t.belongs_to :room, index: true

  t.boolean :is_admin

  t.timestamps
end

I made it so, when I call Room.find(1).users I get a list of all the users in the room. However, I also want to be able to call something like Room.find(1).admins and get a list of users that are admins (where is_admin in rooms_users is true). How would I do that?

Thank you for your time!

Криси Стоянов
  • 348
  • 3
  • 13

2 Answers2

4

You want to use has_many through: instead of has_and_belongs_to_many. Both define many to many associations but has_many through: uses a model for the join rows.

The lack of a model makes has_and_belongs_to_many very limited. You cannot query the join table directly or add additional columns since the rows are created indirectly. 

class User < ApplicationRecord
  has_many :user_rooms
  has_many :rooms, through: :user_rooms
end

class Room < ApplicationRecord
  has_many :user_rooms
  has_many :users, through: :user_rooms
end

class UserRoom < ApplicationRecord
  belongs_to :user
  belongs_to :room
end

You can use your existing schema but you need to rename the table users_rooms to user_rooms with a migration - otherwise rails will deride the class name as Rooms::User.

class RenameUsersRooms < ActiveRecord::Migration[5.0]
  def change
    rename_table(:users_rooms, :user_rooms)
  end
end

However, I also want to be able to call something like Room.find(1).admins and get a list of users that are admins (where is_admin in rooms_users is true). How would I do that?

You want to use a left inner join:

User.joins(:user_rooms)
    .where(user_rooms: { room_id: 1, is_admin: true })

To roll that into the class you can setup an association with a scope applied:

class Room < ApplicationRecord
  has_many :user_rooms
  has_many :users, through: :user_rooms
  has_many :user_room_admins, class_name: 'UserRoom', ->{ where(is_admin: true) } 
  has_many :user_room_admins, through: :user_rooms, 
    class_name: 'User',
    source: :user
end
max
  • 96,212
  • 14
  • 104
  • 165
  • I am pretty sure you cannot (or should not) define two relations with the same name on the same object. Also, I think having `users_rooms` or `rooms_users` as a table name won't change the way Rails will deride the class. It will just call `camelize`. Otherwise a basic `has_many :relation_with_underscore` would be resolved to `Relation::With::Underscore` – MrYoshiji Nov 09 '17 at 18:31
  • No the naming actually matters. If you have plural ”things_something” rails will look for Things::Something. While the singular ‘thing_’ is not treated as a namespace. It’s a very common issue. It’s also why you can nest models without setting table_name. – max Nov 09 '17 at 18:36
  • You can declare two associations with the same name but the later will overwrite all the methods that the previous declaration created. – max Nov 09 '17 at 18:39
  • You are right about the pluralized name and how Rails resolve the constant name, I am surprised as I have several `has_many` relations having a pluralized part in the name and without a class_name option but I don't get any constant error. Is that a Rails 5 feature? I tested it with Rails 5 only – MrYoshiji Nov 09 '17 at 19:04
  • No Im pretty sure the behavior was the same in Rails 4 – max Nov 09 '17 at 23:20
0

You can define a proc in the has_many relation to set SQL clauses, like ORDER or WHERE:

# room.rb
has_many :rooms_users, class_name: 'RoomsUser'
has_many :users, through: :rooms_users
has_many :admins, 
  proc { where(rooms_users: { is_admin: true }) },
  through: :rooms_users,
  class_name: 'User',
  source: :users

# user.rb
has_many :administrated_rooms,
  proc { where(rooms_users: { is_admin: true }) },
  through: :rooms_users,
  class_name: 'Room',
  source: :rooms

You can simplify this with a simple scope defined in the RoomsUser model, something like:

# rooms_user.rb
scope :as_admins, -> { where(is_admin: true) }

And use it in the proc:

# user.rb
has_many :administrated_rooms,
  proc { as_admins },
  through: :rooms_users,
  class_name: 'Room',
  source: :rooms

source option explained:

With source: :users, we're telling Rails to use an association called :users on the RoomsUser model (as that's the model used for :rooms_users).

(from Understanding :source option of has_one/has_many through of Rails)

MrYoshiji
  • 54,334
  • 13
  • 124
  • 117
  • I did something similar and am still getting this error: ActiveRecord::HasManyThroughSourceAssociationNotFoundError: Could not find the source association(s) "admin" or :admins in model RoomsUsers. Try 'has_many :admins, :through => :rooms_users, :source => '. Is it one of user or room? – Криси Стоянов Nov 09 '17 at 16:04
  • @КрисиСтоянов I updated my answer. The `source` option is necessary for `has_many through` when the argument to the `has_many` is not the same name as the relation from the join record to the "end record". If you tell rails `Room has_many :users, through: :rooms_users`, it will guess that `RoomsUser` has a relation `has_many :users`. In your case, the `has_many` name is not the same so you have to tell rails which `source` relation it has to use to find the records. – MrYoshiji Nov 09 '17 at 16:42
  • Using the table name `rooms_users` will cause a missing constant error since rails will attempt to load `Rooms::User`. You either need to rename the table or set `self.table_name = 'rooms_users'`. The former is preferable. – max Nov 09 '17 at 17:11
  • Oh yeah, my answer was implying that the relation is an `has_many through` and not HABTM (which I thought was already the case since the join table has an extra field + timestamps and those are not included in a regular HABTM if I remember correctly). – MrYoshiji Nov 09 '17 at 18:24