typus 0.9.17

data/lib/typus/authentication.rb

@@ -0,0 +1,142 @@
+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.
+    def require_login
+
+      # Uncomment the following line for demo purpouses.
+      # session[:typus_user_id] = Typus.user_class.find(:first)
+
+      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. If role does not longer exist on the 
+    # system @current_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

data/lib/typus/configuration.rb

@@ -0,0 +1,85 @@
+module Typus
+
+  module Configuration
+
+    # Default options which can be overwritten from the initializer.
+    typus_options = { :app_name => 'Typus', 
+                      :config_folder => 'config/typus', 
+                      :email => 'admin@example.com', 
+                      :locales => [ [ "English", :en ] ], 
+                      :recover_password => false, 
+                      :root => 'admin', 
+                      :ssl => false, 
+                      :templates_folder => 'admin/templates',
+                      :user_class_name => 'TypusUser', 
+                      :user_fk => 'typus_user_id' }
+
+    # Default options which can be overwritten from the initializer.
+    model_options = { :default_action_on_item => 'edit', 
+                      :end_year => nil,
+                      :form_rows => 10, 
+                      :icon_on_boolean => true, 
+                      :index_after_save => false, 
+                      :minute_step => 5, 
+                      :nil => 'nil', 
+                      :on_header => false, 
+                      :only_user_items => false, 
+                      :per_page => 15, 
+                      :sidebar_selector => 5, 
+                      :start_year => nil, 
+                      :tiny_mce => { :theme => 'advanced',
+                                     :theme_advanced_toolbar_location => 'top',
+                                     :theme_advanced_toolbar_align => 'left' }, 
+                      :toggle => true }
+
+    @@options = typus_options.merge(model_options)
+
+    mattr_accessor :options
+
+    # Read Typus Configuration files placed on <tt>config/typus/**/*.yml</tt>.
+    def self.config!
+
+      files = Dir["#{Rails.root}/#{options[:config_folder]}/**/*.yml"].sort
+      files = files.delete_if { |x| x.include?('_roles.yml') }
+
+      @@config = {}
+      files.each do |file|
+        data = YAML.load_file(file)
+        @@config = @@config.merge(data) if data
+      end
+
+      return @@config
+
+    end
+
+    mattr_accessor :config
+
+    # Read Typus Roles from configuration files placed on <tt>config/typus/**/*_roles.yml</tt>.
+    def self.roles!
+
+      files = Dir["#{Rails.root}/#{options[:config_folder]}/**/*_roles.yml"].sort
+
+      @@roles = { options[:root] => {} }
+
+      files.each do |file|
+        data = YAML.load_file(file)
+        next unless data
+        data.each do |key, value|
+          next unless value
+          begin
+            @@roles[key] = @@roles[key].merge(value)
+          rescue
+            @@roles[key] = value
+          end
+        end
+      end
+
+      return @@roles.compact
+
+    end
+
+    mattr_accessor :roles
+
+  end
+
+end

data/lib/typus/extensions/routes.rb

@@ -0,0 +1,15 @@
+if defined?(ActionController::Routing::RouteSet)
+
+  class ActionController::Routing::RouteSet
+
+    def load_routes_with_typus!
+      typus_routes = File.join(File.dirname(__FILE__), 'routes_hack.rb')
+      add_configuration_file(typus_routes) unless configuration_files.include?(typus_routes)
+      load_routes_without_typus!
+    end
+
+    alias_method_chain :load_routes!, :typus
+
+  end
+
+end

data/lib/typus/format.rb

@@ -0,0 +1,55 @@
+module Typus
+
+  module Format
+
+    protected
+
+    def generate_html
+
+      items_count = @resource[:class].count(:joins => @joins, :conditions => @conditions)
+      items_per_page = @resource[:class].typus_options_for(:per_page).to_i
+
+      @pager = ::Paginator.new(items_count, items_per_page) do |offset, per_page|
+        data(:limit => per_page, :offset => offset)
+      end
+
+      @items = @pager.page(params[:page])
+
+      select_template :index
+
+    end
+
+    def generate_csv
+
+      require 'fastercsv'
+
+      fields = @resource[:class].typus_fields_for(:csv).collect { |i| i.first }
+      csv_string = FasterCSV.generate do |csv|
+        csv << fields.map { |f| _(f.humanize) }
+        data.each { |i| csv << fields.map { |f| i.send(f) } }
+      end
+
+      filename = "#{Time.now.strftime("%Y%m%d%H%M%S")}_#{@resource[:self]}.csv"
+      send_data(csv_string,
+               :type => 'text/csv; charset=utf-8; header=present',
+               :filename => filename)
+
+    rescue LoadError
+      render :text => _("FasterCSV is not installed.")
+    end
+
+    def generate_xml
+      fields = @resource[:class].typus_fields_for(:xml).collect { |i| i.first }
+      render :xml => data.to_xml(:only => fields)
+    end
+
+    def data(*args)
+      eager_loading = @resource[:class].reflect_on_all_associations(:belongs_to).map { |i| i.name }
+      options = { :joins => @joins, :conditions => @conditions, :order => @order, :include => eager_loading }
+      options.merge!(args.extract_options!)
+      @resource[:class].find(:all, options)
+    end
+
+  end
+
+end

data/lib/typus/generator.rb

@@ -0,0 +1,81 @@
+require 'ftools'
+
+module Typus
+
+  def self.generator
+
+    # Create app/controllers/admin if doesn't exist.
+    admin_controllers_folder = "#{Rails.root}/app/controllers/admin"
+    Dir.mkdir(admin_controllers_folder) unless File.directory?(admin_controllers_folder)
+
+    # Get a list of controllers under `app/controllers/admin`.
+    admin_controllers = Dir["#{Rails.root}/vendor/plugins/*/app/controllers/admin/*.rb", "#{admin_controllers_folder}/*.rb"]
+    admin_controllers = admin_controllers.map { |i| File.basename(i) }
+
+    # Create app/views/admin if doesn't exist.
+    admin_views_folder = "#{Rails.root}/app/views/admin"
+    Dir.mkdir(admin_views_folder) unless File.directory?(admin_views_folder)
+
+    # Create test/functional/admin if doesn't exist.
+    admin_controller_tests_folder = "#{Rails.root}/test/functional/admin"
+    if File.directory?("#{Rails.root}/test")
+      Dir.mkdir(admin_controller_tests_folder) unless File.directory?(admin_controller_tests_folder)
+    end
+
+    # Get a list of functional tests under `test/functional/admin`.
+    admin_controller_tests = Dir["#{admin_controller_tests_folder}/*.rb"]
+    admin_controller_tests = admin_controller_tests.map { |i| File.basename(i) }
+
+    # Generate controllers for tableless models.
+    resources.each do |resource|
+
+      controller_filename = "#{resource.underscore}_controller.rb"
+      controller_location = "#{admin_controllers_folder}/#{controller_filename}"
+
+      if !admin_controllers.include?(controller_filename)
+        template = File.read("#{File.dirname(__FILE__)}/templates/resource_controller.rb.erb")
+        content = ERB.new(template).result(binding)
+        File.open(controller_location, "w+") { |f| f << content }
+      end
+
+      # And now we create the view.
+      view_folder = "#{admin_views_folder}/#{resource.underscore}"
+      view_filename = "index.html.erb"
+
+      if !File.exist?("#{view_folder}/#{view_filename}")
+        Dir.mkdir(view_folder) unless File.directory?(view_folder)
+        origin = "#{File.dirname(__FILE__)}/templates/index.html.erb"
+        destination = "#{view_folder}/#{view_filename}"
+        File.copy(origin, destination)
+      end
+
+    end
+
+    # Generate:
+    #   `app/controllers/admin/#{resource}_controller.rb`
+    #   `test/functional/admin/#{resource}_controller_test.rb`
+    models.each do |model|
+
+      controller_filename = "#{model.tableize}_controller.rb"
+      controller_location = "#{admin_controllers_folder}/#{controller_filename}"
+
+      if !admin_controllers.include?(controller_filename)
+        template = File.read("#{File.dirname(__FILE__)}/templates/resources_controller.rb.erb")
+        content = ERB.new(template).result(binding)
+        File.open(controller_location, "w+") { |f| f << content }
+      end
+
+      test_filename = "#{model.tableize}_controller_test.rb"
+      test_location = "#{admin_controller_tests_folder}/#{test_filename}"
+
+      if !admin_controller_tests.include?(test_filename) && File.directory?("#{Rails.root}/test")
+        template = File.read("#{File.dirname(__FILE__)}/templates/resource_controller_test.rb.erb")
+        content = ERB.new(template).result(binding)
+        File.open(test_location, "w+") { |f| f << content }
+      end
+
+    end
+
+  end
+
+end

data/lib/typus/hash.rb

@@ -0,0 +1,8 @@
+class Hash
+
+  # Remove nil and empty keys.
+  def compact
+    delete_if { |key, value| value.nil? || value.empty? }
+  end
+
+end

data/lib/typus/locale.rb

@@ -0,0 +1,17 @@
+module Typus
+
+  module Locale
+
+    def set_locale
+      if params[:locale]
+        I18n.locale = params[:locale]
+        session[:typus_locale] = params[:locale]
+        redirect_to :back
+      else
+        I18n.locale = session[:typus_locale] || Typus.default_locale
+      end
+    end
+
+  end
+
+end

data/lib/typus/object.rb

@@ -0,0 +1,21 @@
+class Object
+
+  # Instead of having to translate strings and defining a default value:
+  #
+  #     t("Hello World!", :default => 'Hello World!')
+  #
+  # We define this method to define the value only once:
+  #
+  #     _("Hello World!")
+  #
+  # Note that interpolation still works ...
+  #
+  #     _("Hello {{world}}!", :world => @world)
+  #
+  def _(msg, *args)
+    options = args.extract_options!
+    options[:default] = msg
+    I18n.t(msg, options)
+  end
+
+end

data/lib/typus/quick_edit.rb

@@ -0,0 +1,40 @@
+module Typus
+
+  module QuickEdit
+
+    def quick_edit
+
+      render :text => '' and return unless session[:typus_user_id]
+
+      links = [[ "Dashboard", admin_dashboard_path ]]
+      links << [ params[:message], "/admin/#{params[:path]}" ] if params[:message] && params[:path]
+
+      options = links.reverse.map do |link|
+                  "<li><a href=\"#{link.last}\">#{link.first}</a></li>"
+                end
+
+      content = <<-HTML
+var links = '';
+links += '<div id="quick_edit">';
+links += '<ul>';
+links += '#{options}';
+links += '</ul>';
+links += '</div>';
+links += '<style type="text/css">';
+links += '<!--';
+links += '#quick_edit { font-size: 12px; font-family: sans-serif; position: absolute; top: 0px; right: 0px; margin: 10px; }';
+links += '#quick_edit a { color: #FFF; font-weight: bold; text-decoration: none; }'
+links += '#quick_edit ul { margin: 0; padding: 0; }';
+links += '#quick_edit li { display: inline; background: #000; margin: 0 0 0 5px; padding: 3px 5px; }';
+links += '-->';
+links += '</style>';
+document.write(links);
+      HTML
+
+      render :text => content
+
+    end
+
+  end
+
+end