ruby-on-rails - not - devise wiki

idear y múltiples modelos de "usuario"

Question

Estoy usando Rails 3.2 e ideo 2.0 y soy bastante nuevo en Rails.

Requisitos

Me gustaría lograr lo siguiente:

• tener 2 o más modelos de "usuario", ej. Miembro, Cliente, Admin
• todos los modelos comparten algunos campos obligatorios (por ejemplo, correo electrónico y contraseña)
• cada modelo puede tener algunos campos únicos (p. ej., compañía para el cliente solamente)
• algunos campos pueden compartirse pero no tener la misma validación (por ejemplo, se requiere un nombre para el Cliente pero opcional para el Miembro)
• todos los campos deben llenarse durante el proceso de registro, por lo que los formularios son diferentes
• el formulario de inicio de sesión debe ser único

Soluciones posibles

Busqué en Google y busqué StackOverflow durante bastante tiempo, pero nada me parece correcto (soy un chico de Java, lo siento :) y ahora estoy bastante confundido. Dos soluciones surgieron:

Usuario de un solo dispositivo

Esa es la respuesta más frecuente. Simplemente cree el Usuario de diseño predeterminado y cree relaciones entre Miembro -> Usuario y Cliente -> Usuario. Mi preocupación aquí es cómo puedo lograr un proceso de registro personalizado para cada modelo. Probé cosas diferentes pero todo terminó como un desastre.

Múltiples usuarios de diseño

Esto resuelve el proceso de registro personalizado, y parece correcto para mí, pero el formulario de inicio de sesión único es un bloqueador. Encontré una respuesta en SO ( Devise - login from two model ) que sugiere anular Devise :: Models :: Authenticatable.find_for_authentication (conditions). Eso parece complicado (?) Y como soy nuevo en los rieles, me gustaría saber si eso podría funcionar.

¡Gracias por su consejo!

Answer 1

¿Así que qué hay de malo? Simplemente ejecute rails g devise:views [model_name] , personalice cada formulario de registro y en config/initializer/devise.rb simplemente ponga config.scoped_views = true .

Answer 2

Bienvenido a Java guy =), espero que disfrutes del mundo de Rails. Simplemente, para resolver su problema tiene 2 soluciones:

1. Para cada usuario crea una tabla en la base de datos y el modelo correspondiente.
2. Cree una sola tabla en la base de datos y para cada tipo de usuario cree un modelo. Esto se llama herencia de tabla única (STI).

¿Cuál elegir? Depende de los atributos comunes de los roles. Si son casi comunes (por ejemplo, todos tienen un nombre, correo electrónico, móvil, ...) y algunos atributos son diferentes, recomiendo encarecidamente la solución de STI.

¿Cómo hacer el STI? 1. Simplemente cree el modelo y la tabla de usuario de diseño con el comando rails generate devise User 2. Agregue una columna llamada type with string tipo de datos a la tabla de usuario en la base de datos usando una migración. 3. Para cada tipo de usuario cree un modelo (por ejemplo, rails g model admin ) 4. Haga que la clase Admin herede del modelo de usuario

class Admin < User
end

Eso es lo que has hecho =) ... Yupeee

Para crear un administrador, ejecute el comando Admin.create(...) donde los puntos son los atributos de administrador, por ejemplo, el correo electrónico, el nombre, ...

Creo que esta question podría ayudarte

Answer 3

Encontré un camino por recorrer y estoy muy contento con él hasta ahora. Lo describiré aquí para otros.

Fui con la única clase de "usuario". Mi problema era lograr un proceso de registro personalizado para cada pseudo modelo.

model / user.rb:

class User < ActiveRecord::Base
devise :confirmable,
:database_authenticatable,
:lockable,
:recoverable,
:registerable,
:rememberable,
:timeoutable,
:trackable,
:validatable
# Setup accessible (or protected) attributes for your model
attr_accessible :email, :password, :password_confirmation, :remember_me, :role
as_enum :role, [:administrator, :client, :member]
validates_as_enum :role
## Rails 4+ for the above two lines
# enum role: [:administrator, :client, :member]
end

Luego, adapté http://railscasts.com/episodes/217-multistep-forms y http://pastie.org/1084054 para tener dos rutas de registro con un controlador anulado:

config / routes.rb:

get ''users/sign_up'' => ''users/registrations#new'', :as => ''new_user_registration''
get ''clients/sign_up'' => ''users/registrations#new_client'', :as => ''new_client_registration''
post ''clients/sign_up'' => ''users/registrations#create'', :as => ''client_registration''
get ''members/sign_up'' => ''users/registrations#new_member'', :as => ''new_member_registration''
post ''members/sign_up'' => ''users/registrations#create'', :as => ''member_registration''

controladores / usuarios / registrations_controller.rb:

Creé una clase de asistente que conoce los campos para validar en cada paso

class Users::RegistrationsController < Devise::RegistrationsController
# GET /resource/sign_up
def new
session[:user] ||= { }
@user = build_resource(session[:user])
@wizard = ClientRegistrationWizard.new(current_step)
respond_with @user
end
# GET /clients/sign_up
def new_client
session[:user] ||= { }
session[:user][''role''] = :client
@user = build_resource(session[:user])
@wizard = ClientRegistrationWizard.new(current_step)
render ''new_client''
end
# GET /members/sign_up
def new_member
# same
end
# POST /clients/sign_up
# POST /members/sign_up
def create
session[:user].deep_merge!(params[:user]) if params[:user]
@user = build_resource(session[:user])
@wizard = ClientRegistrationWizard.new(current_step)
if params[:previous_button]
@wizard.previous
elsif @user.valid?(@wizard)
if @wizard.last_step?
@user.save if @user.valid?
else
@wizard.next
end
end
session[:registration_current_step] = @wizard.current_step
if @user.new_record?
clean_up_passwords @user
render ''new_client''
else
#session[:registration_current_step] = nil
session[:user_params] = nil
if @user.active_for_authentication?
set_flash_message :notice, :signed_up if is_navigational_format?
sign_in(:user, @user)
respond_with @user, :location => after_sign_up_path_for(@user)
else
set_flash_message :notice, :"signed_up_but_#{@user.inactive_message}" if is_navigational_format?
expire_session_data_after_sign_in!
respond_with @user, :location => after_inactive_sign_up_path_for(@user)
end
end
end
private
def current_step
if params[:wizard] && params[:wizard][:current_step]
return params[:wizard][:current_step]
end
return session[:registration_current_step]
end
end

y mis puntos de vista son:

• new.rb
• new_client.rb incluyendo un parcial de acuerdo con el paso del asistente:
  • _new_client_1.rb
  • _new_client_2.rb
• new_member.rb incluyendo un parcial de acuerdo con el paso del asistente:
  • _new_member_1.rb
  • _new_member_2.rb

Answer 4

Estoy en zapatos similares a ti, después de probar todo tipo de acercamientos, fui con un único modelo de usuario, que pertenecería a roles polimórficos. Esta parece ser la forma más sencilla de lograr un inicio de sesión único.

El modelo de usuario contendría la información específica para el inicio de sesión solamente.

El modelo de Role almacenaría campos específicos para cada rol, así como otras asociaciones específicas del rol.

Los nuevos registros se personalizarían para cada tipo de usuario (roles) a través de controladores individuales y luego se construirían atributos anidados para el usuario.

class User < ActiveRecord::Base
#... devise code ...
belongs_to :role, :polymorphic => true
end
class Member < ActiveRecord::Base
attr_accessible :name, :tel, :city #etc etc....
attr_accessible :user_attributes #this is needed for nested attributes assignment
#model specific associations like
has_many :resumes
has_one :user, :as => :role, dependent: :destroy
accepts_nested_attributes_for :user
end

Rutas: solo cosas normales para el modelo de miembro.

resources :members
#maybe make a new path for New signups, but for now its new_member_path

Controlador: debe construir el usuario para los atributos anidados

#controllers/members_controller.rb
def new
@member = Member.new
@member.build_user
end
def create
#... standard controller stuff
end

views / members / new.html.erb

<h2>Sign up for new members!</h2>
<%= simple_form_for @member do |f| %>
# user fields
<%= f.fields_for :user do |u| %>
<%= u.input :email, :required => true, :autofocus => true %>
<%= u.input :password, :required => true %>
<%= u.input :password_confirmation, :required => true %>
<% end %>
# member fields
<%= f.input :name %>
<%= f.input :tel %>
<%= f.input :city %>
<%= f.button :submit, "Sign up" %>
<% end %>

Me gustaría señalar que NO HAY NECESIDAD de alcanzar gema nested_form; ya que el requisito es que el usuario solo puede pertenecer a un tipo de rol.