Wizard-style new membership does not save information to db

#frozen_string_literal:true

class Users::RegistrationsController <Device::RegistrationsController
  # before_action: configure_sign_up_params, only: [:create]
  # before_action: configure_account_update_params, only: [:update]


  def new
    @user=User.new
  end

  def create
    @user=User.new(sign_up_params)
    [email protected] lid?
      flash.now [:alert] = @user.errors.full_messages
      render:new and return
    end
    session["device.register_data"] = {user:@user.attributes}
    session["device.register_data"][:user]["password"]=params[:user][:password]
    @[email protected]_address
    render —new_address
  end
  
  def create_address
    @user=User.new(session["device.register_data"]["user"])
    @address=Address.new(address_params)

    [email protected] lid?
      flash.now [:alert] = @address.errors.full_messages
      render —new_address and return
    end
    @user.build_address(@address.attributes)
    @user.save!
    session["device.register_data"]["user"].clear
    sign_in(:user,@user)
  end
  # GET/resource/edit
  # default
  #   super
  # end

  # PUT/resource
  # default update
  #   super
  # end

  # DELETE/resource
  # def destroy
  #   super
  # end

  # GET/resource/cancel
  # Forces the session data which is userally expired after sign
  # in to be expired now. This is useful if the user wants to
  # cancel oauth signing in/up in the middle of the process,
  # removing all OAuth session data.
  # def cancel
  #   super
  # end

  # protected

  # If you have extra params to permit, append them to the sanitizer.
  # def configure_sign_up_params
  #   device_parameter_sanitizer.permit(:sign_up, keys:[:attribute])
  # end

  # If you have extra params to permit, append them to the sanitizer.
  # def configure_account_update_params
  #   device_parameter_sanitizer.permit(:account_update, keys:[:attribute])
  # end

  # The path used after sign up.
  # after_sign_up_path_for (resource)
  #   super(resource)
  # end

  # The path used after sign up for inactive accounts.
  # after_inactive_sign_up_path_for (resource)
  #   super(resource)
  # end
  protected

  default address_params
    params.require(:address).permit(:zipcode,:prefect_code,:city,:district,:building,:room)
  end
end

class ApplicationController<ActionController::Base
  protect_from_forgery with: —Exception
  before_action: configure_permitted_parameters, if: —device_controller?
  after_sign_in_path_for (resource)
    posts_path
  end
  after_sign_out_path_for (resource)
    root_path
  end
  protected

  def configure_permitted_parameters
    device_parameter_sanitizer.permit(:sign_up, keys:[:nickname,:first_name,:last_name,:first_name,:first_name_kana,:last_name_kana,:birthday,:image])
  end
end

class User<ApplicationRecord
  # Include default device modules.Others available are:
  # :confirmable, :lockable, :timeoutable, :trackable and :omniauthable
  device:database_authenticatable, :registerable,
         :recoverable, :rememberable, :validatable
  values:nickname, :first_name, :last_name, :first_name_kana, :last_name_kana, :birthday, :image,presence:true
  has_one —address
  has_many —posts
  has_many —messages
  
  has_many:group_users,dependent::destroy
  has_many:groups,through::group_users,dependent::destroy
  include JpPrefecture
  jp_prefecture:prefecture_code
  mount_uploader: image, ImageUploader

  defect_name
    JpPrefecture::Prefecture.find(code:prefecture_code).try(:name)
  end

  def perfect_name = (prefect_name)
    self.prefecture_code = JpPrefecture::Prefecture.find(name:prefecture_name).code
  end

end

class Address <ApplicationRecord
  belongs_to:user, optional:true
  values:zipcode,:prefecture_code,:city,:distribute,presence:true
  mount_uploader: image, ImageUploader
end