Michael Hartl's Rails Tutorial Kapitel 11 & 12: mehrere Fehler und Mails werden nicht gesendet

Question

Ich bin derzeit bei Schritt 12 mit dem Rails Tutorial und habe Probleme beim Versenden der account Aktivierungs E-Mails und Besuch bestimmter Seiten (ich bekomme Fehler)

Bei Anforderung das Zurücksetzen des Kennworts ich folgende Fehler

NameError in PasswordResetsController#create 

uninitialized constant User::FILL_IN 

Extracted source (around line #62): 

    def create_reset_digest 
    self.reset_token = User.new_token 

    (the code below is highlighted red) 

    update_columns(reset_digest: FILL_IN, reset_sent_at: FILL_IN) 

    end 

    # Sends password reset email. 

Quelle Wesen erhalten:

app/models/user.rb:62:in `create_reset_digest' 
app/controllers/password_resets_controller.rb:12:in `create' 

App /models/user.rb

class User < ApplicationRecord 
    attr_accessor :remember_token, :activation_token, :reset_token 
    before_save :downcase_email 
    before_create :create_activation_digest 
    validates :name, presence: true, length: { maximum: 50 } 
    VALID_EMAIL_REGEX = /\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i 
    validates :email, presence: true, length: { maximum: 255 }, 
        format: { with: VALID_EMAIL_REGEX }, 
        uniqueness: { case_sensitive: false } 
    has_secure_password 
    validates :password, presence: true, length: { minimum: 6 }, allow_nil: true 

    # Returns the hash digest of the given string. 
    def User.digest(string) 
    cost = ActiveModel::SecurePassword.min_cost ? BCrypt::Engine::MIN_COST : 
                BCrypt::Engine.cost 
    BCrypt::Password.create(string, cost: cost) 
    end 


    # Returns a random token. 
    def User.new_token 
    SecureRandom.urlsafe_base64 
    end 

    # Remembers a user in the database for use in persistent sessions. 
    def remember 
    self.remember_token = User.new_token 
    update_attribute(:remember_digest, User.digest(remember_token)) 
    end 

    # Returns true if the given token matches the digest. 
    def authenticated?(remember_token) 
    return false if remember_digest.nil? 
    BCrypt::Password.new(remember_digest).is_password?(remember_token) 
    end 

    # Forgets a user. 
    def forget 
    update_attribute(:remember_digest, nil) 
    end 

    def authenticated?(attribute, token) 
    digest = send("#{attribute}_digest") 
    return false if digest.nil? 
    BCrypt::Password.new(digest).is_password?(token) 
    end 

    # Activates an account. 
    def activate 
    update_columns(activated: FILL_IN, activated_at: FILL_IN) 
    end 

    # Sends activation email. 
    def send_activation_email 
    UserMailer.account_activation(self).deliver_now 
    end 

    # Sets the password reset attributes. 
    def create_reset_digest 
    self.reset_token = User.new_token 
    update_columns(reset_digest: FILL_IN, reset_sent_at: FILL_IN) 
    end 

    # Sends password reset email. 
    def send_password_reset_email 
    UserMailer.password_reset(self).deliver_now 
    end 

    # Returns true if a password reset has expired. 
    def password_reset_expired? 
    reset_sent_at < 2.hours.ago 
    end 

    private 

    # Converts email to all lower-case. 
    def downcase_email 
     self.email = email.downcase 
    end 

    # Creates and assigns the activation token and digest. 
    def create_activation_digest 
     self.activation_token = User.new_token 
     self.activation_digest = User.digest(activation_token) 
    end 
end 

app/controllers/password_resets_controller.rb

class PasswordResetsController < ApplicationController 
    before_action :get_user,   only: [:edit, :update] 
    before_action :valid_user,  only: [:edit, :update] 
    before_action :check_expiration, only: [:edit, :update] # Case (1) 

    def new 
    end 

    def create 
    @user = User.find_by(email: params[:password_reset][:email].downcase) 
    if @user 
     @user.create_reset_digest 
     @user.send_password_reset_email 
     flash[:info] = "Email sent with password reset instructions" 
     redirect_to root_url 
    else 
     flash.now[:danger] = "Email address not found" 
     render 'new' 
    end 
    end 

    def edit 
    end 

    def update 
    if params[:user][:password].empty? 
     @user.errors.add(:password, "can't be empty") 
     render 'edit' 
    elsif @user.update_attributes(user_params) 
     log_in @user 
     @user.update_attribute(:reset_digest, nil) 
     flash[:success] = "Password has been reset." 
     redirect_to @user 
    else 
     render 'edit' 
    end 
    end 

    private 

    def user_params 
     params.require(:user).permit(:password, :password_confirmation) 
    end 

    # Before filters 

    def get_user 
     @user = User.find_by(email: params[:email]) 
    end 

    # Confirms a valid user. 
    def valid_user 
     unless (@user && @user.activated? && 
       @user.authenticated?(:reset, params[:id])) 
     redirect_to root_url 
     end 
    end 

    # Checks expiration of reset token. 
    def check_expiration 
     if @user.password_reset_expired? 
     flash[:danger] = "Password reset has expired." 
     redirect_to new_password_reset_url 
     end 
    end 
end 

Wenn ich versuche, einen Benutzer ich folgende Fehler

NameError in UsersController#show 
uninitialized constant UsersController::FILL_IN 

Extracted source (around line #12): 

    def show 
    @user = User.find(params[:id]) 

    (the code below being red) 

    redirect_to root_url and return unless FILL_IN 

    end 

    def new 

Quelle erhalten zu sehen Sein:

app/controllers/users_controller.rb:12:in `show' 

app/controllers/users_controller.rb

class UsersController < ApplicationController 
    before_action :logged_in_user, only: [:index, :edit, :update, :destroy] 
    before_action :correct_user, only: [:edit, :update] 
    before_action :admin_user,  only: :destroy 

    def index 
    @users = User.where(activated: FILL_IN).paginate(page: params[:page]) 
    end 

    def show 
    @user = User.find(params[:id]) 
    redirect_to root_url and return unless FILL_IN 
    end 

    def new 
    @user = User.new 
    end 

    def create 
    @user = User.new(user_params) 
    if @user.save 
     @user.send_activation_email 
     flash[:info] = "Please check your email to activate your account." 
     redirect_to root_url 
    else 
     render 'new' 
    end 
    end 

    def edit 
    @user = User.find(params[:id]) 
    end 

    def update 
    @user = User.find(params[:id]) 
    if @user.update_attributes(user_params) 
      flash[:success] = "Profile updated" 
     redirect_to @user 
    else 
     render 'edit' 
    end 
    end 

    def destroy 
    User.find(params[:id]).destroy 
    flash[:success] = "User deleted" 
    redirect_to users_url 
    end 

    # Returns true if the given token matches the digest. 
    def authenticated?(attribute, token) 
    digest = send("#{attribute}_digest") 
    return false if digest.nil? 
    BCrypt::Password.new(digest).is_password?(token) 
    end 

    private 

    def user_params 
     params.require(:user).permit(:name, :company, :phone, :email, :password, 
            :password_confirmation) 
    end 

# Confirms a logged-in user. 
    def logged_in_user 
     unless logged_in? 
      store_location 
     flash[:danger] = "Please log in." 
     redirect_to login_url 
     end 
    end 

    # Confirms the correct user. 
    def correct_user 
     @user = User.find(params[:id]) 
     redirect_to(root_url) unless @user == current_user 
    end 

     def admin_user 
     redirect_to(root_url) unless current_user.admin? 
    end 

end 

Ich habe bei dieser seit Antworten auf verschiedene Beiträge über einem Tag gesucht und zurückzuverfolgen und meine Schritte redoing, aber ich habe keine Ahnung, was Ich habe etwas falsch gemacht.

Ich kann die Benutzerseiten besuchen und wenn ich Passwort bekomme ich Fehler vergessen einreichen

Answer 1

def index 
    @users = User. where(activated: true) . paginate(page: params[:page]) 
end 

def show 
    @user = User. find(params[:id]) 
    redirect_to root_url and return unless true 
end 

def activate 
    update_columns(activated: true, activated_at: Time.zone.now) 
end