multiple habtm relationships on one model

Question

I am trying to figure out the best way to accomplish my problem. I've got a pages table, and a user_types table. I am trying to specify multiple user types on a page. They will act as permission groups. I need to do this twice however. Once for read permissions, and once for edit permissions. Here is an example:

Home page has 3 user types that can read it - admin, super admin, public It has 2 user types that can edit it - admin, super admin

I have one user_types table: admin super admin public etc

I have created two mapping tables (one for read, and one for edit): pages_user_read_types pages_user_edit_types

they both have page_id, and user_type_id

Is there a better way to accomplish this? If this is the best way, I need help figuring out the relationships for the models. I have this for one relationship

  has_and_belongs_to_many :user_types, :join_table => :pages_user_read_types

How do i specify two relationships for seperate fields?

Thanks

Answer 1

At the very least, you probably want to add a Permission model. If it ever gets more complicated than what you've described, I would also recommend using CanCan.

class Permission < ActiveRecord::Base
  #table is id, page_id, user_type_id, and permission_type (string).
  belongs_to :page
  belongs_to :user_type
end

In your controller, you can construct a filter chain like this:

class PagesController < ApplicationController
  before_filter :load_page
  before_filter :authorize_view!, only: [ :show ]
  before_filter :authorize_edit!, only: [ :edit ]

  def show
  end

  def edit
  end

  private
    def load_page
      @page = Page.find(params[:id])
    end

    def authorize_view!
      if !@page.permissions.where(user_type_id: current_user.user_type_id, permission_type: "view").exists?
        flash[:notice] = "You do not have permission to view that page."
        redirect to root_path
      end
    end

    def authorize_edit!
      if !@page.permissions.where(user_type_id: current_user.user_type_id, permission_type: "edit").exists?
        flash[:notice] = "You do not have permission to edit that page."
        redirect to root_path
      end
    end

end

(This assumes you have a current_user method in your app).

Answer 2

The HABTM relationship in Rails has seemed to fall out of favor over the last couple of years with Rails developers to the has_many :through relationship. The only time you should use HABTM is when you have no need for any additional information about the relationship between two models. In your case, you are trying to emulate this by creating two HABTM relationships when you could effectively accomplish by having a join model with a editable attribute.

In code, it would look something like this:

class Page < ActiveRecord::Base
  has_many :page_permissions
  has_many :user_types, :through => page_permissions

  def editable_user_types
    page_permissions.includes(:user_types).where(:editable => true).map(&:user_type)
  end

  def read_only_user_types
    page_permissions.includes(:user_types).where(:editable => false).map(&:user_type)
  end      
end

class PagePermission < ActiveRecord::Base
  belongs_to :page
  belongs_to :user_type
  # When you create this model, you should have a boolean attribute for editable
end

class UserType < ActiveRecord::Base
  has_many :page_permissions
  has_many :pages, :through => :page_permissions
end

I think following this approach will allow you to consolidate to one join table which will be better in the future if you need to add additional attributes to the relationship (PagePermission) between Page and UserType.