authentasaurus 0.7.3 → 0.8.3

data/lib/action_view/authorization.rb

@@ -1,52 +0,0 @@
-# Defines authorization helpers for ActionController
-module ActionView::Authorization
-  
-  def self.included(base) # :nodoc:
-    base.send :include, InstanceMethods
-  end
-  
-  module InstanceMethods
-    private
-    # Returns an object of the current user
-    def current_user(user_model = nil)
-      user_model = User if user_model.nil?
-      return user_model.find session[:user_id] if session[:user_id]
-    end
-    
-    # Checks if the current user is logged in but takes no further action
-    def is_logged_in?(user_model = nil)
-      user_model = User if user_model.nil?
-      unless user_model.find_by_id(session[:user_id])
-        return false
-      end
-			return true
-    end
-    
-    # Checks if the current user has the appropriate permission
-    # 
-    # *ex*: has?(:write) or has?(:read, :users)
-    def has?(permission, area = nil, user_model = User)
-      return false unless is_logged_in? user_model
-      check = false
-      case permission
-      when :write
-        unless area
-          user_permissions = session[:user_permissions]
-          check = user_permissions[:write].find { |perm| perm==self.controller_name || perm=="all" }
-        else
-          user_permissions = session[:user_permissions]
-          check = user_permissions[:write].find { |perm| perm==area.to_s || perm=="all" }
-        end
-      when :read
-        unless area
-          user_permissions = session[:user_permissions]
-          check = user_permissions[:read].find { |perm| perm==self.controller_name || perm=="all" }
-        else
-          user_permissions = session[:user_permissions]
-          check = user_permissions[:read].find { |perm| perm==area.to_s || perm=="all" }
-        end
-      end
-      return check
-    end
-  end
-end

data/lib/active_record/acts_as_authenticatable.rb

@@ -1,111 +0,0 @@
-module ActiveRecord::ActsAsAuthenticatable
-  def self.included(base)
-    base.send :extend, ClassMethods
-    base.send :include, InstanceMethods
-  end
-  
-  module ClassMethods
-    
-    case Rails.application.config.authentasaurus[:hashing] 
-    when "SHA2"
-      require 'digest/sha2'
-    when "SHA1"
-      require 'digest/sha1'
-    when "MD5"
-      require 'digest/md5'
-    else
-      require 'digest/sha2'
-    end
-    
-    
-    ## Authenticates the username (or email) and password
-    def authenticate(username_or_email, password, remember = false)
-      user=self.find_by_username(username_or_email) || self.find_by_email(username_or_email)
-      if user
-        expected_password=encrypt_password(password, user.password_seed)
-        unless expected_password == user.hashed_password && user.active
-          user = nil 
-        else
-          user.create_remember_me_token if remember
-        end
-      end
-      return user
-    end
-    
-    ## Encrypts the password using the given seed
-		def encrypt_password(password, password_seed)
-			pass_to_hash=password + "Securasaurus" + password_seed
-			
-			case Rails.application.config.authentasaurus[:hashing] 
-      when "SHA2"
-        Digest::SHA2.hexdigest(pass_to_hash)
-      when "SHA1"
-        Digest::SHA1.hexdigest(pass_to_hash)
-      when "MD5"
-        Digest::MD5.hexdigest(pass_to_hash)
-      else
-        Digest::SHA2.hexdigest(pass_to_hash)
-      end
-			
-		end
-  end
-  
-  module InstanceMethods
-    def username=(username)      
-      super(username.downcase)
-    end
-    
-    ## Password attribute (used when creating a user)
-    def password
-      return @password
-    end
-  
-    def password=(pwd)
-      @password = pwd
-      return if pwd.blank?
-      create_salt
-      self.hashed_password = self.class.encrypt_password(@password, self.password_seed)
-    end
-  
-    ## New password attribute (used when editing a user)
-    def new_password
-      return @new_password
-    end
-    
-    def new_password=(pwd)
-      @new_password = pwd
-      return if pwd.blank?
-      create_salt
-      self.hashed_password = self.class.encrypt_password(@new_password, self.password_seed)
-    end
-    
-    def activate
-      self.update_attribute :active, true
-    end
-    
-    def deactivate
-      self.update_attribute :active, false
-    end
-
-    def create_remember_me_token
-      pass_to_hash=Time.now.to_i.to_s + "Securasaurus" + password_seed
-      self.update_attribute :remember_me_token, Digest::SHA1.hexdigest(pass_to_hash)
-      self.remember_me_token
-    end
-    
-    private
-		def new_password_blank? 
-			self.new_password.blank?
-		end
-		
-		## Creates password seed (salt)
-		def create_salt
-			self.password_seed = self.object_id.to_s + rand.to_s
-		end
-		
-		## Dont delete the last user
-		def dont_delete_admin
-		  raise "You cannot delete the last admin" if self.id == 1 || User.count == 1
-	  end
-  end
-end

data/lib/active_record/acts_as_authenticatable_validatable.rb

@@ -1,36 +0,0 @@
-module ActiveRecord::ActsAsAuthenticatableValidatable
-  def self.included(base)
-    base.send :extend, ActiveRecord::ActsAsAuthenticatable::ClassMethods
-    base.send :include, ActiveRecord::ActsAsAuthenticatable::InstanceMethods
-    base.send :extend, ClassMethods
-    base.send :include, InstanceMethods
-  end
-  
-  module ClassMethods
-    ## Authenticates the username (or email) and password
-    def authenticate(username_or_email, password, remember = false)
-      user=self.find_by_username(username_or_email) || self.find_by_email(username_or_email)
-      if user
-        expected_password=encrypt_password(password, user.password_seed)
-        unless expected_password == user.hashed_password && user.active && user.validation.nil?    
-          user = nil 
-        else
-          user.create_remember_me_token if remember
-        end
-      end
-      return user
-    end
-  end
-  
-  module InstanceMethods
-    private
-		def send_validation
-			unless self.active
-				validation = self.build_validation(:email => self.email, :validation_code => User.encrypt_password(self.username,self.password_seed))
-				unless validation.save
-					raise "Could not create validation record"
-				end
-			end
-		end
-  end
-end

data/lib/active_record/authenticatable.rb

@@ -1,64 +0,0 @@
-module ActiveRecord::Authenticatable
-  def self.included(base)
-    base.send :extend, ClassMethods
-  end
-  
-  module ClassMethods
-    def authenticatable(*args)
-      options = args.extract_options!
-      args = args.flatten
-      # Associations
-      belongs_to :group
-      has_many :permissions, :through => :group
-      # Validation
-      # basic attributes
-      validates_presence_of :username, :hashed_password, :password_seed, :email, :name
-      validates_uniqueness_of :username, :email
-      validates_format_of :username, :with => /^[a-z0-9]*([a-z0-9]{4})+[a-z0-9]*$/ # alpha-numeric only and at least 4 characters
-      validates_format_of :email, :with => %r{[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4}}
-      # password validations
-      validates_confirmation_of :password, :on => :create, :if => Proc.new {|user| user.hashed_password.nil? || user.password_seed.nil? }
-      validates_presence_of :password, :on => :create, :if => Proc.new {|user| user.hashed_password.nil? || user.password_seed.nil? }
-      validates_length_of :password, :minimum => 6, :on => :create, :if => Proc.new {|user| user.hashed_password.nil? || user.password_seed.nil? }
-      # new password
-      validates_confirmation_of :new_password, :on => :update, :unless => :new_password_blank?
-      validates_length_of :new_password, :minimum => 6, :on => :update, :unless => :new_password_blank?
-      # format of password
-      if args.include?(:strong_password)
-        validates_format_of :password, :with => %r{[a-z]}, :on => :create, :message => :"authenticatable.lower_case_password", :if => Proc.new {|user| user.hashed_password.nil? || user.password_seed.nil? }
-        validates_format_of :password, :with => %r{[A-Z]}, :on => :create, :message => :"authenticatable.upper_case_password", :if => Proc.new {|user| user.hashed_password.nil? || user.password_seed.nil? }
-        validates_format_of :password, :with => %r{[0-9]}, :on => :create, :message => :"authenticatable.digit_password", :if => Proc.new {|user| user.hashed_password.nil? || user.password_seed.nil? }
-        validates_format_of :password, :with => %r{[@$%!&]}, :on => :create, :message => :"authenticatable.symbol_password", :if => Proc.new {|user| user.hashed_password.nil? || user.password_seed.nil? }
-        # new password
-        validates_format_of :new_password, :with => %r{[a-z]}, :on => :update, :message => :"authenticatable.lower_case_password", :unless => :new_password_blank?
-        validates_format_of :new_password, :with => %r{[A-Z]}, :on => :update, :message => :"authenticatable.upper_case_password", :unless => :new_password_blank?
-        validates_format_of :new_password, :with => %r{[0-9]}, :on => :update, :message => :"authenticatable.digit_password", :unless => :new_password_blank?
-        validates_format_of :new_password, :with => %r{[@$%!&]}, :on => :update, :message => :"authenticatable.symbol_password", :unless => :new_password_blank?
-      end
-      
-      # Accessors
-      attr_accessor :password_confirmation, :new_password_confirmation
-      
-      # default data
-      class << self
-        attr_accessor :default_data
-      end
-      
-      @default_data = {}
-      
-      # dont delete admin
-      before_destroy :dont_delete_admin
-      
-      #validation
-      if args.include?(:validatable)
-        has_one :validation, :as => :user
-        after_create :send_validation
-        # include authentication methods including validation
-        include ActiveRecord::ActsAsAuthenticatableValidatable
-      else
-        # include authentication methods
-        include ActiveRecord::ActsAsAuthenticatable
-      end
-    end
-  end
-end

data/lib/active_resource/acts_as_authenticatable.rb

@@ -1,70 +0,0 @@
-module ActiveResource::ActsAsAuthenticatable
-  def self.included(base)
-    base.send :extend, ClassMethods
-    base.send :include, InstanceMethods
-  end
-  
-  module ClassMethods
-    ## Authenticates the username and password
-    def authenticate(username, password, remember = false)
-      case(self.format)
-      when ActiveResource::Formats::XmlFormat
-        user = self.new Hash.from_xml(self.post(:signin,:username => username, :password => password, :remember => remember).body).values.first
-      when ActiveResource::Formats::JsonFormat
-        user = self.new ActiveSupport::JSON.decode(self.post(:signin,:username => username, :password => password, :remember => remember).body)
-      else
-        user = self.new Hash.from_xml(self.post(:signin,:username => username, :password => password, :remember => remember).body).values.first
-      end
-      
-      unless user.nil?
-        if self.sync && !self.sync_to.nil?
-          last_update = user.attributes.delete "updated_at"
-          local_user = self.sync_to.find_or_initialize_by_username user.username, user.attributes
-          
-          unless local_user.new_record?
-            last_update_datetime = (last_update.kind_of?(String)) ? (DateTime.parse(last_update)) : (last_update)
-            
-            if local_user.updated_at < last_update_datetime
-              local_user.update_attributes user.attributes
-            end
-          else
-            local_user.password = password
-            local_user.password_confirmation = password
-            
-            local_user.hashed_password = user.hashed_password
-            local_user.password_seed = user.password_seed
-            
-            self.sync_to.default_data.each do |key,value|
-              local_user.send(key.to_s + '=', value)
-            end
-            
-            local_user.save
-          end
-        end
-      end
-      return user
-    end
-  end
-  
-  module InstanceMethods
-    def sync
-      if self.class.sync && !self.class.sync_to.nil?
-        user = self.dup
-        last_update = user.attributes.delete "updated_at"
-        local_user = self.class.sync_to.find_or_initialize_by_username user.username, user.attributes
-        
-        unless local_user.new_record?
-          local_user.update_attributes user.attributes            
-        else
-          self.sync_to.default_data.each do |key,value|
-            local_user.send(key.to_s + '=', value)
-          end          
-          
-          local_user.save
-        end
-      else
-        false
-      end
-    end
-  end
-end

data/lib/active_resource/authenticatable.rb

@@ -1,24 +0,0 @@
-require 'active_resource/acts_as_authenticatable'
-module ActiveResource::Authenticatable
-  def self.included(base)
-    base.send :extend, ClassMethods
-    
-  end
-  
-  module ClassMethods
-    
-    def authenticatable(*args)
-      self.unloadable
-      options = args.extract_options!
-      
-      self.site = options[:site] || Rails.application.config.authentasaurus[:modules][:remote][self.name.underscore.gsub(/_sync/, "").to_sym][:site]
-      self.element_name = options[:session_element].try(:to_s) || Rails.application.config.authentasaurus[:modules][:remote][self.name.underscore.gsub(/_sync/, "").to_sym][:session_element]
-      self.sync = options[:sync] || Rails.application.config.authentasaurus[:modules][:remote][self.name.underscore.gsub(/_sync/, "").to_sym][:sync]
-      self.sync_to = options[:sync_to].try(:to_s).try(:camelize).try(:constantize) || Rails.application.config.authentasaurus[:modules][:remote][self.name.underscore.gsub(/_sync/, "").to_sym][:sync_to].camelize.constantize
-      
-    
-      # include authentication methods
-      include ActiveResource::ActsAsAuthenticatable
-    end
-  end
-end

data/lib/authentasaurus/areas_controller.rb

@@ -1,78 +0,0 @@
-module Authentasaurus::AreasController
-  def self.included(base) # :nodoc:
-    base.send :extend, ClassMethods
-    base.send :include, InstanceMethods
-  end
-  
-  module ClassMethods
-  end
-  
-  module InstanceMethods
-    def index
-  		@areas= Area.find :all
-  		
-  		respond_to do |format|
-  			format.html
-  		end
-  	end
-  	
-  	def show
-  		@area = Area.find params[:id]
-  		
-  		respond_to do |format|
-  			format.html
-  		end
-  	end
-  	
-  	def new
-  		@area = Area.new
-  		
-  		respond_to do |format|
-  			format.html
-  		end
-  	end
-  	
-  	def create
-  		@area = Area.new params[:area]
-  		
-  		respond_to do |format|
-  			if @area.save
-  				format.html { redirect_to :action=>:index, :notice => "Area Created" }
-  			else
-  				flash.now[:alert] = I18n.t(:create_failed, :scope => [:authentasaurus, :messages, :areas])
-  				format.html { render :new }
-  			end
-  		end
-  	end
-  	
-  	def edit
-  		@area = Area.find params[:id]
-  		
-  		respond_to do |format|
-  			format.html
-  		end
-  	end
-  	
-  	def update
-  		@area = Area.find params[:id]
-  		
-  		respond_to do |format|
-  			if @area.update_attributes(params[:area])
-  				format.html { redirect_to :action => :index, :notice => "Area updated" }
-  			else
-  				flash.now[:alert] = I18n.t(:update_failed, :scope => [:authentasaurus, :messages, :areas])
-  				format.html { render :edit }
-  			end
-  		end
-  	end
-  	
-  	def destroy
-  		@area = Area.find params[:id]
-  		@area.destroy
-  		
-  		respond_to do |format|
-  			format.html { redirect_to :action=>:index }
-  		end
-  	end
-  end
-end

data/lib/authentasaurus/groups_controller.rb

@@ -1,79 +0,0 @@
-module Authentasaurus::GroupsController
-  def self.included(base) # :nodoc:
-    base.send :extend, ClassMethods
-    base.send :include, InstanceMethods
-  end
-  
-  module ClassMethods
-  end
-  
-  module InstanceMethods
-    def index
-  		@groups = Group.find :all
-  		
-  		respond_to do |format|
-  			format.html
-  		end
-  	end
-  	
-  	def show
-  		@group = Group.find params[:id]
-  		
-  		respond_to do |format|
-  			format.html
-  		end
-  	end
-  	
-  	def new
-  		@group = Group.new
-  		
-  		respond_to do |format|
-  			format.html
-  		end
-  	end
-  	
-  	def create
-  		@group = Group.new params[:group]
-  		
-  		respond_to do |format|
-  			if @group.save
-  				format.html { redirect_to :action=>:index, :notice => "Group created" }
-  			else
-  				flash.now[:alert] = I18n.t(:create_failed, :scope => [:authentasaurus, :messages, :groups])
-  				format.html { render :new }
-  			end
-  		end
-  	end
-  	
-  	def edit
-  		@group = Group.find params[:id]
-  		
-  		respond_to do |format|
-  			format.html
-  		end
-  	end
-  	
-  	def update
-  		@group = Group.find params[:id]
-  		
-  		respond_to do |format|
-  			if @group.update_attributes(params[:group])
-  				format.html { redirect_to :action => :index, :notice => "Group updated" }
-  			else
-  				flash.now[:alert] = I18n.t(:update_failed, :scope => [:authentasaurus, :messages, :groups])
-  				format.html { render :edit }
-  			end
-  		end
-  		
-  	end
-  	
-  	def destroy
-  		@group = Group.find params[:id]
-  		@group.destroy
-  		
-  		respond_to do |format|
-  			format.html { redirect_to :action=>:index }
-  		end	
-  	end
-  end
-end