Rails 4.0 mit Entwickeln. Verschachtelte Attribute Unpermited Parameter

Arbeite ich an einer web-app mit Entwickeln und Rails 4. Ich habe eine Benutzer Modell, das ich verlängert mit 2 extra-Formular-Felder, so dass, wenn ein Benutzer sich anmeldet, er kann uns auch seinen ersten/letzten Namen. (basierend auf http://blog.12spokes.com/web-design-development/adding-custom-fields-to-your-devise-user-model-in-rails-4/). Ich will nun hinzufügen Institution Modell. Dieses Modell has_many :Benutzer und ein Benutzer belongs_to :institution. Ich möchte in der Lage sein zu registrieren, die institution name auf der gleichen form, die ich die Anmeldung. Ich weiß, ich muss ein nested_attribute in meinem Institution Modell, da dies die Eltern, die zeige ich in einem bit. Wenn ich versuche zu unterzeichnen, bis der Benutzer bekomme ich in der Konsole: Unpermited Parameter: Institutionen.

Mein Tipp ist, dass ich nicht aktualisieren kann, meine übergeordneten Klasse(Institution), basierend auf mein Kind Klasse (User). Vielleicht gibt es eine Lösung für dieses? Oder hat jemand ähnliches erlebt?

class Institutions < ActiveRecord::Base
    has_many :users, 
    accepts_nested_attributes_for :users
end

class User < ActiveRecord::Base
     devise :database_authenticatable, :registerable,
     :recoverable, :rememberable, :trackable, :validatable
     belongs_to :institution
end

Anmeldungen/neue.html-Code.erb Hier habe ich die geschachtelte form

<%= form_for(resource, :as => resource_name, :url => registration_path(resource_name)) do |f|     %>
<%= devise_error_messages! %>
.
. 
    <%= f.fields_for :institutions do |i| %>
        <p><%= i.label :name %><br />
        <%= i.text_field :institutions_attr %></p>
    <% end %>

Basiert auf der tutorial-ich gelinkt habe früher, habe ich eine neue User::ParameterSanitizer die erbt von der Entwickeln::ParameterSanitizer und überschreiben die sign_up - Methode wie folgt:

lib/user_sanitizer.rb

private
def sign_up
    default_params.permit(:first_name, :last_name ,:email, :password,  :password_confirmation, :current_password, institutions_attributes: [:id, :name])
end

Schließlich, meine application_controller.rb

class ApplicationController < ActionController::Base
  protect_from_forgery with: :exception

  protected
  def devise_parameter_sanitizer
    if resource_class == User
    User::ParameterSanitizer.new(User, :user, params)
    else 
    super
    end
  end
end

Danke für das Lesen!

Konsole params Ausgabe:

{"utf8"=>"✓",
 "authenticity_token"=>"JKuN6K5l0iwFsj/25B7GKDj7WEHR4DO3oaVyGxGJKvU=",
 "user"=>{"email"=>"[email protected]",
 "first_name"=>"abc",
 "last_name"=>"xyz",
 "institutions"=>{"name"=>"Government"},
 "password"=>"[FILTERED]",
 "password_confirmation"=>"[FILTERED]"},
 "commit"=>"Sign up"}

BEARBEITEN

Wie vorgeschlagen, habe ich Hinzugefügt,

params.require(resource_name).permit( :email, :first_name, :last_name, institution:  [:name], :password, :password_confirmation ) and I get an *error syntax error, unexpected ',', expecting => ...nstitution: [:name], :password, :password_confirmation )*

ABER, wenn ich Sie wieder Bearbeiten zu

params.require(resource_name).permit( :email, :first_name, :last_name, :password, :password_confirmation, institution:  [:name] )

Ich bekomme KEINE syntax-Fehler, aber ich bekomme Unpermited Parameter: Institutionen in der Anfrage.

Meine überzeugung ist, dass dies geschieht, weil Benutzer ist ein Kind der Einrichtung. Ich haben, jedoch nicht in der Lage war, eine Arbeit zu finden, um dieses.

InformationsquelleAutor der Frage Claudiu S | 2013-07-20

config/routes.rb

Erstellen Sie Ihre eigene Registrierung-controller wie so ... (sehen Sie Erarbeiten Unterlagen für die details von übergeordneten Steuerungen hier ...) ... was ist eleganter Weg, im Gegensatz zu tun es über die ApplicationController

devise_for :users, controllers: {registrations: 'users/registrations'}

app/Controller/users/registrations_controller.rb

Überschreiben, die neue Methode zu erstellen, eine Profile im Zusammenhang mit der User - Modell wie folgt ... laufen die configure_permitted_parameters Methode zu desinfizieren, bevor Sie die Parameter (beachten Sie, wie Sie geschachtelte Parameter)

class Users::RegistrationsController < Devise::RegistrationsController

  before_filter :configure_permitted_parameters

  # GET /users/sign_up
  def new

    # Override Devise default behaviour and create a profile as well
    build_resource({})
    resource.build_profile
    respond_with self.resource
  end

  protected

  def configure_permitted_parameters
    devise_parameter_sanitizer.for(:sign_up) { |u|
      u.permit(:email, :password, :password_confirmation, :profile_attributes => :fullname)
    }
  end
end

db/migrate/xxxxxxxxxxxxxx_create_profiles.rb

Dies ist die migration erzeugt, dass der Profile Modell (Hinweis: der Verweis auf User) ... in diesem Beispiel Profil nur hält fullname als eine Erweiterung der User aber fühlen Sie sich frei, um hinzuzufügen, wie Sie wünschen!

class CreateProfiles < ActiveRecord::Migration
  def change
    create_table :profiles do |t|
       t.references :user
       t.string :fullname
       t.timestamps
    end
  end
end

app/models/user.rb

class User < ActiveRecord::Base

  # Associations
  has_one :profile, dependent: :destroy, autosave: true

  # Allow saving of attributes on associated records through the parent,
  # :autosave option is automatically enabled on every association
  accepts_nested_attributes_for :profile

  # Devise
  # Include default devise modules. Others available are:
  # :confirmable, :lockable, :timeoutable and :omniauthable
  devise :database_authenticatable, :registerable,
         :recoverable, :rememberable, :trackable, :validatable
end

app/models/Profil.rb

class Profile < ActiveRecord::Base

  # Associations
  belongs_to :user

  # Validations
  validates :fullname, presence: true
end

app/views/devise/registrations/new.html

<% resource.build_profile if resource.profile.nil? %>
<%= form_for(resource, :as => resource_name,
                       :url => registration_path(resource_name)) do |f| %>
  <ul>

    <%= devise_error_messages! %>

    <li class="fullname">
      <%= f.fields_for :profile do |profile_fields| %>
        <%= profile_fields.label :fullname %>
        <%= profile_fields.text_field :fullname %>
      <% end %>
    </li>
    <li class="email">
      <%= f.label :email %>
      <%= f.email_field :email, :autofocus => true %>
    </li>
    <li class="password">
      <%= f.label :password %>
      <%= f.password_field :password %>
    </li>
    <li class="password">
      <%= f.label :password_confirmation %>
      <%= f.password_field :password_confirmation %>
    </li>
    <li>
      <%= f.submit %>
    </li>
    <li>
      <p><%= render "devise/shared/links" %></p>
    </li>
  </ul>
<% end %>

InformationsquelleAutor der Antwort King'ori Maina

13

Müssen Sie erstellen Ihre eigene Registrierung-controller zu tun, hier ist, wie:

Routen.rb
```
devise_for :users, controllers: {registrations: 'registrations'}
```
Controller

Müssen Sie ersetzen :your_fields durch die Felder, die Sie zulassen möchten (sorry, wenn das überlasse ich Ihnen, aber das macht meine Antwort eher allgemein, daher geeignet für jeden, der vorbei)
```
class RegistrationsController < Devise::RegistrationsController

  private

    def sign_up_params
      allow = [:email, :your_fields, :password, :password_confirmation]
      params.require(resource_name).permit(allow)
    end

end
```
Zusätzliche info (geschachtelte Attribute + einige Tests)

Beachten Sie auch, dass, wenn Sie mit Verein und accepts_nested_attributes_for Sie haben params so strukturiert

model: {field, field, field, associated_model: {field, field}}

Und natürlich müssen Sie die gleiche Struktur in Ihre sign_up_params Methode. Wenn Sie brauchen, um dies zu verstehen, können Sie den Inhalt der sign_up_params Methode wie diese:
```
    def sign_up_params
      params.require(resource_name).permit!
    end
```
Dass damit param, dann posten Sie Ihre form (es sollte dieses mal passieren) und schauen in Ihre rails-Konsole zu sehen, die Struktur der params schließlich können Sie set-up sign_up_params Methode richtig

Überprüfen Sie diese für mehr info http://www.railsexperiments.com/using-strong-parameters-with-nested-forms/

In Ihrem Fall sollten Sie verwenden:

params.require(resource_name).permit( :email, :first_name, :last_name, institutions: [:name], :password, :password_confirmation )

InformationsquelleAutor der Antwort Benj
5

Mit Schienen 5.1 und entwickeln 4.4.1 folgenden ist die kürzeste und funktioniert ziemlich gut:

app/models/user.rb
```
after_initialize do
  build_profile if new_record? && profile.blank?
end
```
app/controllers/application_controller.rb
```
before_action :configure_permitted_parameters, if: :devise_controller?

def configure_permitted_parameters
  devise_parameter_sanitizer.permit(:sign_up, keys: [{ profile_attributes: :name }])
end
```
Der Schlüssel hier ist, Sie kann ohne separaten controller:
- erlauben geschachtelte Attribute
- bauen, Bezug für form builder
InformationsquelleAutor der Antwort Aleksandr K.

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.