typus-rails4 4.0.0.beta6

data/lib/typus/authentication/base.rb

@@ -0,0 +1,39 @@
+module Typus
+  module Authentication
+    module Base
+
+      def admin_user
+        @admin_user
+      end
+
+      def current_role
+        admin_user.role.to_sym
+      end
+
+      def authenticate
+      end
+
+      def check_if_user_can_perform_action_on_user
+      end
+
+      def check_if_user_can_perform_action_on_resources
+      end
+
+      def check_if_user_can_perform_action_on_resource
+      end
+
+      def check_resource_ownership
+      end
+
+      def check_resources_ownership
+      end
+
+      def set_attributes_on_create
+      end
+
+      def set_attributes_on_update
+      end
+
+    end
+  end
+end

data/lib/typus/authentication/devise.rb

@@ -0,0 +1,19 @@
+module Typus
+  module Authentication
+    module Devise
+
+      protected
+
+      include Base
+
+      def admin_user
+        send("current_#{Typus.user_class_name.underscore}")
+      end
+
+      def authenticate
+        send("authenticate_#{Typus.user_class_name.underscore}!")
+      end
+
+    end
+  end
+end

data/lib/typus/authentication/http_basic.rb

@@ -0,0 +1,18 @@
+module Typus
+  module Authentication
+    module HttpBasic
+
+      protected
+
+      include Base
+
+      def authenticate
+        @admin_user = FakeUser.new
+        authenticate_or_request_with_http_basic(Typus.admin_title) do |username, password|
+          username == Typus.username && password == Typus.password
+        end
+      end
+
+    end
+  end
+end

data/lib/typus/authentication/none.rb

@@ -0,0 +1,15 @@
+module Typus
+  module Authentication
+    module None
+
+      protected
+
+      include Base
+
+      def authenticate
+        @admin_user = FakeUser.new
+      end
+
+    end
+  end
+end

data/lib/typus/authentication/none_with_role.rb

@@ -0,0 +1,15 @@
+module Typus
+  module Authentication
+    module NoneWithRole
+
+      protected
+
+      include Base
+
+      def authenticate
+        @admin_user = MyFakeUser.new
+      end
+
+    end
+  end
+end

data/lib/typus/authentication/session.rb

@@ -0,0 +1,123 @@
+module Typus
+  module Authentication
+    module Session
+
+      protected
+
+      include Base
+
+      def authenticate
+        unless session[:typus_user_id] && admin_user && admin_user.active?
+          path = request.path != '/admin/dashboard' ? request.path : nil
+          deauthenticate(path)
+        end
+      end
+
+      def deauthenticate(return_to = nil)
+        session.delete(:typus_user_id)
+        redirect_to new_admin_session_path(return_to: return_to)
+      end
+
+      #--
+      # Return the current user. If role does not longer exist on the system
+      # admin_user will be signed out from the system.
+      #++
+      def admin_user
+        @admin_user ||= Typus.user_class.find_by_id(session[:typus_user_id])
+      end
+
+      #--
+      # This method checks if the user can perform the requested action.
+      # It works on models, so its available on the `resources_controller`.
+      #++
+      def check_if_user_can_perform_action_on_resources
+        if @item && @item.is_a?(Typus.user_class)
+          check_if_user_can_perform_action_on_user
+        else
+          not_allowed if admin_user.cannot?(params[:action], @resource.model_name)
+        end
+      end
+
+      #--
+      # Action is available on: edit, update, toggle and destroy
+      #++
+      def check_if_user_can_perform_action_on_user
+        is_current_user = (admin_user == @item)
+        current_user_is_root = admin_user.is_root? && is_current_user
+
+        case params[:action]
+        when 'edit'
+          # Edit other items is not allowed unless current user is root
+          # and is not the current user.
+          not_allowed if admin_user.is_not_root? && !is_current_user
+        when 'toggle', 'destroy'
+          not_allowed if admin_user.is_not_root? || current_user_is_root
+        when 'update'
+          # Admin can update himself except setting the status to false!. Other
+          # users can update their profile as the attributes (role & status)
+          # are protected.
+          status_as_boolean = params[@object_name][:status] == '1' ? true : false
+
+          status_changed = !(@item.status == status_as_boolean)
+          role_changed = !(@item.role == params[@object_name][:role])
+
+          root_changed_his_status_or_role = current_user_is_root && (status_changed || role_changed)
+          not_root_tries_to_change_another_user = admin_user.is_not_root? && !is_current_user
+
+          not_allowed if root_changed_his_status_or_role || not_root_tries_to_change_another_user
+        end
+      end
+
+      #--
+      # This method checks if the user can perform the requested action.
+      # It works on a resource: git, memcached, syslog ...
+      #++
+      def check_if_user_can_perform_action_on_resource
+        resource = params[:controller].remove_prefix.camelize
+        not_allowed if admin_user.cannot?(params[:action], resource, { special: true })
+      end
+
+      #--
+      # If item is owned by another user, we only can perform a show action on
+      # the item. Updated item is also blocked.
+      #++
+      def check_resource_ownership
+        if admin_user.is_not_root?
+
+          condition_typus_users = @item.respond_to?(Typus.relationship) && !@item.send(Typus.relationship).include?(admin_user)
+          condition_typus_user_id = @item.respond_to?(Typus.user_foreign_key) && !admin_user.owns?(@item)
+
+          not_allowed if (condition_typus_users || condition_typus_user_id)
+        end
+      end
+
+      #--
+      # Show only related items it @resource has a foreign_key (Typus.user_foreign_key)
+      # related to the logged user.
+      #++
+      def check_resources_ownership
+        if admin_user.is_not_root? && @resource.typus_user_id?
+          @resource = @resource.where(Typus.user_foreign_key => admin_user)
+        end
+      end
+
+      ##
+      # OPTIMIZE: This method should accept args.
+      #
+      def set_attributes_on_create
+        @item.send("#{Typus.user_foreign_key}=", admin_user.id) if @resource.typus_user_id?
+      end
+
+      ##
+      # OPTIMIZE: This method should accept args and not perform an update
+      #           because we are updating the attributes twice!
+      #
+      def set_attributes_on_update
+        if @resource.typus_user_id? && admin_user.is_not_root?
+          @item.update_attributes(Typus.user_foreign_key => admin_user.id)
+        end
+      end
+
+    end
+  end
+end

data/lib/typus/configuration.rb

@@ -0,0 +1,43 @@
+require 'erb'
+
+module Typus
+  module Configuration
+
+    # Read configuration from <tt>config/typus/*.yml</tt>.
+    def self.models!
+      @@config = {}
+
+      Typus.model_configuration_files.each do |file|
+        if data = YAML::load(ERB.new(File.read(file)).result)
+          @@config.merge!(data)
+        end
+      end
+
+      @@config
+    end
+
+    mattr_accessor :config
+    @@config = {}
+
+    # Read roles from files <tt>config/typus/*_roles.yml</tt>.
+    def self.roles!
+      @@roles = Hash.new({})
+
+      Typus.role_configuration_files.each do |file|
+        if data = YAML::load(ERB.new(File.read(file)).result)
+          # For some weird reason we can't use {}.compact
+          data = data.delete_if { |_, v| v.blank? }
+          data.each do |key, value|
+            @@roles[key] = @@roles[key].merge(value)
+          end
+        end
+      end
+
+      @@roles
+    end
+
+    mattr_accessor :roles
+    @@roles = Hash.new({})
+
+  end
+end

data/lib/typus/engine.rb

@@ -0,0 +1,4 @@
+module Admin
+  class Engine < Rails::Engine
+  end
+end

data/lib/typus/orm/active_record.rb

@@ -0,0 +1,10 @@
+if defined?(ActiveRecord)
+  require 'typus/orm/active_record/class_methods'
+  ActiveRecord::Base.extend Typus::Orm::ActiveRecord::ClassMethods
+
+  require 'typus/orm/active_record/search'
+  ActiveRecord::Base.extend Typus::Orm::ActiveRecord::Search
+
+  require 'typus/orm/active_record/admin_user'
+  ActiveRecord::Base.extend Typus::Orm::ActiveRecord::AdminUser::ClassMethods
+end

data/lib/typus/orm/active_record/admin_user.rb

@@ -0,0 +1,65 @@
+require 'active_support/concern'
+require 'bcrypt'
+require 'typus/orm/active_record/instance_methods'
+
+module Typus
+  module Orm
+    module ActiveRecord
+      module AdminUser
+
+        extend ActiveSupport::Concern
+        include Typus::Orm::ActiveRecord::InstanceMethods
+
+        included do
+          has_secure_password
+
+          # attr_protected :role, :status
+
+          validates :email, presence: true, uniqueness: true, format: { with: Typus::Regex::Email }
+          validates :password, length: { minimum: 8 }, allow_nil: true
+          validates :role, presence: true
+
+          serialize :preferences
+
+          before_save :set_token
+        end
+
+        module ClassMethods
+
+          def authenticate(email, password)
+            user = find_by_email_and_status(email, true)
+            user && user.authenticate(password) ? user : nil
+          end
+
+          def generate(*args)
+            options = args.extract_options!
+            options[:password] ||= Typus.password
+            options[:role] ||= Typus.master_role
+            options[:status] = true
+            user = new(options)
+            user.save ? user : false
+          end
+
+          def roles
+            Typus::Configuration.roles.keys.sort
+          end
+
+          def locales
+            Typus.available_locales
+          end
+
+        end
+
+        def locale
+          (preferences && preferences[:locale]) ? preferences[:locale] : ::I18n.default_locale
+        end
+
+        def locale=(locale)
+          self.preferences ||= {}
+          self.preferences[:locale] = locale
+        end
+
+      end
+    end
+  end
+end

data/lib/typus/orm/active_record/class_methods.rb

@@ -0,0 +1,104 @@
+module Typus
+  module Orm
+    module ActiveRecord
+      module ClassMethods
+
+        include Typus::Orm::Base::ClassMethods
+
+        # Model fields as an <tt>ActiveSupport::OrderedHash</tt>.
+        def model_fields
+          ActiveSupport::OrderedHash.new.tap do |hash|
+            columns.map { |u| hash[u.name.to_sym] = u.type.to_sym }
+          end
+        end
+
+        # Model relationships as an <tt>ActiveSupport::OrderedHash</tt>.
+        def model_relationships
+          ActiveSupport::OrderedHash.new.tap do |hash|
+            reflect_on_all_associations.map { |i| hash[i.name] = i.macro }
+          end
+        end
+
+        def typus_supported_attributes
+          [:virtual, :custom, :association, :selector, :dragonfly, :paperclip]
+        end
+
+        def typus_fields_for(filter)
+          ActiveSupport::OrderedHash.new.tap do |fields_with_type|
+            get_typus_fields_for(filter).each do |field|
+              typus_supported_attributes.each do |attribute|
+                if (value = send("#{attribute}_attribute?", field))
+                  fields_with_type[field.to_s] = value
+                end
+              end
+              fields_with_type[field.to_s] ||= model_fields[field]
+            end
+          end
+        end
+
+        def get_typus_fields_for(filter)
+          data = read_model_config['fields']
+          fields = case filter.to_sym
+                   when :index                  then data['index'] || data['list']
+                   when :new, :create           then data['new'] || data['form']
+                   when :edit, :update, :toggle then data['edit'] || data['form']
+                   else
+                     data[filter.to_s]
+                   end
+
+          fields ||= data['default'] || typus_default_fields_for(filter)
+          fields = fields.extract_settings if fields.is_a?(String)
+          fields.map(&:to_sym)
+        end
+
+        def typus_default_fields_for(filter)
+          filter.to_sym.eql?(:index) ? ['id'] : model_fields.keys
+        end
+
+        def virtual_attribute?(field)
+          :virtual if virtual_fields.include?(field.to_s)
+        end
+
+        def dragonfly_attribute?(field)
+          if respond_to?(:dragonfly_attachment_classes) && dragonfly_attachment_classes.map(&:attribute).include?(field)
+            :dragonfly
+          end
+        end
+
+        def paperclip_attribute?(field)
+          if respond_to?(:attachment_definitions) && attachment_definitions.try(:has_key?, field)
+            :paperclip
+          end
+        end
+
+        def selector_attribute?(field)
+          :selector if typus_field_options_for(:selectors).include?(field)
+        end
+
+        def association_attribute?(field)
+          reflect_on_association(field).macro if reflect_on_association(field)
+        end
+
+        def typus_filters
+          filters = ActiveSupport::OrderedHash.new.tap do |fields_with_type|
+            get_typus_filters.each do |field|
+              fields_with_type[field.to_s] = association_attribute?(field) || model_fields[field.to_sym]
+            end
+          end
+          # Remove unsupported filters!
+          filters.reject { |k, v| [:time].include?(v) }
+        end
+
+        def get_typus_filters
+          data = read_model_config['filters'] || ''
+          data.extract_settings.map(&:to_sym)
+        end
+
+        def typus_user_id?
+          columns.map(&:name).include?(Typus.user_foreign_key)
+        end
+
+      end
+    end
+  end
+end