[RUBY] [Rails] Implémentation d'une nouvelle fonction d'enregistrement au format assistant à l'aide de devise

introduction

Quand j'ai fait un site de copie de Furima, j'ai eu du mal car j'ai rendu la structure un peu difficile, alors j'ai décidé de le garder comme un disque. Si vous avez des suggestions, comme le rendre plus beau, s'il vous plaît.

Méthode de mise en œuvre

Environnement de développement

• Ruby 2.5.1
• Rails 5.0.7.2
• devise

supposition

--devise est déjà installé

• La fonction de connexion dans l'état par défaut du périphérique a été implémentée.
• Transition de la page 1 → page 2 → page d'accueil (connexion) --Il y a trois tables: ʻusers profiles`` envoi_destinations`
• La première page traite à la fois du «modèle de l'utilisateur» et du «modèle de profil» sous une forme.

• Reportez-vous à cet article pour savoir comment envoyer des valeurs à deux modèles en même temps. [Rails] Comment envoyer des valeurs à deux modèles en même temps en utilisant le formulaire de devise (exemple: modèle utilisateur et modèle de profil)

Conception DB

table des utilisateurs

table des profils

table send_destinations (adresse)

code

Créer un contrôleur

--Créer un contrôleur «utilisateurs» sous la gestion de la devise

Terminal

$ rails g devise:controllers users

• Définir le routage pour faire référence à quel contrôleur

routes.rb

Rails.application.routes.draw do
  devise_for :users, controllers: { registrations: 'users/registrations' }
  root to: 'items#index'
end

Décrivez l'association dans le modèle

--Description de l'association dans chaque modèle de ʻUser, Profile, Sending_destination`

• La validation est omise.

user.rb

class User < ApplicationRecord
  devise :database_authenticatable, :registerable,
         :recoverable, :rememberable, :validatable
  has_one :profile
  accepts_nested_attributes_for :profile
  has_one :sending_destination
end

profile.rb

class Profile < ApplicationRecord
  belongs_to :user, optional: true
end

sending_destination.rb

class SendingDestination < ApplicationRecord
  belongs_to :user, optional: true
end

ʻOptional: true` est une option qui permet à la clé externe d'être nulle.

Modifier la nouvelle action et la vue correspondante (page 1)

--Écrire une nouvelle action dans users / registrations_controller.rb

users/registrations_controller.rb

class Users::RegistrationsController < Devise::RegistrationsController
  #réduction
  def new
    @user = User.new
    @user.build_profile
  end 
  #réduction
end
 

--Modifier les inscriptions / new.html.haml correspondant à la nouvelle action

ruby:devise/registrations/new.haml.html

= form_for(@user, url: user_registration_path) do |f|
  = render "devise/shared/error_messages", resource: @user
  = f.text_field :nickname
  = f.email_field :email
  = f.password_field :password
  = f.password_field :password_confirmation
  = f.fields_for :profile do |p|
    = p.text_field :family_name
    = p.text_field :first_name
    = p.text_field :family_name_kana
    = p.text_field :first_name_kana
    = p.select :year
    = p.select :month
    = p.select :day
  = f.submit "prochain"

En fait, il existe des descriptions de div, d'étiquette et de classe, mais elles sont écrites simplement. Nous utilisons fields_for pour gérer les deux modèles. Je me réfère aux articles suivants. [Rails] Comment envoyer des valeurs à deux modèles en même temps en utilisant le formulaire de devise (exemple: modèle utilisateur et modèle de profil) [Rails] Comment enregistrer des données sur plusieurs modèles avec un seul form_for

Modifier l'action de création

• Vérification de validation des informations saisies sur la première page --Avoir les informations saisies à la page 1 en session --Créez une instance à utiliser pour l'enregistrement suivant des informations d'adresse et passez à la page appropriée Les trois points ci-dessus seront réalisés par l'action de création.

users/registrations_controller.rb

class Users::RegistrationsController < Devise::RegistrationsController
  #réduction
  def create
    @user = User.new(sign_up_params)
    @user.build_profile(sign_up_params[:profile_attributes])
    unless @user.valid?
      flash.now[:alert] = @user.errors.full_messages
      render :new and return
    end
    session["devise.regist_data"] = {user: @user.attributes}
    session["devise.regist_data"][:user]["password"] = params[:user][:password]
    session[:profile_attributes] = sign_up_params[:profile_attributes]
    @sending_destination = @user.build_sending_destination
    render :new_sending_destination
  end
  #réduction
  protected
  #réduction
end

Vérifiez si le paramètre viole la validation avec la méthode «valide?». La fonction session qui conserve les informations côté client est utilisée pour que les informations ne soient pas perdues même si la page change. Pour que la session contienne les informations sous la forme d'un objet de hachage, les données sont formatées à l'aide de la méthode des attributs. En outre, bien que les informations de mot de passe soient incluses dans les paramètres, les informations de mot de passe ne sont pas incluses lorsque les données sont formatées par la méthode des attributs. Vous devez donc attribuer à nouveau le mot de passe à la session. Créez une instance du modèle send_destination associé à l'instance @ user créée cette fois avec build_sending_destination. Ensuite, affichez la vue de l'action new_sending_destination qui affiche la page sur laquelle vous souhaitez enregistrer vos informations d'adresse.

Modifiez l'action new_sending_destination et la vue correspondante (page 2)

--Définir le routage de l'action new_sending_destination qui affiche la page d'enregistrement de l'adresse --Définir le routage de l'action create_sending_destination pour enregistrer l'adresse

routes.rb

Rails.application.routes.draw do
  devise_for :users, controllers: { registrations: 'users/registrations' }
  devise_scope :user do
    get 'sending_destinations', to: 'users/registrations#new_sending_destination'
    post 'sending_destinations', to: 'users/registrations#create_sending_destination'
  end

  root to: 'items#index'
end

--Créez le fichier de vue correspondant new_sending_destination.html.haml

ruby:devise/registrations/new_sending_destination.html.haml

= form_for @sending_destination do |f|
  = render "devise/shared/error_messages", resource: @sending_destination
  = f.text_field :family_name
  = f.text_field :first_name
  = f.text_field :family_name_kana
  = f.text_field :first_name_kana
  = f.text_field :post_code
  = f.text_field :prefecture
  = f.text_field :city
  = f.text_field :house_number
  = f.text_field :building_name
  = f.number_field :phone_number
  = f.submit "s'inscrire"  

modifier l'action create_sending_destination

• Contrôle de validation des informations d'adresse saisies sur la deuxième page
• Enregistrez les informations indiquant que le contrôle de validation a été effectué et les informations conservées au cours de la session en tant qu'informations utilisateur. --Supprimer la session --S'identifier

users/registrations_controller.rb

class Users::RegistrationsController < Devise::RegistrationsController
  #réduction
  def create_sending_destination
    @user = User.new(session["devise.regist_data"]["user"])
    @profile = @user.build_profile(session[:profile_attributes])
    @sending_destination = SendingDestination.new(sending_destination_params)
    unless @sending_destination.valid?
      flash.now[:alert] = @sending_destination.errors.full_messages
      render :new_sending_destination and return
    end
    @user.build_sending_destination(@sending_destination.attributes)
    @user.save
    @profile.save
    session["devise.regist_data"]["user"].clear
    session[:profile_attributes].clear
    sign_in(:user, @user)

    redirect_to root_path
  end

  protected

  def sending_destination_params
    params.require(:sending_destination).permit(
      :first_name,
      :family_name,
      :first_name_kana, 
      :family_name_kana, 
      :post_code, 
      :prefecture, :city, 
      :house_number, 
      :building_name, 
      :phone_number
    )
  end
end

Les informations conservées en session sont attribuées à chaque instance de «@ user» et «@ prfile». Vérifiez les informations d'adresse sur la deuxième page avec «valide?». Attribuez les paramètres envoyés à l'aide de build_sending_destination à @ user, qui contient la session suspendue. Puis enregistrez-le dans le tableau en utilisant la méthode save. Supprimez la session en utilisant la méthode «clear». Connectez-vous avec sign_in (: user, @user) et passez à la première page avec redirect_to root_path.

en conclusion

Il peut être implémenté par la méthode ci-dessus. En utilisant fields_for sur la première page, j'ai eu beaucoup de mal à assigner une session, mais grâce à cela, j'ai pu réfléchir à son fonctionnement. Je ne l'ai pas expliqué en détail, mais j'ai essayé d'écrire un article qui sert également de sortie, donc j'espère qu'il sera utile autant que possible.