typus 0.9.39 → 1.0.0.pre

data/lib/typus/authentication.rb

@@ -4,47 +4,74 @@ module Typus
 
     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 
+    #--
+    # 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
+    #++
+    def authenticate
+      case Typus.authentication
+      when :none
+        authenticate_via_none
+      when :http_basic
+        authenticate_via_http_basic
+      when :session
+        authenticate_via_session
+      end
+    end
+
+    def authenticate_via_none
+      @current_user = Admin::FakeUser.new
+    end
 
-      # Uncomment the following line for demo purpouses.
-      # session[:typus_user_id] = Typus.user_class.find(:first)
+    def authenticate_via_http_basic
+      @current_user = Admin::FakeUser.new
+      authenticate_or_request_with_http_basic(Typus.admin_title) do |user_name, password|
+        user_name == Typus.username && password == Typus.password
+      end
+    end
 
+    def authenticate_via_session
       if session[:typus_user_id]
-        set_current_user
+        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)
+        back_to = request.env['PATH_INFO'] unless [admin_dashboard_path, admin_path].include?(request.env['PATH_INFO'])
+        redirect_to new_admin_session_path(:back_to => back_to)
       end
-
     end
 
-    # Return the current user. If role does not longer exist on the 
+    #--
+    # 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
+    #++
+    def current_user
 
       @current_user = Typus.user_class.find(session[:typus_user_id])
 
-      unless Typus::Configuration.roles.keys.include?(@current_user.role)
+      unless Typus::Configuration.roles.has_key?(@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']
+        back_to = (request.env['REQUEST_URI'] == admin_dashboard_path) ? nil : request.env['REQUEST_URI']
         raise _("Typus user has been disabled.")
       end
 
+      I18n.locale = @current_user.preferences[:locale]
+
     rescue Exception => error
       flash[:notice] = error.message
       session[:typus_user_id] = nil
-      redirect_to admin_sign_in_path(:back_to => back_to)
+      redirect_to new_admin_session_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 Typus.authentication.eql?(:session)
+
       return unless @item.kind_of?(Typus.user_class)
 
       current_user = (@current_user == @item)
@@ -53,14 +80,14 @@ module Typus
                 when 'edit'
 
                   # Only admin and owner of Typus User can edit.
-                  if !@current_user.is_root? && !current_user
+                  if @current_user.is_not_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])
+                  if current_user && !(@item.role == params[@object_name][:role])
                     _("You can't change your role.")
                   end
 
@@ -69,7 +96,7 @@ module Typus
                   # 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?
+                  elsif @current_user.is_not_root?
                     _("You're not allowed to toggle status.")
                   end
 
@@ -78,7 +105,7 @@ module Typus
                   # Admin can remove anything except herself.
                   if @current_user.is_root? && current_user
                     _("You can't remove yourself.")
-                  elsif !@current_user.is_root?
+                  elsif @current_user.is_not_root?
                     _("You're not allowed to remove Typus Users.")
                   end
 
@@ -86,50 +113,129 @@ module Typus
 
       if message
         flash[:notice] = message
-        redirect_to request.referer || admin_dashboard_path
+        redirect_to set_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
+    #++
+    def check_if_user_can_perform_action_on_resources
+
+      return unless Typus.authentication.eql?(:session)
 
       message = case params[:action]
                 when 'index', 'show'
-                  _("{{current_user_role}} can't display items.", 
-                    :current_user_role => @current_user.role.capitalize)
+                  "%{current_user_role} can't display items."
                 when 'destroy'
-                  _("{{current_user_role}} can't delete this item.", 
-                    :current_user_role => @current_user.role.capitalize)
+                  "%{current_user_role} can't delete this item."
                 else
-                  _("{{current_user_role}} can't perform action. ({{action}})", 
-                    :current_user_role => @current_user.role.capitalize, 
-                    :action => params[:action])
+                  "%{current_user_role} can't perform action. (%{action})"
                 end
 
-      unless @current_user.can_perform?(@resource[:class], params[:action])
+      message = _(message,
+                  :current_user_role => @current_user.role.capitalize,
+                  :action => params[:action])
+
+      unless @current_user.can?(params[:action], @resource)
         flash[:notice] = message
-        redirect_to request.referer || admin_dashboard_path
+        redirect_to set_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
+    # It works on a resource: git, memcached, syslog ...
+    #++
+    def check_if_user_can_perform_action_on_resource
+      return unless Typus.authentication.eql?(:session)
+
+      controller = params[:controller].extract_resource
       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 request.referer || admin_dashboard_path
+      unless @current_user.can?(action, controller.camelize, { :special => true })
+        render :text => "Not allowed!", :status => :unprocessable_entity
+      end
+    end
+
+    #--
+    # If item is owned by another user, we only can perform a
+    # show action on the item. Updated item is also blocked.
+    #
+    #   before_filter :check_resource_ownership, :only => [ :edit, :update, :destroy,
+    #                                                       :toggle, :position,
+    #                                                       :relate, :unrelate ]
+    #++
+    def check_resource_ownership
+
+      return unless Typus.authentication.eql?(:session)
+
+      # By-pass if current_user is root.
+      return if @current_user.is_root?
+
+      condition_typus_users = @item.respond_to?(Typus.relationship) && !@item.send(Typus.relationship).include?(@current_user)
+      condition_typus_user_id = @item.respond_to?(Typus.user_fk) && !@item.owned_by?(@current_user)
+
+      if condition_typus_users || condition_typus_user_id
+         alert = _("You don't have permission to access this item.")
+         redirect_to set_path, :alert => alert
+      end
+
+    end
+
+    def check_resource_ownerships
+
+      return unless Typus.authentication.eql?(:session)
+
+      # By-pass if current_user is root.
+      return if @current_user.is_root?
+
+      # Show only related items it @resource has a foreign_key (Typus.user_fk)
+      # related to the logged user.
+      if @resource.typus_user_id?
+        condition = { Typus.user_fk => @current_user }
+        @conditions = @resource.merge_conditions(@conditions, condition)
+      end
+
+    end
+
+    def check_ownership_of_referal_item
+      return unless Typus.authentication.eql?(:session)
+
+      return unless params[:resource] && params[:resource_id]
+      klass = params[:resource].classify.constantize
+      return if !klass.typus_user_id?
+      item = klass.find(params[:resource_id])
+      raise "You're not owner of this record." unless item.owned_by?(@current_user) || @current_user.is_root?
+    end
+
+    def set_attributes_on_create
+      return unless Typus.authentication.eql?(:session)
+      if @resource.typus_user_id?
+        @item.attributes = { Typus.user_fk => @current_user.id }
+      end
+    end
+
+    def set_attributes_on_update
+      return unless Typus.authentication.eql?(:session)
+      if @resource.typus_user_id? && @current_user.is_not_root?
+        @item.update_attributes(Typus.user_fk => @current_user.id)
+      end
+    end
+
+    #--
+    # Reload @current_user when updating to see flash message in the
+    # correct locale.
+    #++
+    def reload_locales
+      return unless Typus.authentication.eql?(:session)
+      if @resource.eql?(Typus.user_class)
+        I18n.locale = @current_user.reload.preferences[:locale]
       end
     end
 
   end
 
-end
+end

data/lib/typus/configuration.rb

@@ -2,73 +2,39 @@ module Typus
 
   module Configuration
 
-    # Default options which can be overwritten from the initializer.
-    typus_options = { :app_name => 'Typus', 
-                      :config_folder => 'config/typus', 
-                      :default_locale => :en, 
-                      :email => 'admin@example.com', 
-                      :file_preview => :typus_preview, 
-                      :file_thumbnail => :typus_thumbnail, 
-                      :recover_password => false, 
-                      :relationship => 'typus_users', 
-                      :root => 'admin', 
-                      :ssl => false, 
-                      :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 => 15, 
-                      :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>.
+    # Read configuration from <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') }
+      application = Dir[File.join(Typus.config_folder, "**", "*.yml").to_s]
+      plugins = Dir[File.join("vendor", "plugins", "*", "config", "typus", "*.yml").to_s]
+      files = (application + plugins).reject { |f| f.include?("_roles.yml") }
 
       @@config = {}
       files.each do |file|
-        data = YAML.load_file(file)
-        @@config = @@config.merge(data) if data
+        if data = YAML::load_file(file)
+          @@config.merge!(data)
+        end
       end
 
       return @@config
-
     end
 
     mattr_accessor :config
 
-    # Read Typus Roles from configuration files placed on <tt>config/typus/**/*_roles.yml</tt>.
+    # Read roles from files <tt>config/typus/**/*_roles.yml</tt>.
     def self.roles!
+      application = Dir[File.join(Typus.config_folder, "**", "*_roles.yml").to_s]
+      plugins = Dir[File.join("vendor", "plugins", "*", "config", "typus", "*_roles.yml").to_s]
+      files = (application + plugins).sort
 
-      files = Dir["#{Rails.root}/#{options[:config_folder]}/**/*_roles.yml"].sort
-
-      @@roles = { options[:root] => {} }
+      @@roles = { Typus.master_role => {} }
 
       files.each do |file|
-        data = YAML.load_file(file)
+        data = YAML::load_file(file)
         next unless data
         data.each do |key, value|
           next unless value
           begin
-            @@roles[key] = @@roles[key].merge(value)
+            @@roles[key].merge!(value)
           rescue
             @@roles[key] = value
           end
@@ -76,7 +42,6 @@ module Typus
       end
 
       return @@roles.compact
-
     end
 
     mattr_accessor :roles

data/lib/typus/engine.rb

@@ -0,0 +1,6 @@
+module Typus
+
+  class Engine < Rails::Engine
+  end
+
+end

data/lib/typus/format.rb

@@ -6,8 +6,8 @@ module Typus
 
     def generate_html
 
-      items_count = @resource[:class].count(:joins => @joins, :conditions => @conditions)
-      items_per_page = @resource[:class].typus_options_for(:per_page).to_i
+      items_count = @resource.count(:joins => @joins, :conditions => @conditions)
+      items_per_page = @resource.typus_options_for(:per_page)
 
       @pager = ::Paginator.new(items_count, items_per_page) do |offset, per_page|
         data(:limit => per_page, :offset => offset)
@@ -15,13 +15,16 @@ module Typus
 
       @items = @pager.page(params[:page])
 
-      select_template :index
-
     end
 
+    #--
+    # TODO: Find in batches only works properly if it's used on
+    #       models, not controllers, so in this action does nothing.
+    #       We should find a way to be able to process data.
+    #++
     def generate_csv
 
-      fields = @resource[:class].typus_fields_for(:csv).collect { |i| i.first }
+      fields = @resource.typus_fields_for(:csv)
 
       require 'csv'
       if CSV.const_defined?(:Reader)
@@ -36,30 +39,50 @@ module Typus
         csv = CSV
       end
 
-      csv_string = csv.generate do |c|
-        c << fields.map { |f| _(f.humanize) }
-        data.each { |i| c << fields.map { |f| i.send(f) } }
+      filename = Rails.root.join("tmp", "export-#{@resource.to_resource}-#{Time.now.utc.to_s(:number)}.csv")
+
+      options = { :conditions => @conditions, :batch_size => 1000 }
+
+      csv.open(filename, 'w', :col_sep => ';') do |csv|
+        csv << fields.keys
+        @resource.find_in_batches(options) do |records|
+          records.each do |record|
+            csv << fields.map do |key, value|
+                     case value
+                     when :transversal
+                       a, b = key.split(".")
+                       record.send(a).send(b)
+                     when :belongs_to
+                       record.send(key).to_label
+                     else
+                       record.send(key)
+                     end
+                   end
+          end
+        end
       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)
+      send_file filename
 
     end
 
-    def generate_xml
-      fields = @resource[:class].typus_fields_for(:xml).collect { |i| i.first }
-      render :xml => data.to_xml(:only => fields)
+    def generate_json; export(:json); end
+    def generate_xml; export(:xml); end
+
+    def export(format)
+      fields = @resource.typus_fields_for(format).collect { |i| i.first }
+      methods = fields - @resource.column_names
+      except = @resource.column_names - fields
+      render format => data.send("to_#{format}", :methods => methods, :except => except)
     end
 
     def data(*args)
-      eager_loading = @resource[:class].reflect_on_all_associations(:belongs_to).map { |i| i.name }
+      eager_loading = @resource.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)
+      @resource.all(options)
     end
 
   end
 
-end
+end