fetty-generators 1.7.1 → 2.0.0

data/lib/generators/fetty/authentication/templates/controllers/reset_passwords_controller.rb

@@ -0,0 +1,45 @@
+class ResetPasswordsController < ApplicationController
+  skip_before_filter :authenticate_user!
+  
+  def new
+  end
+  
+  def create
+    if @user = User.first(:conditions => { :username => params[:login] }) || User.first(:conditions => { :email => params[:login] })
+      if @user.activated?
+        @user.send_forgot_password_instructions!
+        flash.now[:notice] = "We've sent an email to #{@user.email} containing instructions on how to reset your password."
+        render :action => 'new'
+      else
+        raise "Account has never been activated, please activate your account first before resetting your password."
+      end
+    else
+      raise "Could not find any account with that username / email address."
+    end
+  rescue Exception => e
+    flash.now[:alert] = e.message
+    render :action => 'new'
+  end
+  
+  def edit
+    unless @user = User.first(:conditions => { :id => params[:id], :token => params[:token] })
+      redirect_to new_reset_password_url, :alert => "Unable to find an account, Please follow the URL from your email / send the new reset instructions!"
+    end
+  end
+  
+  def update
+    if @user = User.first(:conditions => { :id => params[:id], :token => params[:token] })
+      if @user.reset_password(params[:password],params[:password_confirmation]) == UsersAuthentication::Status::Valid
+        redirect_to new_session_url, :notice => "Your password was successfully updated, Please login using your new password!"
+      else
+        raise "Unable to reset your password!"
+      end
+    else
+      raise "Unable to find an account, Please follow the URL from your email / send the new reset instructions!"
+    end
+  rescue Exception => e
+    flash.now[:alert] = e.message
+    render :action => 'edit'
+  end
+  
+end

data/lib/generators/fetty/authentication/templates/controllers/sessions_controller.rb

@@ -0,0 +1,30 @@
+class SessionsController < ApplicationController
+  skip_before_filter :authenticate_user!, :except => [:destroy]
+  
+  def new
+  end
+  
+  def create
+    @user = User.authenticate!(params[:login], params[:password])
+    if @user.is_a? User
+      set_session_or_cookies(@user,params[:remember_me])
+      redirect_to redirect_to_target_or_default_url, :notice => "Sign in successfully."
+    elsif @user == UsersAuthentication::Status::Unexist
+      raise "User account not found! please sign up first."
+    elsif @user == UsersAuthentication::Status::InvalidPassword
+      raise "Invalid username or password."
+    elsif @user == UsersAuthentication::Status::Inactivated
+      raise "Please activate your account first! check your email."
+    end
+  rescue Exception => e
+    set_session_or_cookies(nil)
+    flash.now[:alert] = e.message
+    render :action => 'new'
+  end
+  
+  def destroy
+    set_session_or_cookies(nil)
+    redirect_to root_url, :notice => "Successfully sign out."
+  end
+  
+end

data/lib/generators/fetty/authentication/templates/controllers/users_controller.rb

@@ -0,0 +1,78 @@
+class UsersController < ApplicationController
+  skip_before_filter :authenticate_user!, :except => [:index, :edit, :update, :destroy]
+  
+  def index
+    @users = User.all
+    
+    respond_to do |format|
+      format.html # index.html.erb
+      format.xml  { render :xml => @users }
+      format.js
+    end
+  end
+  
+  def show
+    @user = User.find(params[:id])
+  end
+  
+  def new
+    @user = User.new
+  end
+  
+  def create
+    @user = User.new(:username => params[:username], :email => params[:email], :password => params[:password], :password_confirmation => params[:password_confirmation])
+    if @user.save
+      @user.send_activation_mail
+      redirect_to new_session_url, :notice => "Activation link has been sent to your email. Please activate first!"
+    else
+      raise "Unable to create user account."
+    end
+  rescue Exception => e
+    flash.now[:alert] = e.message
+    render :action => 'new'
+  end
+  
+  def edit
+    @user = User.find(params[:id])
+  end
+  
+  def update
+    @user = User.find(params[:id])
+    if @user.update_attributes(:username => params[:username], :email => params[:email], :password => params[:password], :password_confirmation => params[:password_confirmation])
+      redirect_to user_path(@user), :notice => "Your profile has been updated."
+    else
+      raise "Unable to update your profile."
+    end
+  rescue Exception => e
+    flash.now[:alert] = e.message
+    render :action => 'edit'
+  end
+  
+  def destroy
+    @user = User.find(params[:id])
+    if current_user === @user
+      set_session_or_cookies(nil)
+      @user.destroy 
+      redirect_to new_session_url, :notice => "Your account has been deleted."
+    else
+      @user.destroy 
+      redirect_to users_url, :notice => "account has been deleted."
+    end
+  end
+  
+  def activate
+    @user = User.activate!(params[:id],params[:token])
+    if @user.is_a? User
+      set_session_or_cookies(@user)
+      redirect_to root_url, :notice => "Your account has been activated!"
+    elsif @user == UsersAuthentication::Status::Unexist
+      raise "Invalid user account and activation code"
+    elsif @user == UsersAuthentication::Status::Activated
+      raise "You already activated this account."
+    end
+  rescue Exception => e
+    set_session_or_cookies(nil)
+    redirect_to new_session_url, :alert => e.message
+  end
+  
+end

data/lib/generators/fetty/authentication/templates/helpers/reset_passwords_helper.rb

@@ -0,0 +1,2 @@
+module ResetPasswordsHelper
+end

data/lib/generators/fetty/authentication/templates/helpers/sessions_helper.rb

@@ -0,0 +1,2 @@
+module SessionsHelper
+end

data/lib/generators/fetty/authentication/templates/helpers/users_helper.rb

@@ -0,0 +1,2 @@
+module UsersHelper
+end

data/lib/generators/fetty/authentication/templates/lib/sessions_authentication.rb

@@ -0,0 +1,53 @@
+module SessionsAuthentication
+  
+  def self.included(receiver)
+    receiver.send :helper_method, :current_user, :user_signed_in?
+  end
+  
+  def current_user
+    @current_user ||= ( signin_from_session || signin_from_cookies )
+  end
+  
+  def user_signed_in?
+    current_user ? true : false
+  end
+  
+  def authenticate_user!
+    unless user_signed_in?
+      redirect_to new_session_url, :alert => "You must sign in first before accessing this page."
+    end
+  end
+  
+  def set_session_or_cookies(user,remember = false)
+    if user
+      @current_user = user
+      if remember
+        cookies.permanent.signed[:user_id] = user.id
+      else
+        session[:user_id] = user.id
+      end
+    else
+      @current_user = nil
+      session[:user_id] = nil if session[:user_id]
+      cookies.delete :user_id if cookies.signed[:user_id]
+      reset_session
+    end
+  end
+  
+  def signin_from_session
+    User.find(session[:user_id]) if session[:user_id]
+  end
+  
+  def signin_from_cookies
+    User.find(cookies.signed[:user_id]) if cookies.signed[:user_id]
+  end
+  
+  def redirect_to_target_or_default_url(default = root_url)
+    if request.env["HTTP_REFERER"].blank? || request.env["HTTP_REFERER"] == new_session_url
+      default
+    else 
+      request.env["HTTP_REFERER"]
+    end
+  end
+  
+end

data/lib/generators/fetty/authentication/templates/lib/users_authentication.rb

@@ -0,0 +1,110 @@
+module UsersAuthentication
+  
+  module ClassMethods
+    
+    def authenticate!(login, pass)
+      user = first(:conditions => { :username => login }) || first(:conditions => { :email => login })
+      case
+      when user.nil? then return UsersAuthentication::Status::Unexist
+      when !user.password_match?(pass) then return UsersAuthentication::Status::InvalidPassword
+      when !user.activated? then return UsersAuthentication::Status::Inactivated
+      else
+        return user
+      end
+    end
+    
+    def activate!(id,token)
+      user = first(:conditions => { :id => id, :token => token })
+      case
+      when user.nil? then return UsersAuthentication::Status::Unexist
+      when user.activated? then return UsersAuthentication::Status::Activated
+      else
+        user.update_attribute(:activated_at, Time.now.utc)
+        user.clear_token!
+        return user
+      end
+    end
+    
+  end
+  
+  module InstanceMethods
+    
+    def send_activation_mail
+      UserMailer.user_activation(self).deliver
+    end
+    
+    def send_forgot_password_instructions!
+      self.make_token!
+      UserMailer.user_forgot_password(self).deliver
+    end
+    
+    def reset_password(new_pass,new_pass_conf)
+      self.password = new_pass
+      self.password_confirmation = new_pass_conf
+      self.save
+      unless self.password_match?(new_pass)
+        return Status::Error
+      else
+        self.clear_token!
+        return Status::Valid
+      end
+    end
+    
+    def password_match?(pass)
+      self.password_hash == encrypt_password(pass)
+    end
+    
+    def activated?
+      !self.activated_at.nil?
+    end
+    
+    def make_token!
+      self.update_attribute(:token, generate_token)
+    end
+    
+    def clear_token!
+      self.update_attribute(:token, nil)
+    end
+    
+    private
+    
+    def generate_token
+      ActiveSupport::SecureRandom.urlsafe_base64
+    end
+    
+    def encrypt_password(pass)
+      BCrypt::Engine.hash_secret(pass, self.password_salt)
+    end
+    
+    def prepare_password
+      unless password.blank?
+        self.password_salt = BCrypt::Engine.generate_salt
+        self.password_hash = encrypt_password(password)
+      end
+    end
+    
+    def prepare_activation
+      self.token = generate_token
+    end
+    
+  end
+  
+  def self.included(receiver)
+    receiver.send :attr_accessor, :password, :password_confirmation
+    receiver.send :before_save, :prepare_password
+    receiver.send :before_create, :prepare_activation
+    
+    receiver.extend ClassMethods
+    receiver.send :include, InstanceMethods
+  end
+  
+  class Status
+    Valid = 0
+    Unexist = 1
+    InvalidPassword = 2
+    Inactivated = 3
+    Activated = 4
+    Error = 5
+  end
+  
+end

data/lib/generators/fetty/authentication/templates/mailers/setup_mail.rb

@@ -0,0 +1,11 @@
+ActionMailer::Base.smtp_settings = {
+  :address              => "smtp.gmail.com",
+  :port                 => 587,
+  :domain               => "your_app",
+  :user_name            => "your_username",
+  :password             => "your_password",
+  :authentication       => "plain",
+  :enable_starttls_auto => true
+}
+
+ActionMailer::Base.default_url_options[:host] = "localhost:3000"

data/lib/generators/fetty/authentication/templates/mailers/user_mailer.rb

@@ -0,0 +1,14 @@
+class UserMailer < ActionMailer::Base
+  default :from => "from@example.com"
+
+  def user_forgot_password(user)
+    @user = user
+    mail(:to => user.email, :subject => "Reset Password Instructions")
+  end
+  
+  def user_activation(user)
+    @user = user
+    mail(:to => user.email, :subject => "Account Activation")
+  end
+  
+end

data/lib/generators/fetty/authentication/templates/models/active_record/create_users.rb

@@ -0,0 +1,17 @@
+class CreateUsers < ActiveRecord::Migration
+  def self.up
+    create_table :users do |t|
+      t.string :username
+      t.string :email
+      t.string :password_hash
+      t.string :password_salt
+      t.datetime :activated_at
+      t.string :token
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :users
+  end
+end

data/lib/generators/fetty/authentication/templates/models/active_record/user.rb

@@ -0,0 +1,15 @@
+class User < ActiveRecord::Base
+  
+  attr_accessible :username, :email, :password, :password_confirmation, :activated_at, :token
+  
+  validates_presence_of :username, :email
+  validates_uniqueness_of :username, :email
+  validates_format_of :username, :with => /\A[-\w\._@]+\z/i, :message => "should only contain letters, numbers, or .-_@"
+  validates_format_of :email, :with => /\A[-a-z0-9_+\.]+\@([-a-z0-9]+\.)+[a-z0-9]{2,4}\z/i, :message => "not a valid email address"
+  validates_presence_of :password, :on => :create
+  validates_confirmation_of :password
+  validates_length_of :password, :minimum => 6
+  
+  include UsersAuthentication
+  
+end

data/lib/generators/fetty/authentication/templates/models/mongoid/user.rb

@@ -0,0 +1,23 @@
+class User
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  include UsersAuthentication
+  
+  attr_accessible :username, :email, :password, :password_confirmation, :activated_at, :token
+  
+  field :username, :type => String
+  field :email, :type => String
+  field :password_hash, :type => String
+  field :password_salt, :type => String
+  field :activated_at, :type => Time
+  field :token, :type => String
+  
+  validates_presence_of :username, :email
+  validates_uniqueness_of :username, :email
+  validates_format_of :username, :with => /\A[-\w\._@]+\z/i, :message => "should only contain letters, numbers, or .-_@"
+  validates_format_of :email, :with => /\A[-a-z0-9_+\.]+\@([-a-z0-9]+\.)+[a-z0-9]{2,4}\z/i, :message => "not a valid email address"
+  validates_presence_of :password, :on => :create
+  validates_confirmation_of :password
+  validates_length_of :password, :minimum => 6
+  
+end

data/lib/generators/fetty/authentication/templates/spec/controllers/reset_passwords_controller_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+describe ResetPasswordsController do
+  
+  describe "GET new" do
+    it "should render the reset password page" do
+      get :new
+      response.should be_success
+    end
+  end
+  
+  describe "POST create" do
+    describe "with valid login" do
+      it "should send reset password instructions through mail" do
+        user = Factory(:user, :activated_at => Date.today)
+        User.stub(:first).with(:conditions => { :username => "some@email.com" }).and_return(user)
+        post :create, :login => "some@email.com"
+        assigns(:user).should be_a(User)
+        flash[:notice].should_not be_nil
+      end
+    end
+    
+    describe "with invalid login" do
+      it "should not send reset password instructions if user not found" do
+        User.stub(:first).with(:conditions => { :username => "some@email.com" }).and_return(nil)
+        post :create, :login => "some@email.com"
+        assigns(:user).should be_nil
+      end
+      
+      it "should not send reset password instructions if user not activated" do
+        user = Factory(:user)
+        User.stub(:first).with(:conditions => { :username => "some@email.com" }).and_return(user)
+        post :create, :login => "some@email.com"
+        assigns(:user).should be_a(User)
+        assigns(:user).activated_at.should be_nil
+      end
+      
+      after(:each) do
+        flash[:alert].should_not be_nil
+      end
+    end
+    
+    after(:each) do
+      response.should render_template(:new)
+    end
+  end
+  
+  describe "GET edit" do
+    before(:each) do
+      @user = Factory(:user, :token => "sometoken")
+    end
+    
+    it "should assigns @user and render page if given parameters are valid" do
+      User.stub(:first).with(:conditions => { :id => @user.id.to_s, :token => @user.token.to_s }).and_return(@user)
+      get :edit, :id => @user.id.to_s, :token => @user.token.to_s
+      assigns(:user).should eql(@user)
+      response.should be_success
+    end
+    
+    it "should not render page and redirect to reset password page" do
+      User.stub(:first).with(:conditions => { :id => @user.id.to_s, :token => @user.token.to_s }).and_return(nil)
+      get :edit, :id => @user.id.to_s, :token => @user.token.to_s
+      assigns(:user).should be_nil
+      response.should redirect_to(new_reset_password_path)
+    end
+  end
+  
+  describe "PUT update" do
+    describe "with valid params" do
+      it "should reset password" do
+        user = Factory(:user, :token => "sometoken")
+        User.stub(:first).with(:conditions => { :id => user.id.to_s, :token => user.token.to_s }).and_return(user)
+        User.any_instance.stub(:reset_password).with("secret","secret").and_return(UsersAuthentication::Status::Valid)
+        put :update, :id => user.id.to_s, :token => user.token.to_s, :password => "secret", :password_confirmation => "secret"
+        assigns(:user).should eql(user)
+        flash[:notice].should_not be_nil
+        response.should redirect_to(new_session_path)
+      end
+    end
+    
+    describe "with invalid params" do
+      it "should not send reset password instructions if user not found" do
+        user = Factory(:user, :token => "sometoken")
+        User.stub(:first).with(:conditions => { :id => user.id.to_s, :token => user.token.to_s }).and_return(nil)
+        put :update, :id => user.id.to_s, :token => user.token.to_s
+        assigns(:user).should be_nil
+        flash[:alert].should_not be_nil
+        response.should render_template(:edit)
+      end
+    end
+  end
+
+end