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.