brainsome_typus 4.0.0.beta1

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,41 @@
+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)
+          data.compact.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,17 @@
+module Admin
+  class Engine < Rails::Engine
+
+    initializer :assets do |config|
+
+      # Add all "frontend libraries" (bootstrap etc.) to the asset pipeline load path. 
+      # This is necessary because typus uses a nondefault directory structure in vendor/assets.
+      extra_asset_paths = Dir.glob(File.join(root, 'vendor/assets/*/{img,images,css,js}'))
+      Rails.application.config.assets.paths += extra_asset_paths
+
+      # Add nondefault image directory to the precompile array, otherwise images in there won't
+      # become available for the asset pipeline.
+      Rails.application.config.assets.precompile << %r{^img/.+}
+
+    end
+  end
+end

data/lib/typus/i18n.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+module Typus
+  module I18n
+
+    class << self
+
+      # Instead of having to translate strings and defining a default value to
+      # avoid "missing translation" messages:
+      #
+      #     I18n.t("Hello World!", :default => "Hello World!")
+      #
+      # We define a Typus translation method which will set up a default value
+      # for you: (Interpolation still works)
+      #
+      #     Typus::I18n.t("Hello World!")
+      #     Typus::I18n.t("Hello %{world}!", :world => @world)
+      #
+      def t(key, options = {})
+        options[:default] ||= key
+        ::I18n.t(key, options)
+      end
+
+      def default_locale
+        :en
+      end
+
+      def available_locales
+        {
+          "Brazilian Portuguese" => "pt-BR",
+          "Català" => "ca",
+          "German" => "de",
+          "Greek"  => "el",
+          "Italiano" => "it",
+          "English" => "en",
+          "Español" => "es",
+          "Français" => "fr",
+          "Magyar" => "hu",
+          "Portuguese" => "pt-PT",
+          "Russian" => "ru",
+          "中文" => "zh-CN",
+        }
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,84 @@
+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
+          attr_reader   :password
+          attr_accessor :password_confirmation
+
+          # attr_protected :role, :status
+
+          validates :email, :presence => true, :uniqueness => true, :format => { :with => Typus::Regex::Email }
+          validates :password, :confirmation => true
+          validates :password_digest, :presence => true
+          validate :password_must_be_strong
+          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.authenticated?(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::I18n.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
+
+        def authenticated?(unencrypted_password)
+          equal = BCrypt::Password.new(password_digest) == unencrypted_password
+          equal ? self : false
+        end
+
+        def password=(unencrypted_password)
+          @password = unencrypted_password
+          self.password_digest = BCrypt::Password.create(unencrypted_password)
+        end
+
+        def password_must_be_strong(count = 6)
+          if password.present? && password.size < count
+            errors.add(:password, :too_short, :count => count)
+          end
+        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

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

@@ -0,0 +1,76 @@
+module Typus
+  module Orm
+    module ActiveRecord
+      module InstanceMethods
+
+        def to_label
+          email
+        end
+
+        def resources
+          Typus::Configuration.roles[role.to_s].compact
+        end
+
+        def models
+          Typus.models.delete_if { |m| cannot?('read', m) }
+        end
+
+        def applications
+          Typus.applications.delete_if { |a| application(a).empty? }
+        end
+
+        def application(name)
+          Typus.application(name).delete_if { |r| !resources.keys.include?(r) }
+        end
+
+        def can?(action, resource, options = {})
+          resource = resource.to_s
+
+          return false if !resources.include?(resource)
+          return true if resources[resource].include?("all")
+
+          action = options[:special] ? action : action.acl_action_mapper
+
+          resources[resource].extract_settings.include?(action)
+        end
+
+        def cannot?(*args)
+          !can?(*args)
+        end
+
+        def is_root?
+          role == Typus.master_role
+        end
+
+        def is_not_root?
+          !is_root?
+        end
+
+        def active?
+          status && Typus::Configuration.roles.has_key?(role)
+        end
+
+        def locale
+          (preferences && preferences[:locale]) ? preferences[:locale] : ::I18n.default_locale
+        end
+
+        def locale=(locale)
+          self.preferences ||= {}
+          self.preferences[:locale] = locale
+        end
+
+        def owns?(resource)
+          id == resource.send(Typus.user_foreign_key)
+        end
+
+        def set_token
+          token = "#{SecureRandom.hex(6)}-#{SecureRandom.hex(6)}"
+          token.encode!('UTF-8') if token.respond_to?(:encode)
+          self.token = token
+        end
+        protected :set_token
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module Typus
+  module Orm
+    module ActiveRecord
+      module Search
+
+        include Typus::Orm::Base::Search
+
+        def build_search_conditions(key, value)
+          Array.new.tap do |search|
+            query = ::ActiveRecord::Base.connection.quote_string(value.downcase)
+
+            search_fields = typus_search_fields
+            search_fields = search_fields.empty? ? { "name" => "@" } : search_fields
+
+            search_fields.each do |key, value|
+              _query = case value
+                       when "=" then query
+                       when "^" then "#{query}%"
+                       when "@" then "%#{query}%"
+                       end
+
+              column_name = (key.match('\.') ? key : "#{table_name}.#{key}")
+              table_key = (adapter == 'postgresql') ? "LOWER(TEXT(#{column_name}))" : "#{column_name}"
+
+              search << "#{table_key} LIKE '#{_query}'"
+            end
+          end.join(" OR ")
+        end
+
+        # TODO: Use Rails scopes to build the search: where(key => interval)
+        def build_filter_interval(interval, key)
+          ["#{table_name}.#{key} BETWEEN ? AND ?", interval.first.to_s(:db), interval.last.to_s(:db)]
+        end
+
+        def build_my_joins(params)
+          query_params = params.dup
+          query_params.reject! { |k, v| !model_relationships.keys.include?(k.to_sym) }
+          query_params.compact.map { |k, v| k.to_sym }
+        end
+
+      end
+    end
+  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