Question

我正在创建一个有两种类型用户的rails应用程序：驱动程序和机制。

到目前为止，我有一个驱动程序类（称为＆＃34;用户＆＃34;）完全设置了配置文件和属性与＆＃34;汽车＆＃34;连接模型，以便他们可以将汽车添加到他们的个人资料中。

现在我需要创建＆＃34;机械师＆＃34;用户将像商业页面一样，提供地址，提供的服务等，然后这些机制将添加驱动程序作为他们的客户。

我的直觉是创建一个新的机制模型，并按照与用户模型相同的方式设置它，但使用适当的模式。我想我可能会遇到sessions helper的问题，因为＆＃34;用户＆＃34;用于很多功能。我可以在会话助手中复制这些项目并替换＆＃34; user＆＃34;和＆＃34;机械师＆＃34;，但我不确定这是否有效。

我考虑使用像cancancan这样的宝石来限制用户，但这似乎有问题。还想知道我是否可以使用当前用户＆＃34;类和创建两个继承自User的模型（驱动程序和机制），每个模型具有特定的功能。

我真的需要知道从哪个方向开始实现这一目标，所以任何建议，链接到有用的轨道演员等都会是惊人的。谢谢！

会话助手

module SessionsHelper

  # Logs in the given user.
  def log_in(user)
    session[:user_id] = user.id
  end

  # Remembers a user in a persistent session.
  def remember(user)
    user.remember
    cookies.permanent.signed[:user_id] = user.id
    cookies.permanent[:remember_token] = user.remember_token
  end

  def current_user?(user)
    user == current_user
  end

  # Returns the user corresponding to the remember token cookie.
  def current_user
    if (user_id = session[:user_id])
      @current_user ||= User.find_by(id: user_id)
    elsif (user_id = cookies.signed[:user_id])
      user = User.find_by(id: user_id)
      if user && user.authenticated?(cookies[:remember_token])
        log_in user
        @current_user = user
      end
    end
  end

  # Returns true if the user is logged in, false otherwise.
  def logged_in?
    !current_user.nil?
  end

  def forget(user)
    user.forget
    cookies.delete(:user_id)
    cookies.delete(:remember_token)
  end

  # Logs out the current user.
  def log_out
    forget(current_user)
    session.delete(:user_id)
    @current_user = nil
  end

  # Redirects to stored location (or to the default).
  def redirect_back_or(default)
    redirect_to(root_url)
    session.delete(:forwarding_url)
  end

  # Stores the URL trying to be accessed.
  def store_location
    session[:forwarding_url] = request.url if request.get?
  end
end

user.rb

class User < ActiveRecord::Base
  has_many :cars
  attr_accessor :remember_token
  before_save { self.email = email.downcase }
  validates :name,  presence: true, length: { maximum: 50 }
  VALID_EMAIL_REGEX = /\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i
  validates :email, presence: true, length: { maximum: 255 },
                    format: { with: VALID_EMAIL_REGEX },
                    uniqueness: { case_sensitive: false }
  has_secure_password
  validates :phone, presence:true
  validates :password, length: { minimum: 6 }, allow_blank: true

  # Returns the hash digest of the given string.
  def User.digest(string)
    cost = ActiveModel::SecurePassword.min_cost ? BCrypt::Engine::MIN_COST :
                                                  BCrypt::Engine.cost
    BCrypt::Password.create(string, cost: cost)
  end

  # Returns a random token.
  def User.new_token
    SecureRandom.urlsafe_base64
  end

  # Remembers a user in the database for use in persistent sessions.
  def remember
    self.remember_token = User.new_token
    update_attribute(:remember_digest, User.digest(remember_token))
  end

  # Returns true if the given token matches the digest.
  def authenticated?(remember_token)
    return false if remember_digest.nil?
    BCrypt::Password.new(remember_digest).is_password?(remember_token)
  end

  def forget
    update_attribute(:remember_digest, nil)
  end

  def feed
    Car.where("user_id = ?", id)
  end
end
        cookies.permanent.signed[:user_id] = user.id
        cookies.permanent[:remember_token] = user.remember_token
      end

      def current_user?(user)
        user == current_user
      end

      # Returns the user corresponding to the remember token cookie.
      def current_user
        if (user_id = session[:user_id])
          @current_user ||= User.find_by(id: user_id)
        elsif (user_id = cookies.signed[:user_id])
          user = User.find_by(id: user_id)
          if user && user.authenticated?(cookies[:remember_token])
            log_in user
            @current_user = user
          end
        end
      end

      # Returns true if the user is logged in, false otherwise.
      def logged_in?
        !current_user.nil?
      end

      def forget(user)
        user.forget
        cookies.delete(:user_id)
        cookies.delete(:remember_token)
      end

      # Logs out the current user.
      def log_out
        forget(current_user)
        session.delete(:user_id)
        @current_user = nil
      end

      # Redirects to stored location (or to the default).
      def redirect_back_or(default)
        redirect_to(root_url)
        session.delete(:forwarding_url)
      end

      # Stores the URL trying to be accessed.
      def store_location
        session[:forwarding_url] = request.url if request.get?
      end
    end

Answer 1

我建议将身份验证与授权分开，以略微改变您的设置。用户，驱动程序和机械师是分开但相关的概念。用户是可以访问您的应用程序机制的任何人，驱动程序是分配给用户的角色（他们有权做什么）。

有很多不同的方法可以解决这个问题，而且不知道你的应用程序的确切性质，很难建议一个特定的解决方案，但我认为如果你解决这些问题，你会在很长一段时间内好转。运行

这是一个很好的资源链接，可以帮助您入门：

http://railsapps.github.io/rails-authorization.html

Answer 2

使用cancan gem ..你可以在railscasts.com找到它的一集

Answer 3

我认为，devise gem应该有所帮助。

查看入门部分（https://github.com/plataformatec/devise/blob/master/README.md#getting-started），您可以在其中找到有关如何创建不同类型用户的信息。

希望有所帮助！

Answer 4

查看Pundit gem：https://github.com/elabs/pundit我在最近的项目中使用它并喜欢它。

创建两种类型的用户Rails应用程序

4 个答案: