ruby on rails - instalar - Rails 4/Devise/MongoDB: "Parámetros no permitidos" utilizando propiedades personalizadas y parámetros potentes

rspec rails devise

Question

Tratando de agregar un atributo personalizado anidado, Perfil (un documento de Mongoid), a mi clase de Usuario de diseño. Cuando se envía el formulario de registro Devise, debe crear también un Usuario y un objeto de Perfil correspondiente.

Me gustaría que el resultado final se vea así en mi MongoDB:

Usuario:

{
# Devise fields:
"email": "[email protected]",
...
# Custom field
"profile" : "<object_id>"
}

Perfil:

{
"first_name": "Dave",
....
}

Desafortunadamente, recibo esto en mi consola cada vez que envío mi registro. Crea con éxito un usuario pero no puede crear un perfil asociado.

Started POST "/" for 127.0.0.1 at 2013-04-20 23:37:10 -0400
Processing by Users::RegistrationsController#create as HTML
Parameters:
{"utf8"=>"✓",
"authenticity_token"=>"awN2GU8EYEfisU0",
"user"=>
{"profile_attributes"=>
{"first_name"=>"Dave",
"birthday(2i)"=>"4",
"birthday(3i)"=>"21",
"birthday(1i)"=>"1933",
"occupation_title"=>"Software Developer"},
"password"=>"[FILTERED]",
"password_confirmation"=>"[FILTERED]",
"email"=>"[email protected]"}}
Unpermitted parameters: profile_attributes

Tengo la configuración:

• Rails 4.0.0beta1, Ruby 2.0.0-p0
• Devise (rama ''rails4''), Mongoid (de git)
• Un controlador de registros Devise personalizado para agregar una definición de parámetros potentes.

modelos / user.rb:

class User
include Mongoid::Document
devise :database_authenticatable, :registerable,
:recoverable, :rememberable, :trackable, :validatable,
:token_authenticatable, :confirmable, :lockable, :timeoutable
field :email, type: String, default: ''''
...
has_one :profile
accepts_nested_attributes_for :profile
end

modelos / profile.rb:

class Profile
include Mongoid::Document
include Mongoid::Timestamps
# Attributes
# ----------
field :slug, type: String, default: '''' # Acts as user-''friendlier'' slug
field :birthday, type: DateTime, default: DateTime.now
field :first_name, type: String, default: ''''
field :occupation_title, type: String, default: ''''
belongs_to :user
embeds_many :photos
has_one :occupation_industry, :as => :industry
end

controladores / usuarios / registrations_controller.rb

class Users::RegistrationsController < Devise::RegistrationsController
def resource_params
params.require(:user).permit(:email, :password, :password_confirmation, :profile_attributes)
end
private :resource_params
end

routes.rb

devise_for :users,
:path => '''',
:path_names => {
:sign_in => ''login'',
:sign_out => ''logout'',
:sign_up => ''register''
},
:controllers => {
:registrations => "users/registrations",
:passwords => "users/passwords"
}

Ya he consultado estas publicaciones relacionadas, que no parecían ayudar:

• Rieles 4 Atributos anidados Parámetros no permitidos
• https://gist.github.com/kazpsp/3350730

EDITAR:

Parece que Devise realmente admite parámetros potentes en su rama ''rails4'' (que se supone que se fusionará con el maestro en unos pocos días). Al examinar el código, parece que puede anular una función params para cada acción en los controladores de diseño. Para crear nuevos usuarios, sign_up_params lugar de resource_params en mi ejemplo.

A pesar de cambiar este nombre al correcto, todavía no funcionaba ... solo la lista blanca de todos los parámetros que usaban este bang parecía funcionar:

def sign_up_params
params.require(:user).permit!
end

Obviamente, este tipo de derrota el propósito de los parámetros fuertes ... así que ahora la pregunta es ¿cómo puedo permitir mis atributos anidados profile_attributes (como se vio en mi pregunta original)?

Answer 1

Tuve el mismo problema al iniciar sesión, dice: Unpermitted parameters: password, remember_me . y porque tengo un controlador que hereda Devise :: SessionsController , entonces uso mi propio parámetro sanitizer .

esto es lo que hago:

Cree un archivo en ''# {Rails.root} / lib'' fold, my es hzsapa_parameter_sanitizer.rb y requerido en config / application.rb , luego anule el método devise_parameter_sanitizer en application_controller.rb

lib / hzsapa_parameter_sanitizer.rb

class HzsapaParameterSanitizer < Devise::ParameterSanitizer
def sign_in
default_params.permit(auth_keys + [:password, :remember_me])
end
end

Puede anular esos métodos según su problema:

def sign_in
default_params.permit(auth_keys)
end
def sign_up
default_params.permit(auth_keys + [:password, :password_confirmation])
end
def account_update
default_params.permit(auth_keys + [:password, :password_confirmation, :current_password])
end

config / application.rb

require "hzsapa_parameter_sanitizer"

app / application_controller.rb

class ApplicationController < ActionController::Base
# Prevent CSRF attacks by raising an exception.
# For APIs, you may want to use :null_session instead.
protect_from_forgery with: :exception
def devise_parameter_sanitizer
@devise_parameter_sanitizer ||= if defined?(ActionController::StrongParameters)
HzsapaParameterSanitizer.new(resource_class, resource_name, params)
else
Devise::BaseSanitizer.new(resource_class, resource_name, params)
end
end
end

Editar: acabo de encontrar la solución en el diseño de README, puedes seguirla aquí

Answer 2

¡Utilicé tu código y funcionó para mí!

Aquí esta lo que hice

class RegistrationsController < Devise::RegistrationsController
skip_before_filter :verify_authenticity_token, :only => :create #, :if => Proc.new { |c| c.request.format == ''application/json'' }
respond_to :json, :html, :xml
def create
user = User.new(devise_registrations_permitted_parameters)
if user.save
render :json=> user.as_json(:auth_token=>user.authentication_token, :email=>user.email,:name => user.name), :status=>201
return
else
warden.custom_failure!
render :json=> user.errors, :status=>422
end
end
protected
def devise_registrations_permitted_parameters
params.require(:user).permit(:name, :email, :password, :password_confirmation)
end
end

Answer 3

Encontré un método diferente que permite que todo el diseño de la lógica y el código primordiales residan en el controlador de la aplicación . Esto permite pasar todos y cada uno de los parámetros personalizados para cada acción de diseño (iniciar sesión, registrarse, actualizar). También agregué un sanitizador de parámetros para devise_invitable y manejo esa lógica aquí (invitar, accept_invitation). Tengo params personalizados como avatar, avatar_cache, etc.

#application_controller.rb
before_filter :configure_permitted_parameters, if: :devise_controller?
protected
# There are just three actions in Devise that allows any set of parameters to be passed down to the model,
# therefore requiring sanitization. Their names and the permited parameters by default are:
# sign_in (Devise::SessionsController#new) - Permits only the authentication keys (like email)
# sign_up (Devise::RegistrationsController#create) - Permits authentication keys plus password and password_confirmation
# account_update (Devise::RegistrationsController#update) - Permits authentication keys plus password, password_confirmation
# and current_password. More at https://github.com/plataformatec/devise#strong-parameters
def configure_permitted_parameters
devise_parameter_sanitizer.for(:accept_invitation) do |u|
u.permit(:username,:validate_username, :password,:password_confirmation, :invitation_token)
end
devise_parameter_sanitizer.for(:invite) do |u|
u.permit(:name,:comments)
end
devise_parameter_sanitizer.for(:sign_up) do |u|
u.permit(:username,:password,:password_confirmation)
end
devise_parameter_sanitizer.for(:sign_in) do |u|
u.permit(:username,:email,:password,:password_confirmation,:phone, :validate_username, :avatar_cache, :remove_avatar, :current_password,:remember_me)
end
devise_parameter_sanitizer.for(:account_update) do |u|
u.permit(:username,:email,:password,:password_confirmation,:phone, :validate_username,:avatar, :avatar_cache, :remove_avatar, :current_password)
end
end

Encuentre y lea más en https://github.com/plataformatec/devise#strong-parameters

Answer 4

Tuve exactamente el mismo problema y la invalidación sign_up_params funcionó para mí

def sign_up_params
params.require(:user).permit(:email, :password, :password_confirmation, :other, :etc)
end

por supuesto, la diferencia está en que los míos son solo valores escalares, mientras tratas de asignar en masa una relación ... Supongo que ahí es donde debes buscar.

Por cierto, la documentación sigue siendo inexistente en este tema (demasiado nueva), y los comentarios del código sugieren anular devise_parameter_sanitizer , que no es necesario.