qm-acts-as-generic-controller 0.1.21 → 0.2.0

data/Rakefile

@@ -10,10 +10,10 @@ begin
     gemspec.email = "marcin@saepia.net"
     gemspec.homepage = "http://q.saepia.net"
     gemspec.authors = ["Marcin Lewandowski"]
-    gemspec.version = "0.1.21"
+    gemspec.version = "0.2.0"
     gemspec.files = Rake::FileList.new [ "MIT-LICENSE", "Rakefile", "lib/*", "app/views/generic_controller/*" ]
     gemspec.add_dependency "qui-common-helpers", ">= 0.0.8"
-    gemspec.add_dependency "qui-index-table", ">= 0.0.8"
+    gemspec.add_dependency "qui-index-table", ">= 0.0.9"
     gemspec.add_dependency "qui-tabs", ">= 0.0.3"
     gemspec.add_dependency "qui-toolbar", ">= 0.0.5"
     gemspec.add_dependency "rfc822"

data/app/views/generic_controller/index.erb

@@ -27,4 +27,4 @@
     <%- end -%>
   <%- end -%>
 <%- end -%>
-<%= render :partial => "generic_controller/index_table", :locals => { :records => records, :class_name => class_name } %>
+<%= generic_index_table :records => records, :class_name => class_name %>

data/app/views/generic_controller/show.erb

@@ -81,7 +81,7 @@
           <%= link_to t(:"toolbar.create"), polymorphic_path([ "new", section, v[:class_name].table_name.singularize ], { association_attribute => record.id, :association_attribute => association_attribute }), :class => "create" %>
         <%- end -%>
 
-        <%= render :partial => "generic_controller/index_table", :locals => { :records => record.send(k).limit_with_security_scheme(:user => current_user), :class_name => v[:class_name] } %>
+        <%= generic_index_table :records => record.send(k).limit_with_security_scheme(:user => current_user), :class_name => v[:class_name] %>
         <%- tab_headers[k] = t(:"#{section_prefix}tabs.#{table_name}.#{k}") + " (#{record.send(k).limit_with_security_scheme(:user => current_user).size})" %>
       <%- end -%>
     

data/lib/qm-acts-as-generic-controller-controller.rb

@@ -36,7 +36,7 @@ module QM
       module InstanceMethods
         def index
           unless instance_variable_defined?(plural_variable)
-            instance_variable_set(plural_variable, model.limit_with_security_scheme(:user => current_user)) 
+            instance_variable_set(plural_variable, model.limit_with_security_scheme(:user => current_user, :paginate => true, :paginate_page => params[:page] || 1, :paginate_per_page => params[:per_page] || 100, :sort_by => params[:sort_by], :sort_order => params[:sort_order])) 
           end
           
           respond_to do |format|

data/lib/qm-acts-as-generic-controller-model.rb

@@ -8,37 +8,81 @@ module QM
       module ClassMethods
         def limit_with_security_scheme(options)
           # options[:user] - current user that performs the query
+          # options[:paginate] - set to true if you want to enable pagination, not applicable for the ExternalSystem request
+          # options[:paginate_page] - set to integer
+          # options[:sort_by] - field to sort by
+          # options[:sort_order] - "A" or "D"
           
           raise ArgumentError, "You must pass options[:user] to limit_with_security_scheme" unless options.has_key? :user
 
           return all if options[:user].is_a? ExternalSystem
-          
+
           # Return empty set if user has no privileges at all (nor index_any and index_created)
           unless options[:user].has_privileges?(:class_name => self, :generic_action => :index_any) or options[:user].has_privileges?(:class_name => self, :generic_action => :index_created)
-#            puts ":("
-#            puts options[:user].inspect
-#            puts self
-#            puts options[:user].has_privileges?(:class_name => self, :generic_action => :index_any)
-#            puts options[:user].has_privileges?(:class_name => self, :generic_action => :index_created)
-#            puts options[:user].has_privileges?(:class_name => self, :generic_action => :index_any) or options[:user].has_privileges?(:class_name => self, :generic_action => :index_created)
             return []
           end
           
           creator_column = "creator_#{options[:user].class.to_s.tableize.singularize}_id"
           should_limit_index_for_created = columns_hash.has_key?(creator_column) && options[:user].respond_to?(:has_privileges?) && !options[:user].has_privileges?(:class_name => self, :generic_action => :index_any) && options[:user].has_privileges?(:class_name => self, :generic_action => :index_created)
           
+          universal_find_params = {}
+          
+          if options.has_key? :sort_by and not options[:sort_by].nil?
+            # Sorting
+            if options[:sort_order] == "A"
+              sort_direction = "ASC"
+              sort_opposite_direction = "DESC"
+            else
+              sort_direction = "DESC"
+              sort_opposite_direction = "ASC"
+            end
+            
+            # FIXME what if this is not index?
+            generic_field = self.generic_fields[:index].detect{ |f| f[:name] == options[:sort_by].to_sym }
+            if generic_field and generic_field[:options].has_key? :sort_sql
+              universal_find_params[:order] = generic_field[:options][:sort_sql].gsub("%{DIRECTION}", sort_direction).gsub("%{OPPOSITE_DIRECTION}", sort_opposite_direction) 
+              
+            elsif self.columns_hash.has_key? options[:sort_by].to_s
+              universal_find_params[:order] = "#{options[:sort_by]} #{sort_direction}"
+            end
+          end
+                
           
           if respond_to? :limit_for_user
             if should_limit_index_for_created
-              limit_for_user(options[:user]).find(:all, :conditions => { creator_column => options[:user].id })
+              if defined? WillPaginate
+                logger.info "#{self}.limit_with_security_scheme: limit_for_user & limit_index_for_created & will_paginate(page = #{options[:paginate_page]}, per_page = #{options[:paginate_per_page]})"
+                limit_for_user(options[:user]).find(:all, universal_find_params).find(:all, :conditions => { creator_column => options[:user].id }).paginate(:page => options[:paginate_page], :per_page => options[:paginate_per_page])
+              else
+                logger.info "#{self}.limit_with_security_scheme: limit_for_user & limit_index_for_created"
+                limit_for_user(options[:user]).find(:all, universal_find_params).find(:all, :conditions => { creator_column => options[:user].id })
+              end
             else
-              limit_for_user(options[:user])
+              if defined? WillPaginate
+                logger.info "#{self}.limit_with_security_scheme: limit_for_user & will_paginate(page = #{options[:paginate_page]}, per_page = #{options[:paginate_per_page]})"
+                limit_for_user(options[:user]).find(:all, universal_find_params).paginate(:page => options[:paginate_page], :per_page => options[:paginate_per_page])
+              else
+                logger.info "#{self}.limit_with_security_scheme: limit_for_user"
+                limit_for_user(options[:user]).find(:all, universal_find_params)
+              end
             end
           else
             if should_limit_index_for_created
-              find(:all, :conditions => { creator_column => options[:user].id })
+              if defined? WillPaginate
+                logger.info "#{self}.limit_with_security_scheme: limit_index_for_created & will_paginate(page = #{options[:paginate_page]}, per_page = #{options[:paginate_per_page]})"
+                find(:all, :conditions => { creator_column => options[:user].id }).find(:all, universal_find_params).paginate(:page => options[:paginate_page], :per_page => options[:paginate_per_page])
+              else
+                logger.info "#{self}.limit_with_security_scheme: limit_index_for_created"
+                find(:all, :conditions => { creator_column => options[:user].id }).find(:all, universal_find_params)
+              end
             else
-              all
+              if defined? WillPaginate
+                logger.info "#{self}.limit_with_security_scheme: will_paginate(page = #{options[:paginate_page]}, per_page = #{options[:paginate_per_page]})"
+                find(:all, universal_find_params).paginate(:page => options[:paginate_page], :per_page => options[:paginate_per_page])
+              else
+                logger.info "#{self}.limit_with_security_scheme: (all)"
+                find(:all, universal_find_params)
+              end
             end
           end          
         end

data/lib/qm-acts-as-generic-controller-view.rb

@@ -36,6 +36,85 @@ module QM
         
         result
       end
+      
+      def generic_index_table(options = {})
+        records    = options[:records]    || instance_variable_get("@#{@controller.class.to_s.demodulize.gsub("Controller", "").tableize}")
+        class_name = options[:class_name] || @controller.class.to_s.demodulize.gsub("Controller", "").singularize.constantize
+
+        privileged_fields = class_name.generic_fields(:action => :index).collect{|field| field if not current_user.respond_to? "has_privileges?" or (class_name.generic_field_associations.has_key?(field[:name]) and current_user.has_privileges?(:class_name => class_name.generic_field_associations[field[:name]][:class_name])) or (current_user.has_privileges?(:class_name => class_name, :attribute => field[:name], :mode => :read)) }.compact
+
+        headers = privileged_fields.collect{ |x| x[:options][:index_header] || ".#{x[:name]}".to_sym }
+
+        controller_name = "#{defined?(section) ? "#{section.to_s.camelize}::" : ""}#{class_name.to_s.pluralize}".tableize
+
+        has_edit = ActionController::Routing::Routes.routes.collect{|x| x if x.matches_controller_and_action?(controller_name, "edit") }.compact.size > 0
+        has_delete = ActionController::Routing::Routes.routes.collect{|x| x if x.matches_controller_and_action?(controller_name, "destroy") }.compact.size > 0
+
+        if current_user.respond_to? "has_privileges?"
+          has_edit = has_edit && current_user.has_privileges?(:class_name => class_name, :generic_action => :update_any)
+          has_delete = has_edit && current_user.has_privileges?(:class_name => class_name, :generic_action => :delete_any)
+        end
+
+        class_name.generic_actions(:action => :index).size.times{ headers << :oneicon }
+
+        headers << :oneicon if has_edit
+        headers << :oneicon if has_delete
+        
+        
+        index_table records, :headers => headers, :class_name => class_name do |r|
+          row = ""
+          
+          privileged_fields.each do |field|
+            row << content_tag(:td) do
+              if field[:options].has_key? :renderer
+                send(field[:options][:renderer], { :record => r, :field => field, :action => :index }).to_s
+              else
+                generic_renderer(:index, { :record => r, :field => field }).to_s
+              end
+            end
+          end
+
+          class_name.generic_actions(:action => :index).each do |action|
+            row << content_tag(:td, send(action[:options][:renderer], { :action => :index, :record => r, :action => :index, :generic_action => action }), :class => "action #{action[:name]}")
+          end
+
+          if has_edit
+            row << content_tag(:td, :class => "action edit") do
+              link_to_edit(r)
+            end
+          end
+          
+          if has_delete
+            row << content_tag(:td, :class => "action delete") do
+              link_to_delete(r)
+            end
+          end
+          
+          row
+        end
+      end
+      
+      def index_table_th(content, options = {}) 
+        if options[:sort_by]
+          content_tag(:th, index_table_th_sort(content, options), options)
+        else
+          content_tag(:th, content, options)
+        end
+      end
+      
+      def index_table_th_sort(content, options = {})
+        c = ""
+        if params[:sort_by] == options[:sort_by]
+          if params[:sort_order] == "A"
+            c << image_tag("sort-asc.png", :alt => "^", :class => "sort-icon")
+          else
+            c << image_tag("sort-desc.png", :alt => "v", :class => "sort-icon")
+          end
+        end
+        
+        link_to(content + c, params.merge({ :sort_by => options[:sort_by], :sort_order => options[:sort_order]}))
+      end
+      
     
       def multiple_select(options = {})
         options.symbolize_keys!

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: qm-acts-as-generic-controller
 version: !ruby/object:Gem::Version 
-  hash: 49
+  hash: 23
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 21
-  version: 0.1.21
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Marcin Lewandowski
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-26 00:00:00 +01:00
+date: 2011-02-07 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -42,12 +42,12 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 15
+        hash: 13
         segments: 
         - 0
         - 0
-        - 8
-        version: 0.0.8
+        - 9
+        version: 0.0.9
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
@@ -150,8 +150,8 @@ homepage: http://q.saepia.net
 licenses: []
 
 post_install_message: 
-rdoc_options: []
-
+rdoc_options: 
+- --charset=UTF-8
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement