brisk-bills 0.7.0 → 0.8.1

data/vendor/plugins/active_scaffold/lib/active_scaffold/actions/delete.rb

@@ -1,46 +1,73 @@
 module ActiveScaffold::Actions
   module Delete
     def self.included(base)
-      base.before_filter :delete_authorized?, :only => [:delete, :destroy]
+      base.before_filter :delete_authorized_filter, :only => [:delete, :destroy]
     end
 
     # this method is for html mode. it provides "the missing action" (http://thelucid.com/articles/2006/07/26/simply-restful-the-missing-action).
     # it also gives us delete confirmation for html mode. woo!
     def delete
-      @record = find_if_allowed(params[:id], :destroy)
+      destroy_find_record
       render :action => 'delete'
     end
 
     def destroy
       return redirect_to(params.merge(:action => :delete)) if request.get?
-
       do_destroy
-
-      respond_to do |type|
-        type.html do
-          flash[:info] = as_(:deleted_model, :model => @record.to_label)
-          return_to_main
-        end
-        type.js { render(:action => 'destroy') }
-        type.xml { render :xml => successful? ? "" : response_object.to_xml, :content_type => Mime::XML, :status => response_status }
-        type.json { render :text => successful? ? "" : response_object.to_json, :content_type => Mime::JSON, :status => response_status }
-        type.yaml { render :text => successful? ? "" : response_object.to_yaml, :content_type => Mime::YAML, :status => response_status }
-      end
+      respond_to_action(:destroy)
     end
 
     protected
+    def destroy_respond_to_html
+      flash[:info] = as_(:deleted_model, :model => @record.to_label) if self.successful?
+      return_to_main
+    end
+
+    def destroy_respond_to_js
+      render(:action => 'destroy')
+    end
+
+    def destroy_respond_to_xml
+      render :xml => successful? ? "" : response_object.to_xml(:only => active_scaffold_config.list.columns.names), :content_type => Mime::XML, :status => response_status
+    end
+
+    def destroy_respond_to_json
+      render :text => successful? ? "" : response_object.to_json(:only => active_scaffold_config.list.columns.names), :content_type => Mime::JSON, :status => response_status
+    end
+
+    def destroy_respond_to_yaml
+      render :text => successful? ? "" : Hash.from_xml(response_object.to_xml(:only => active_scaffold_config.list.columns.names)).to_yaml, :content_type => Mime::YAML, :status => response_status
+    end
+
+    def destroy_find_record
+      @record = find_if_allowed(params[:id], :delete)
+    end
 
     # A simple method to handle the actual destroying of a record
     # May be overridden to customize the behavior
     def do_destroy
-      @record = find_if_allowed(params[:id], :destroy)
-      self.successful = @record.destroy
+      destroy_find_record
+      begin
+        self.successful = @record.destroy
+        marked_records.delete @record.id.to_s if successful?
+      rescue
+        flash[:warning] = as_(:cant_destroy_record, :record => @record.to_label)
+        self.successful = false
+      end
     end
 
     # The default security delegates to ActiveRecordPermissions.
     # You may override the method to customize.
     def delete_authorized?
-      authorized_for?(:action => :destroy)
+      authorized_for?(:crud_type => :delete)
+    end
+    private
+    def delete_authorized_filter
+      link = active_scaffold_config.delete.link || active_scaffold_config.delete.class.link
+      raise ActiveScaffold::ActionNotAllowed unless self.send(link.security_method)
+    end
+    def destroy_formats
+      (default_formats + active_scaffold_config.formats + active_scaffold_config.delete.formats).uniq
     end
   end
 end

data/vendor/plugins/active_scaffold/lib/active_scaffold/actions/field_search.rb

@@ -1,46 +1,60 @@
-module ActiveScaffold::Actions
-  module FieldSearch
-    def self.included(base)
-      base.before_filter :field_search_authorized?, :only => :show_search
-      base.before_filter :do_search
-    end
-
-    # FieldSearch uses params[:search] and not @record because search conditions do not always pass the Model's validations.
-    # This facilitates for example, textual searches against associations via .search_sql
-    def show_search
-      params[:search] ||= {}
-      @record = active_scaffold_config.model.new
-      respond_to do |type|
-        type.html { render(:action => "field_search") }
-        type.js { render(:partial => "field_search") }
-      end
-    end
-
-    protected
-
-    def do_search
-      unless params[:search].nil?
-        like_pattern = active_scaffold_config.field_search.full_text_search? ? '%?%' : '?%'
-        search_conditions = []
-        columns = active_scaffold_config.field_search.columns
-        columns.each do |column|
-          search_conditions << self.class.condition_for_column(column, params[:search][column.name], like_pattern)
-        end
-        search_conditions.compact!
-        self.active_scaffold_conditions = merge_conditions(self.active_scaffold_conditions, *search_conditions)
-        @filtered = !search_conditions.blank?
-
-        includes_for_search_columns = columns.collect{ |column| column.includes}.flatten.uniq.compact
-        self.active_scaffold_joins.concat includes_for_search_columns
-
-        active_scaffold_config.list.user.page = nil
-      end
-    end
-
-    # The default security delegates to ActiveRecordPermissions.
-    # You may override the method to customize.
-    def field_search_authorized?
-      authorized_for?(:action => :read)
-    end
-  end
-end
+module ActiveScaffold::Actions
+  module FieldSearch
+    include ActiveScaffold::Actions::CommonSearch
+    def self.included(base)
+      base.before_filter :search_authorized_filter, :only => :show_search
+      base.before_filter :store_search_params_into_session, :only => [:list, :index]
+      base.before_filter :do_search, :only => [:list, :index]
+      base.helper_method :field_search_params
+    end
+
+    # FieldSearch uses params[:search] and not @record because search conditions do not always pass the Model's validations.
+    # This facilitates for example, textual searches against associations via .search_sql
+    def show_search
+      @record = active_scaffold_config.model.new
+      respond_to_action(:field_search)
+    end
+
+    protected
+    def field_search_params
+      search_params || {}
+    end
+
+    def field_search_respond_to_html
+      render(:action => "field_search")
+    end
+    
+    def field_search_respond_to_js
+      render(:partial => "field_search")
+    end
+
+    def do_search
+      unless search_params.blank?
+        text_search = active_scaffold_config.field_search.text_search
+        search_conditions = []
+        columns = active_scaffold_config.field_search.columns
+        search_params.each do |key, value|
+          next unless columns.include? key
+          search_conditions << self.class.condition_for_column(active_scaffold_config.columns[key], value, text_search)
+        end
+        search_conditions.compact!
+        self.active_scaffold_conditions = merge_conditions(self.active_scaffold_conditions, *search_conditions)
+        @filtered = !search_conditions.blank?
+
+        includes_for_search_columns = columns.collect{ |column| column.includes}.flatten.uniq.compact
+        self.active_scaffold_includes.concat includes_for_search_columns
+
+        active_scaffold_config.list.user.page = nil
+      end
+    end
+
+    private
+    def search_authorized_filter
+      link = active_scaffold_config.field_search.link || active_scaffold_config.field_search.class.link
+      raise ActiveScaffold::ActionNotAllowed unless self.send(link.security_method)
+    end
+    def field_search_formats
+      (default_formats + active_scaffold_config.formats + active_scaffold_config.field_search.formats).uniq
+    end
+  end
+end

data/vendor/plugins/active_scaffold/lib/active_scaffold/actions/list.rb

@@ -1,29 +1,14 @@
 module ActiveScaffold::Actions
   module List
     def self.included(base)
-      base.before_filter :list_authorized?, :only => [:index, :table, :update_table, :row, :list]
+      base.before_filter :list_authorized_filter, :only => [:index, :row, :list]
+      base.send :include, ActiveScaffold::Actions::Mark if base.active_scaffold_config.list.mark_records
     end
 
     def index
       list
     end
 
-    def table
-      do_list
-      render(:action => 'list', :layout => false)
-    end
-
-    # This is called when changing pages, sorts and search
-    def update_table
-      respond_to do |type|
-        type.js do
-          do_list
-          render(:partial => 'list')
-        end
-        type.html { return_to_main }
-      end
-    end
-
     # get just a single row
     def row
       render :partial => 'list_record', :locals => {:record => find_if_allowed(params[:id], :read)}
@@ -31,39 +16,52 @@ module ActiveScaffold::Actions
 
     def list
       do_list
-      if active_scaffold_config.list.always_show_create
-        do_new
-      end
-      respond_to do |type|
-        type.html { render :action => 'list' }
-        type.js { render :action => 'list', :layout => false }
-        type.xml { render :xml => response_object.to_xml, :content_type => Mime::XML, :status => response_status }
-        type.json { render :text => response_object.to_json, :content_type => Mime::JSON, :status => response_status }
-        type.yaml { render :text => response_object.to_yaml, :content_type => Mime::YAML, :status => response_status }
-      end
+      do_new if active_scaffold_config.list.always_show_create
+      @record ||= active_scaffold_config.model.new if active_scaffold_config.list.always_show_search
+      respond_to_action(:list)
     end
-
+    
     protected
+    def list_respond_to_html
+      render :action => 'list', :layout => !respond_to?(:component_request?) || !component_request?
+    end
+    def list_respond_to_js
+      render :action => 'list.js'
+    end
+    def list_respond_to_xml
+      render :xml => response_object.to_xml(:only => active_scaffold_config.list.columns.names), :content_type => Mime::XML, :status => response_status
+    end
+    def list_respond_to_json
+      render :text => response_object.to_json(:only => active_scaffold_config.list.columns.names), :content_type => Mime::JSON, :status => response_status
+    end
+    def list_respond_to_yaml
+      render :text => Hash.from_xml(response_object.to_xml(:only => active_scaffold_config.list.columns.names)).to_yaml, :content_type => Mime::YAML, :status => response_status
+    end
+
+    def set_includes_for_list_columns
+      includes_for_list_columns = active_scaffold_config.list.columns.collect{ |c| c.includes }.flatten.uniq.compact
+      self.active_scaffold_includes.concat includes_for_list_columns
+    end
 
     # The actual algorithm to prepare for the list view
     def do_list
-      includes_for_list_columns = active_scaffold_config.list.columns.collect{ |c| c.includes }.flatten.uniq.compact
-      self.active_scaffold_joins.concat includes_for_list_columns
+      set_includes_for_list_columns
 
       options = { :sorting => active_scaffold_config.list.user.sorting,
                   :count_includes => active_scaffold_config.list.user.count_includes }
-      paginate = (params[:format].nil?) ? (accepts? :html, :js) : [:html, :js].include?(params[:format])
+      paginate = (params[:format].nil?) ? (accepts? :html, :js) : ['html', 'js'].include?(params[:format])
       if paginate
         options.merge!({
           :per_page => active_scaffold_config.list.user.per_page,
-          :page => active_scaffold_config.list.user.page
+          :page => active_scaffold_config.list.user.page, 
+          :pagination => active_scaffold_config.list.pagination
         })
       end
 
-      page = find_page(options);
-      if page.items.empty?
-        page = page.pager.first
-        active_scaffold_config.list.user.page = 1
+      page = find_page(options)
+      if page.items.blank? && !page.pager.infinite?
+        page = page.pager.last
+        active_scaffold_config.list.user.page = page.number
       end
       @page, @records = page, page.items
     end
@@ -71,7 +69,14 @@ module ActiveScaffold::Actions
     # The default security delegates to ActiveRecordPermissions.
     # You may override the method to customize.
     def list_authorized?
-      authorized_for?(:action => :read)
+      authorized_for?(:crud_type => :read)
+    end
+    private
+    def list_authorized_filter
+      raise ActiveScaffold::ActionNotAllowed unless list_authorized?
+    end
+    def list_formats
+      (default_formats + active_scaffold_config.formats + active_scaffold_config.list.formats).uniq
     end
   end
 end

data/vendor/plugins/active_scaffold/lib/active_scaffold/actions/mark.rb

@@ -0,0 +1,72 @@
+module ActiveScaffold::Actions
+  module Mark
+
+    def self.included(base)
+      base.before_filter :mark_authorized?, :only => :mark
+      #base.prepend_before_filter :assign_marked_records_to_model
+      base.helper_method :marked_records
+    end
+
+    def mark
+      if mark?
+        do_mark
+      else
+        do_unmark
+      end
+      mark_respond_to_js
+    end
+
+    protected
+    # We need to give the ActiveRecord classes a handle to currently marked records. We don't want to just pass the object,
+    # because the object may change. So we give ActiveRecord a proc that ties to the
+    # marked_records_method on this ApplicationController.
+    def assign_marked_records_to_model
+      active_scaffold_config.model.marked_records_proc = proc {send(:marked_records)}
+    end
+
+    def mark?
+      params[:value] == 'true'
+    end
+    
+    def do_mark
+      if params[:id]
+        marked_records << params[:id]
+      else
+        each_record_in_scope {|record| marked_records << record.id.to_s}
+      end
+    end
+
+    def do_unmark
+      if params[:id]
+        marked_records.delete params[:id]
+      else
+        each_record_in_scope {|record| marked_records.delete(record.id.to_s)}
+      end
+    end
+    
+    def each_record_in_scope
+      do_search if respond_to? :do_search
+      set_includes_for_list_columns
+      find_options = finder_options
+      find_options[:include] = nil if find_options[:conditions].nil?
+      beginning_of_chain.all(find_options).each {|record| yield record}
+    end
+
+    def mark_respond_to_js
+      if params[:id]
+        do_search if respond_to? :do_search
+        set_includes_for_list_columns
+        count = beginning_of_chain.count(count_options(finder_options, active_scaffold_config.list.user.count_includes))
+        @mark = marked_records.length >= count
+      else
+        @mark = mark?
+      end
+    end
+
+    # The default security delegates to ActiveRecordPermissions.
+    # You may override the method to customize.
+    def mark_authorized?
+      authorized_for?(:crud_type => :read)
+    end
+  end
+end

data/vendor/plugins/active_scaffold/lib/active_scaffold/actions/nested.rb

@@ -8,65 +8,38 @@ module ActiveScaffold::Actions
         include ActiveScaffold::Actions::Nested::ChildMethods if active_scaffold_config.model.reflect_on_all_associations.any? {|a| a.macro == :has_and_belongs_to_many}
       end
       base.before_filter :include_habtm_actions
-      # TODO: it's a bit wasteful to run this routine every page load.
-      base.before_filter :links_for_associations
       base.helper_method :nested_habtm?
     end
 
     def nested
       do_nested
-
-      respond_to do |type|
-        type.html { render :partial => 'nested', :layout => true }
-        type.js { render :partial => 'nested' }
-      end
+      respond_to_action(:nested)
     end
 
     protected
-
+    def nested_respond_to_html
+      render :partial => 'nested', :layout => true
+    end
+    def nested_respond_to_js
+      render :partial => 'nested'
+    end
     # A simple method to find the record we'll be nesting *from*
     # May be overridden to customize the behavior
     def do_nested
       @record = find_if_allowed(params[:id], :read)
     end
 
-    # Create the automatic column links. Note that this has to happen when configuration is *done*, because otherwise the Nested module could be disabled. Actually, it could still be disabled later, couldn't it?
-    # TODO: This should really be a post-config routine, instead of a before_filter.
-    def links_for_associations
-      active_scaffold_config.list.columns.each do |column|
-        # if column.link == false we won't create a link. that's how a dev can suppress the auto links.
-        if column.association and column.link.nil?
-          if column.plural_association?
-            # note: we can't create nested scaffolds on :through associations because there's no reverse association.
-            column.set_link('nested', :parameters => {:associations => column.name.to_sym}) #unless column.through_association?
-          elsif not column.polymorphic_association?
-            model = column.association.klass
-            begin
-              controller = self.class.active_scaffold_controller_for(model)
-            rescue ActiveScaffold::ControllerNotFound
-              next
-            end
-
-            actions = controller.active_scaffold_config.actions
-            action = nil
-            if actions.include? :update and column.actions_for_association_links.include? :edit and model.authorized_for? :action => :update
-              action = 'edit'
-            elsif actions.include? :show and column.actions_for_association_links.include? :show and model.authorized_for? :action => :read
-              action = 'show'
-            end
-            column.set_link(action, :controller => controller.controller_path, :parameters => {:parent_controller => params[:controller]}) if action
-          end
-        end
-      end
+    def nested_authorized?
+      true
     end
 
     def include_habtm_actions
       if nested_habtm?
         # Production mode is ok with adding a link everytime the scaffold is nested - we ar not ok with that.
-        active_scaffold_config.action_links.add('new_existing', :label => 'Add Existing', :type => :table, :security_method => :add_existing_authorized?) unless active_scaffold_config.action_links['new_existing']
+        active_scaffold_config.action_links.add('new_existing', :label => :add_existing, :type => :collection, :security_method => :add_existing_authorized?) unless active_scaffold_config.action_links['new_existing']
         if active_scaffold_config.nested.shallow_delete
-          active_scaffold_config.action_links.add('destroy_existing', :label => 'Remove', :type => :record, :confirm => 'are_you_sure', :method => :delete, :position => false, :security_method => :delete_existing_authorized?) unless active_scaffold_config.action_links['destroy_existing']
-          active_scaffold_config.action_links.delete("destroy") if active_scaffold_config.action_links['destroy']
+          active_scaffold_config.action_links.add('destroy_existing', :label => :remove, :type => :member, :confirm => :are_you_sure_to_delete, :method => :delete, :position => false, :security_method => :delete_existing_authorized?) unless active_scaffold_config.action_links['destroy_existing']
+          active_scaffold_config.action_links.delete("delete") if active_scaffold_config.action_links['delete']
         end
       else
         # Production mode is caching this link into a non nested scaffold
@@ -74,7 +47,7 @@ module ActiveScaffold::Actions
         
         if active_scaffold_config.nested.shallow_delete
           active_scaffold_config.action_links.delete("destroy_existing") if active_scaffold_config.action_links['destroy_existing']
-          active_scaffold_config.action_links.add('destroy', :label => 'Delete', :type => :record, :confirm => 'are_you_sure', :method => :delete, :position => false, :security_method => :delete_authorized?) unless active_scaffold_config.action_links['destroy']
+          active_scaffold_config.action_links.add(ActiveScaffold::Config::Delete.link) unless active_scaffold_config.action_links['delete']
         end
         
       end
@@ -103,7 +76,10 @@ module ActiveScaffold::Actions
       return active_scaffold_constraints.values.to_s if nested?
       nil
     end
-
+    private
+    def nested_formats
+      (default_formats + active_scaffold_config.formats + active_scaffold_config.nested.formats).uniq
+    end
   end
 end
 
@@ -112,73 +88,90 @@ module ActiveScaffold::Actions::Nested
 
     def self.included(base)
       super
-      # This .verify method call is clashing with other non .add_existing actions. How do we do this correctly? Can we make it action specific.
-      # base.verify :method => :post,
-      #             :only => :add_existing,
-      #             :redirect_to => { :action => :index }
+      base.verify :method => :post,
+                  :only => :add_existing,
+                  :redirect_to => { :action => :index }
     end
 
     def new_existing
       do_new
-
-      respond_to do |type|
-        type.html do
-          if successful?
-            render(:action => 'add_existing_form')
-          else
-            return_to_main
-          end
-        end
-        type.js do
-          render(:partial => 'add_existing_form')
-        end
-      end
+      respond_to_action(:new_existing)
     end
 
     def add_existing
       do_add_existing
-
-      respond_to do |type|
-        type.html do
-          if successful?
-            flash[:info] = as_(:created_model, :model => @record.to_label)
-            return_to_main
-          else
-            render(:action => 'add_existing_form')
-          end
-        end
-        type.js do
-          if successful?
-            render :action => 'add_existing'
-          else
-            render :action => 'form_messages'
-          end
-        end
-        type.xml { render :xml => response_object.to_xml, :content_type => Mime::XML, :status => response_status }
-        type.json { render :text => response_object.to_json, :content_type => Mime::JSON, :status => response_status }
-        type.yaml { render :text => response_object.to_yaml, :content_type => Mime::YAML, :status => response_status }
-      end
+      respond_to_action(:add_existing)
     end
 
     def destroy_existing
       return redirect_to(params.merge(:action => :delete)) if request.get?
-
       do_destroy_existing
-
-      respond_to do |type|
-        type.html do
-          flash[:info] = as_(:deleted_model, :model => @record.to_label)
-          return_to_main
-        end
-        type.js { render(:action => 'destroy') }
-        type.xml { render :xml => successful? ? "" : response_object.to_xml, :content_type => Mime::XML, :status => response_status }
-        type.json { render :text => successful? ? "" : response_object.to_json, :content_type => Mime::JSON, :status => response_status }
-        type.yaml { render :text => successful? ? "" : response_object.to_yaml, :content_type => Mime::YAML, :status => response_status }
-      end
+      respond_to_action(:destroy_existing)
     end
     
     protected
+    def new_existing_respond_to_html
+      if successful?
+        render(:action => 'add_existing_form')
+      else
+        return_to_main
+      end
+    end
+    def new_existing_respond_to_js
+      render(:partial => 'add_existing_form')
+    end
+    def add_existing_respond_to_html
+      if successful?
+        flash[:info] = as_(:created_model, :model => @record.to_label)
+        return_to_main
+      else
+        render(:action => 'add_existing_form')
+      end
+    end
+    def add_existing_respond_to_js
+      if successful?
+        render :action => 'add_existing'
+      else
+        render :action => 'form_messages'
+      end
+    end
+    def add_existing_respond_to_xml
+      render :xml => response_object.to_xml(:only => active_scaffold_config.list.columns.names), :content_type => Mime::XML, :status => response_status
+    end
+    def add_existing_respond_to_json
+      render :text => response_object.to_json(:only => active_scaffold_config.list.columns.names), :content_type => Mime::JSON, :status => response_status
+    end
+    def add_existing_respond_to_yaml
+      render :text => Hash.from_xml(response_object.to_xml(:only => active_scaffold_config.list.columns.names)).to_yaml, :content_type => Mime::YAML, :status => response_status
+    end
+    def destroy_existing_respond_to_html
+      flash[:info] = as_(:deleted_model, :model => @record.to_label)
+      return_to_main
+    end
+
+    def destroy_existing_respond_to_js
+      render(:action => 'destroy')
+    end
 
+    def destroy_existing_respond_to_xml
+      render :xml => successful? ? "" : response_object.to_xml(:only => active_scaffold_config.list.columns.names), :content_type => Mime::XML, :status => response_status
+    end
+
+    def destroy_existing_respond_to_json
+      render :text => successful? ? "" : response_object.to_json(:only => active_scaffold_config.list.columns.names), :content_type => Mime::JSON, :status => response_status
+    end
+
+    def destroy_existing_respond_to_yaml
+      render :text => successful? ? "" : Hash.from_xml(response_object.to_xml(:only => active_scaffold_config.list.columns.names)).to_yaml, :content_type => Mime::YAML, :status => response_status
+    end
+
+    def add_existing_authorized?
+      true
+    end
+    def delete_existing_authorized?
+      true
+    end
+ 
     def after_create_save(record)
       if params[:association_macro] == :has_and_belongs_to_many
         params[:associated_id] = record
@@ -210,6 +203,15 @@ module ActiveScaffold::Actions::Nested
         do_destroy
       end
     end
-
+    private
+    def new_existing_formats
+      (default_formats + active_scaffold_config.formats).uniq
+    end
+    def add_existing_formats
+      (default_formats + active_scaffold_config.formats).uniq
+    end
+    def destroy_existing_formats
+      (default_formats + active_scaffold_config.formats).uniq
+    end
   end
 end