fesplugas-typus 0.9.0

data/generators/typus/typus_generator.rb

@@ -0,0 +1,141 @@
+class TypusGenerator < Rails::Generator::Base
+
+  def manifest
+
+    record do |m|
+
+      ##
+      # Default name for our application.
+      #
+
+      application = Rails.root.basename
+
+      ##
+      # To create <tt>application.yml</tt> and <tt>application_roles.yml</tt> detect 
+      # available AR models on the application.
+      #
+
+      models = Dir["#{Rails.root}/app/models/*.rb"].collect { |x| File.basename(x) }
+      ar_models = []
+
+      models.each do |model|
+        class_name = model.sub(/\.rb$/,'').classify
+        begin
+          klass = class_name.constantize
+          ar_models << klass if klass.superclass.equal?(ActiveRecord::Base)
+        rescue Exception => error
+          puts "=> [typus] #{error.message} on '#{class_name}'."
+        end
+      end
+
+      ##
+      # Configuration files
+      #
+
+      config_folder = Typus::Configuration.options[:config_folder]
+      folder = "#{Rails.root}/#{config_folder}"
+      Dir.mkdir(folder) unless File.directory?(folder)
+
+      configuration = { :base => '', :roles => '' }
+
+      ar_models.each do |model|
+
+        # By default we don't want to show in our lists text fields and created_at
+        # and updated_at attributes.
+        list = model.columns.reject { |c| c.sql_type == 'text' || %w( created_at updated_at ).include?(c.name) }.map(&:name)
+
+        # By default we don't want to show in our forms created_at and updated_at 
+        # attributes.
+        form = model.columns.reject { |c| %w( id created_at updated_at ).include?(c.name) }.map(&:name)
+
+        # By default we want to show all model columns in the show action.
+        show = model.columns.map(&:name)
+
+        # Detect relationships using reflection and remove the _id part from 
+        # attributes when relationships is defined in ActiveRecord.
+        list.each do |i|
+          if i.include?('_id')
+            assoc_name = model.reflect_on_association(i.gsub(/_id/, '').to_sym).macro rescue nil
+            i.gsub!(/_id/, '') if assoc_name == :belongs_to
+          end
+        end
+
+        # Detect relationships using reflection.
+        relationships = [ :belongs_to, :has_and_belongs_to_many, :has_many, :has_one ].map do |relationship|
+                          model.reflect_on_all_associations(relationship).map { |i| i.name.to_s }
+                        end.flatten.sort
+
+        configuration[:base] << <<-CODE
+#{model}:
+  fields:
+    list: #{list.join(', ')}
+    form: #{form.join(', ')}
+    show: #{show.join(', ')}
+    relationship:
+    options:
+      auto_generated:
+      read_only:
+      selectors:
+  actions:
+    index:
+    edit:
+  export:
+  order_by:
+  relationships: #{relationships.join(', ')}
+  filters:
+  search:
+  application: #{application}
+  description:
+
+        CODE
+
+        configuration[:roles] << <<-CODE
+  #{model}: create, read, update, delete
+        CODE
+
+      end
+
+      Dir["#{Typus.root}/generators/typus/templates/config/typus/*"].each do |f|
+        base = File.basename(f)
+        m.template "config/typus/#{base}", "#{config_folder}/#{base}", 
+                   :assigns => { :configuration => configuration }
+      end
+
+      ##
+      # Initializers
+      #
+
+      m.template 'config/initializers/typus.rb', 'config/initializers/typus.rb', 
+                 :assigns => { :application => application }
+
+      ##
+      # Public folders
+      #
+
+      [ "#{Rails.root}/public/stylesheets/admin", 
+        "#{Rails.root}/public/javascripts/admin", 
+        "#{Rails.root}/public/images/admin" ].each do |folder|
+        Dir.mkdir(folder) unless File.directory?(folder)
+      end
+
+      m.file 'public/stylesheets/admin/screen.css', 'public/stylesheets/admin/screen.css'
+      m.file 'public/stylesheets/admin/reset.css', 'public/stylesheets/admin/reset.css'
+      m.file 'public/javascripts/admin/application.js', 'public/javascripts/admin/application.js'
+
+      Dir["#{Typus.root}/generators/typus/templates/public/images/admin/*"].each do |f|
+        base = File.basename(f)
+        m.file "public/images/admin/#{base}", "public/images/admin/#{base}"
+      end
+
+      ##
+      # Migration file
+      #
+
+      m.migration_template 'db/create_typus_users.rb', 'db/migrate', 
+                            { :migration_file_name => 'create_typus_users' }
+
+    end
+
+  end
+
+end

data/generators/typus_update_schema_to_01/templates/config/typus.yml

@@ -0,0 +1,14 @@
+TypusUser:
+  fields:
+    list: email, role, status
+    form: first_name, last_name, role, email, password, password_confirmation
+    options:
+      selectors: role
+      booleans:
+        status: Active, Inactive
+  filters: status, role
+  search: first_name, last_name, email, role
+  application: Typus
+  description: System Users Administration
+  options:
+    icon_on_boolean: false

data/generators/typus_update_schema_to_01/templates/migration.rb

@@ -0,0 +1,11 @@
+class UpdateTypusSchemaTo01 < ActiveRecord::Migration
+
+  def self.up
+    rename_column :typus_users, :roles, :role
+  end
+
+  def self.down
+    rename_column :typus_users, :role, :roles
+  end
+
+end

data/generators/typus_update_schema_to_01/typus_update_schema_to_01_generator.rb

@@ -0,0 +1,19 @@
+class TypusUpdateSchemaTo01Generator < Rails::Generator::Base
+
+  def manifest
+
+    record do |m|
+
+      config_folder = Typus::Configuration.options[:config_folder]
+      Dir["#{Typus.root}/generators/typus_update_schema_to_01/templates/config/*"].each do |f|
+        base = File.basename(f)
+        m.template "config/#{base}", "#{config_folder}/#{base}"
+      end
+
+      m.migration_template 'migration.rb', 'db/migrate', { :migration_file_name => 'update_typus_schema_to_01' }
+
+    end
+
+  end
+
+end

data/init.rb

@@ -0,0 +1,19 @@
+require 'typus'
+require 'sha1'
+
+if Typus.testing?
+  Typus::Configuration.options[:config_folder] = 'vendor/plugins/typus/test/config/working'
+end
+
+##
+# Typus.enable and run the generator unless we are testing the plugin.
+# Do not Typus.enable or generate files if we are running a rails 
+# generator.
+#
+
+scripts = %w( script/generate script/destroy )
+
+unless scripts.include?($0)
+  Typus.enable
+  Typus.generator unless Typus.testing?
+end

data/lib/typus/active_record.rb

@@ -0,0 +1,298 @@
+module Typus
+
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+
+    ##
+    # Return model fields as a OrderedHash
+    #
+    def model_fields
+      hash = ActiveSupport::OrderedHash.new
+      columns.map { |u| hash[u.name.to_sym] = u.type.to_sym }
+      return hash
+    end
+
+    def model_relationships
+      hash = ActiveSupport::OrderedHash.new
+      reflect_on_all_associations.map { |i| hash[i.name] = i.macro }
+      return hash
+    end
+
+    ##
+    # Form and list fields
+    #
+    def typus_fields_for(filter)
+
+      fields_with_type = ActiveSupport::OrderedHash.new
+
+      begin
+        fields = Typus::Configuration.config[name]['fields'][filter.to_s]
+        fields = fields.split(', ').collect { |f| f.to_sym }
+      rescue
+        return [] if filter == 'list'
+        filter = 'list'
+        retry
+      end
+
+      begin
+
+        fields.each do |field|
+
+          attribute_type = model_fields[field]
+
+          # Custom field_type depending on the attribute name.
+          case field.to_s
+            when 'parent_id':       attribute_type = :tree
+            when /file_name/:       attribute_type = :file
+            when /password/:        attribute_type = :password
+            when 'position':        attribute_type = :position
+            when /\?/:              attribute_type = :boolean
+          end
+
+          if reflect_on_association(field)
+            attribute_type = reflect_on_association(field).macro
+          end
+
+          if typus_field_options_for(:selectors).include?(field)
+            attribute_type = :selector
+          end
+
+          # And finally insert the field and the attribute_type 
+          # into the fields_with_type ordered hash.
+          fields_with_type[field.to_s] = attribute_type
+
+        end
+
+      rescue
+        fields = Typus::Configuration.config[name]['fields']['list'].split(', ')
+        retry
+      end
+
+      return fields_with_type
+
+    end
+
+    ##
+    # Typus sidebar filters.
+    #
+    def typus_filters
+
+      fields_with_type = ActiveSupport::OrderedHash.new
+
+      data = Typus::Configuration.config[name]['filters']
+      return [] unless data
+      fields = data.split(', ').collect { |i| i.to_sym }
+
+      fields.each do |field|
+        attribute_type = model_fields[field.to_sym]
+        if reflect_on_association(field.to_sym)
+          attribute_type = reflect_on_association(field.to_sym).macro
+        end
+        fields_with_type[field.to_s] = attribute_type
+      end
+
+      return fields_with_type
+
+    end
+
+    ##
+    #  Extended actions for this model on Typus.
+    #
+    def typus_actions_for(filter)
+      Typus::Configuration.config[name]['actions'][filter.to_s].split(', ')
+    rescue
+      []
+    end
+
+    ##
+    # Used for +search+, +relationships+
+    #
+    def typus_defaults_for(filter)
+      data = Typus::Configuration.config[name][filter.to_s]
+      return (!data.nil?) ? data.split(', ') : []
+    end
+
+    ##
+    #
+    #
+    def typus_field_options_for(filter)
+      Typus::Configuration.config[name]['fields']['options'][filter.to_s].split(', ').collect { |i| i.to_sym }
+    rescue
+      []
+    end
+
+    ##
+    # We should be able to overwrite options by model.
+    #
+    def typus_options_for(filter)
+
+      data = Typus::Configuration.config[name]
+      unless data['options'].nil?
+        value = data['options'][filter.to_s] unless data['options'][filter.to_s].nil?
+      end
+
+      return (!value.nil?) ? value : Typus::Configuration.options[filter.to_sym]
+
+    end
+
+    def typus_export_formats
+      data = Typus::Configuration.config[name]
+      !data['export'].nil? ? data['export'].split(', ') : []
+    end
+
+    ##
+    # Used for order_by
+    #
+    def typus_order_by
+
+      fields = typus_defaults_for(:order_by)
+      return "#{table_name}.id ASC" if fields.empty?
+
+      order = fields.map do |field|
+                (field.include?('-')) ? "#{table_name}.#{field.delete('-')} DESC" : "#{table_name}.#{field} ASC"
+              end.join(', ')
+
+      return order
+
+    end
+
+    ##
+    # We are able to define our own booleans.
+    #
+    def typus_boolean(attribute = :default)
+
+      boolean = Typus::Configuration.config[name]['fields']['options']['booleans'][attribute.to_s] rescue nil
+      boolean = 'true, false' if boolean.nil?
+
+      hash = ActiveSupport::OrderedHash.new
+
+      if boolean.kind_of?(Array)
+        hash[:true] = boolean.first.humanize
+        hash[:false] = boolean.last.humanize
+      else
+        hash[:true] = boolean.split(', ').first.humanize
+        hash[:false] = boolean.split(', ').last.humanize
+      end
+
+      return hash
+
+    end
+
+    ##
+    # We are able to define how to display dates on Typus
+    #
+    def typus_date_format(attribute = :default)
+      date_format = Typus::Configuration.config[name]['fields']['options']['date_formats'][attribute.to_s] rescue nil
+      date_format = :db if date_format.nil?
+      return date_format.to_sym
+    end
+
+    ##
+    # We are able to define which template to use to render the attribute 
+    # within the form
+    #
+    def typus_template(attribute)
+      Typus::Configuration.config[name]['fields']['options']['templates'][attribute.to_s]
+    rescue
+      nil
+    end
+
+    ##
+    # Build conditions
+    #
+    def build_conditions(params)
+
+      conditions, joins = merge_conditions, []
+
+      query_params = params.dup
+      %w( action controller ).each { |param| query_params.delete(param) }
+
+      # If a search is performed.
+      if query_params[:search]
+        search = typus_defaults_for(:search).map do |s|
+                   ["LOWER(#{s}) LIKE '%#{query_params[:search].downcase}%'"]
+                 end
+        conditions = merge_conditions(conditions, search.join(' OR '))
+      end
+
+      query_params.each do |key, value|
+
+        filter_type = model_fields[key.to_sym] || model_relationships[key.to_sym]
+
+        ##
+        # Sidebar filters:
+        #
+        #   - Booleans: true, false
+        #   - Datetime: today, past_7_days, this_month, this_year
+        #   - Integer & String: *_id and "selectors" (P.ej. category_id)
+        #
+        case filter_type
+        when :boolean
+          condition = { key => (value == 'true') ? true : false }
+          conditions = merge_conditions(conditions, condition)
+        when :datetime
+          interval = case value
+                     when 'today':         Time.today..Time.today.tomorrow
+                     when 'past_7_days':   6.days.ago.midnight..Time.today.tomorrow
+                     when 'this_month':    Time.today.last_month..Time.today.tomorrow
+                     when 'this_year':     Time.today.last_year..Time.today.tomorrow
+                     end
+          condition = ["#{key} BETWEEN ? AND ?", interval.first.to_s(:db), interval.last.to_s(:db)]
+          conditions = merge_conditions(conditions, condition)
+        when :integer, :string
+          condition = { key => value }
+          conditions = merge_conditions(conditions, condition)
+        when :has_and_belongs_to_many
+          condition = {  key => { :id => value } }
+          conditions = merge_conditions(conditions, condition)
+          joins << key.to_sym
+        end
+
+      end
+
+      return conditions, joins
+
+    end
+
+  end
+
+  module InstanceMethods
+
+    def previous_and_next(condition = {}, klass = self.class)
+
+      previous_conditions = "id < #{id}"
+      next_conditions = "id > #{id}"
+
+      if !condition.empty?
+        conditions, joins = klass.build_conditions(condition)
+        previous_conditions += " AND #{conditions}"
+        next_conditions += " AND #{conditions}"
+      end
+
+      previous_ = klass.find :first, 
+                             :select => [:id], 
+                             :order => "id DESC", 
+                             :conditions => previous_conditions
+
+      next_ = klass.find :first, 
+                         :select => [:id], 
+                         :order => "id ASC", 
+                         :conditions => next_conditions
+
+      return previous_, next_
+
+    end
+
+    def typus_name
+      respond_to?(:name) ? name : "#{self.class}##{id}"
+    end
+
+  end
+
+end
+
+ActiveRecord::Base.send :include, Typus
+ActiveRecord::Base.send :include, Typus::InstanceMethods

data/lib/typus/authentication.rb

@@ -0,0 +1,155 @@
+module Typus
+
+  module Authentication
+
+    protected
+
+    ##
+    # Require login checks if the user is logged on Typus, otherwise 
+    # is sent to the sign in page with a :back_to param to return where 
+    # she tried to go.
+    #
+    # Use this for demo!
+    #
+    #     session[:typus_user_id] = Typus.user_class.find(:first)
+    #
+    def require_login
+      if session[:typus_user_id]
+        set_current_user
+      else
+        back_to = (request.env['REQUEST_URI'] == '/admin') ? nil : request.env['REQUEST_URI']
+        redirect_to admin_sign_in_path(:back_to => back_to)
+      end
+    end
+
+    ##
+    # Return the current user.
+    #
+    # NOTE: If role does not longer exist on the system the user will 
+    #       be signed out from Typus.
+    #
+    def set_current_user
+
+      @current_user = Typus.user_class.find(session[:typus_user_id])
+
+      unless @current_user.respond_to?(:role)
+        raise _("Run 'script/generate typus_update_schema_to_01 -f && rake db:migrate' to update database schema.")
+      end
+
+      unless Typus::Configuration.roles.keys.include?(@current_user.role)
+        raise _("Role does no longer exists.")
+      end
+
+      unless @current_user.status
+        back_to = (request.env['REQUEST_URI'] == '/admin') ? nil : request.env['REQUEST_URI']
+        raise _("Typus user has been disabled.")
+      end
+
+    rescue Exception => error
+      flash[:notice] = error.message
+      session[:typus_user_id] = nil
+      redirect_to admin_sign_in_path(:back_to => back_to)
+    end
+
+    ##
+    # Action is available on:
+    #
+    #     edit, update, toggle and destroy
+    #
+    def check_if_user_can_perform_action_on_user
+
+      return unless @item.kind_of?(Typus.user_class)
+
+      current_user = (@current_user == @item)
+
+      message = case params[:action]
+                when 'edit'
+
+                  # Only admin and owner of Typus User can edit.
+                  if !@current_user.is_root? && !current_user
+                    _("As you're not the admin or the owner of this record you cannot edit it.")
+                  end
+
+                when 'update'
+
+                  # current_user cannot change her role.
+                  if current_user && !(@item.role == params[:item][:role])
+                    _("You can't change your role.")
+                  end
+
+                when 'toggle'
+
+                  # Only admin can toggle typus user status, but not herself.
+                  if @current_user.is_root? && current_user
+                    _("You can't toggle your status.")
+                  elsif !@current_user.is_root?
+                    _("You're not allowed to toggle status.")
+                  end
+
+                when 'destroy'
+
+                  # Admin can remove anything except herself.
+                  if @current_user.is_root? && current_user
+                    _("You can't remove yourself.")
+                  elsif !@current_user.is_root?
+                    _("You're not allowed to remove Typus Users.")
+                  end
+
+                end
+
+      if message
+        flash[:notice] = message
+        redirect_to :back rescue redirect_to admin_dashboard_path
+      end
+
+    end
+
+    ##
+    # This method checks if the user can perform the requested action.
+    # It works on models, so its available on the admin_controller.
+    #
+    def check_if_user_can_perform_action_on_resource
+
+      message = case params[:action]
+                when 'index', 'show'
+                  _("{{current_user_role}} can't display items.", 
+                    :current_user_role => @current_user.role.capitalize)
+                when 'edit', 'update', 'position', 'toggle', 'relate', 'unrelate'
+                when 'destroy'
+                  _("{{current_user_role}} can't delete this item.", 
+                    :current_user_role => @current_user.role.capitalize)
+                else
+                  _("{{current_user_role}} can't perform action ({{action}}).", 
+                    :current_user_role => @current_user.role.capitalize, 
+                    :action => params[:action])
+                end
+
+      unless @current_user.can_perform?(@resource[:class], params[:action])
+        flash[:notice] = message || _("{{current_user_role}} can't perform action. ({{action}}).", 
+                                      :current_user_role => @current_user.role.capitalize, 
+                                      :action => params[:action])
+        redirect_to :back rescue redirect_to admin_dashboard_path
+      end
+
+    end
+
+    ##
+    # This method checks if the user can perform the requested action.
+    # It works on resources, which are not models, so its available on 
+    # the typus_controller.
+    #
+    def check_if_user_can_perform_action_on_resource_without_model
+      controller = params[:controller].split('/').last
+      action = params[:action]
+      unless @current_user.can_perform?(controller.camelize, action, { :special => true })
+        flash[:notice] = _("{{current_user_role}} can't go to {{action}} on {{controller}}.", 
+                           :current_user_role => @current_user.role.capitalize, 
+                           :action => action, 
+                           :controller => controller.humanize.downcase)
+        redirect_to :back rescue redirect_to admin_dashboard_path
+      end
+    end
+
+  end
+
+end