active_scaffold_batch 3.2.0

data/lib/active_scaffold/actions/batch_create.rb

@@ -0,0 +1,247 @@
+module ActiveScaffold::Actions
+  module BatchCreate
+
+    def self.included(base)
+      base.send :include, ActiveScaffold::Actions::BatchBase unless base < ActiveScaffold::Actions::BatchBase
+      base.before_filter :batch_create_authorized_filter, :only => [:batch_new, :batch_create]
+      base.helper_method :batch_create_values
+      base.helper_method :batch_create_by_column
+      base.helper_method :batch_create_by_records
+    end
+
+    def batch_new
+      do_batch_new
+      respond_to_action(:batch_new)
+    end
+
+    def batch_add
+      do_batch_add
+      respond_to_action(:batch_add)
+    end
+
+    def batch_create
+      batch_action
+    end
+
+    
+    protected
+    def batch_new_respond_to_html
+      if batch_successful?
+        render(:action => 'batch_create')
+      else
+        return_to_main
+      end
+    end
+
+    def batch_new_respond_to_js
+      render(:partial => 'batch_create_form')
+    end
+
+    def batch_add_respond_to_js
+      render
+    end
+
+    def batch_create_values
+      @batch_create_values || {}
+    end
+
+    def batch_create_by_records
+      if @batch_create_by_records.nil?
+        if marked_records_parent
+          column = active_scaffold_config.columns[batch_create_by_column.to_sym]
+          @batch_create_by_records = if column.polymorphic_association?
+            active_scaffold_config_for(params[:batch_create_by].singularize).model.find(marked_records_parent.to_a)
+          else
+            column_plural_assocation_value_from_value(column, marked_records_parent)
+          end
+        end
+      end
+      @batch_create_by_records || []
+    end
+
+    def batch_create_respond_to_html
+      if params[:iframe]=='true' # was this an iframe post ?
+        do_refresh_list
+        responds_to_parent do
+          render :action => 'on_batch_create.js', :layout => false
+        end
+      else # just a regular post
+        if batch_successful?
+          return_to_main
+        else
+          render(:action => 'batch_create')
+        end
+      end
+    end
+
+    def batch_create_respond_to_js
+      do_refresh_list
+      render :action => 'on_batch_create'
+    end
+
+    def do_batch_new
+      self.successful = true
+      do_new
+      if batch_create_by_column
+        batch_scope # that s a dummy call to remove batch_scope parameter
+      else
+        @scope = temporary_id
+      end
+    end
+
+    def do_batch_add
+      @records = {}
+      t = temporary_id
+      params[:num_records].to_i.times do
+        @records[t.succ!] = do_new
+      end
+    end
+
+    def marked_records_parent
+      if @marked_records_parent.nil?
+        @marked_records_parent = if params[:batch_create_by]
+          session_parent = active_scaffold_session_storage(params[:batch_create_by])
+          session_parent[:marked_records] || Set.new
+        else
+          false
+        end
+      end
+      @marked_records_parent
+    end
+
+    def before_do_batch_create
+      if batch_create_by_column
+        create_columns = active_scaffold_config.batch_create.columns
+        @batch_create_values = create_attribute_values_from_params(create_columns, params[:record])
+      else
+        @batch_scope = 'multiple'
+      end
+    end
+
+    def run_in_transaction?
+      active_scaffold_config.batch_create.run_in_transaction
+    end
+
+    def validate_first?
+      active_scaffold_config.batch_create.run_in_transaction == :validate_first
+    end
+
+    def run_in_transaction_if_enabled
+      processed_records, created_records = 0
+      if run_in_transaction?
+        active_scaffold_config.model.transaction do
+          processed_records, created_records = yield
+          if processed_records == created_records
+            @error_records.each { |_, record| create_save(record) } if validate_first?
+            @error_records = []
+          else
+            created_records = 0
+            raise ActiveRecord::Rollback
+          end
+        end
+      else
+        processed_records, created_records = yield
+      end
+      flash[:info] = as_(:some_records_created, :count => created_records, :model => active_scaffold_config.label(:count => created_records)) if batch_successful? || created_records > 0
+    end
+
+    def batch_create_listed
+      run_in_transaction_if_enabled do
+        processed_records = created_records = 0
+        case active_scaffold_config.batch_create.process_mode
+        when :create then
+          batch_create_by_records.each do |batch_record|
+            create_record_in_batch(batch_record)
+            created_records += 1 if successful?
+            processed_records += 1
+          end
+        else
+          Rails.logger.error("Unknown process_mode: #{active_scaffold_config.batch_create.process_mode} for action batch_create")
+        end
+        [processed_records, created_records]
+      end
+    end
+    alias_method :batch_create_marked, :batch_create_listed
+
+    def batch_create_multiple
+      run_in_transaction_if_enabled do
+        @error_records = {}
+        processed_records = created_records = 0
+        params[:record].each do |scope, record_hash|
+          do_create(:attributes => record_hash, :skip_save => validate_first?)
+          error_records[scope] = @record unless successful? && !run_in_transaction?
+          created_records += 1 if successful?
+          processed_records += 1
+        end
+        [processed_records, created_records]
+      end
+    end
+
+    def new_batch_create_record(created_by)
+      new_model
+    end
+
+    def create_record_in_batch(created_by)
+      @successful = nil
+      @record = new_batch_create_record(created_by)
+      @record.send("#{batch_create_by_column.to_s}=", created_by)
+      batch_create_values.each do |attribute, value|
+        set_record_attribute(value[:column], attribute, value[:value])
+      end
+
+      if authorized_for_job?(@record)
+        create_save(@record)
+        if successful?
+          marked_records_parent.delete(created_by.id) if batch_scope == 'MARKED' && marked_records_parent
+        end
+        error_records << @record unless successful? && !run_in_transaction?
+      end
+    end
+
+    def batch_create_by_column
+      active_scaffold_config.batch_create.default_batch_by_column
+    end
+
+    def create_attribute_values_from_params(columns, attributes)
+      values = {}
+      columns.each :for => active_scaffold_config.model, :crud_type => :create, :flatten => true do |column|
+        next unless attributes.has_key?(column.name)
+        if column == batch_create_by_column.to_sym
+          @batch_create_by_records = column_plural_assocation_value_from_value(column, attributes[column.name])
+        else
+          values[column.name] = {:column => column, :value => column_value_from_param_value(nil, column, attributes[column.name])}
+        end
+      end
+      values
+    end
+    
+    # The default security delegates to ActiveRecordPermissions.
+    # You may override the method to customize.
+    def batch_create_authorized?(record = nil)
+      authorized_for?(:crud_type => :create)
+    end
+
+    def batch_create_ignore?(record = nil)
+      false
+    end
+
+    def override_batch_create_value(form_ui)
+      method = "batch_create_value_for_#{form_ui}"
+      method if respond_to? method
+    end
+
+    def create_ignore?
+      super || batch_create_by_column.blank?
+    end
+
+    private
+
+    def batch_create_authorized_filter
+      link = active_scaffold_config.batch_create.link || active_scaffold_config.batch_create.class.link
+      raise ActiveScaffold::ActionNotAllowed unless self.send(link.security_method)
+    end
+    def batch_new_formats
+      (default_formats + active_scaffold_config.formats).uniq
+    end
+  end
+end

data/lib/active_scaffold/actions/batch_destroy.rb

@@ -0,0 +1,77 @@
+module ActiveScaffold::Actions
+  module BatchDestroy
+
+    def self.included(base)
+      base.send :include, ActiveScaffold::Actions::BatchBase unless base < ActiveScaffold::Actions::BatchBase
+      base.before_filter :batch_destroy_authorized_filter, :only => [:batch_destroy]
+    end
+
+    def batch_destroy
+      batch_action
+    end
+    
+    protected
+
+    def before_do_batch_destroy
+    end
+
+    def batch_destroy_listed
+      case active_scaffold_config.batch_destroy.process_mode
+      when :delete then
+        each_record_in_scope do |record|
+          destroy_record(record) if authorized_for_job?(record)
+        end
+      when :delete_all then
+        do_search if respond_to? :do_search
+        # dummy condition cause we have to call delete_all on relation not on association
+        beginning_of_chain.where('1=1').delete_all(all_conditions)
+      else
+        Rails.logger.error("Unknown process_mode: #{active_scaffold_config.batch_destroy.process_mode} for action batch_destroy")
+      end
+      
+    end
+
+    def batch_destroy_marked
+      case active_scaffold_config.batch_destroy.process_mode
+      when :delete then
+        each_marked_record do |record|
+          destroy_record(record) if authorized_for_job?(record)
+        end
+      when :delete_all then
+        active_scaffold_config.model.where(active_scaffold_config.model.primary_key => marked_records.to_a).delete_all
+        do_demark_all
+      else
+        Rails.logger.error("Unknown process_mode: #{active_scaffold_config.batch_destroy.process_mode} for action batch_destroy")
+      end
+    end
+
+    def destroy_record(record)
+      @successful = nil
+      @record = record
+
+      do_destroy
+      if successful?
+        @record.as_marked = false if batch_scope == 'MARKED'
+      else
+        error_records << @record
+      end
+    end
+
+    # The default security delegates to ActiveRecordPermissions.
+    # You may override the method to customize.
+    def batch_destroy_authorized?(record = nil)
+      authorized_for?(:crud_type => :delete)
+    end
+
+    def batch_destroy_marked_ignore?(record = nil)
+      !active_scaffold_config.actions.include? :mark
+    end
+
+    private
+
+    def batch_destroy_authorized_filter
+      link = active_scaffold_config.batch_destroy.link || active_scaffold_config.batch_destroy.class.link
+      raise ActiveScaffold::ActionNotAllowed unless self.send(link.first.security_method)
+    end
+  end
+end

data/lib/active_scaffold/actions/batch_update.rb

@@ -0,0 +1,281 @@
+module ActiveScaffold::Actions
+  module BatchUpdate
+
+    GenericOperators = [
+      'NO_UPDATE',
+      'REPLACE'
+    ]
+    NumericOperators = [
+      'PLUS',
+      'MINUS',
+      'TIMES',
+      'DIVISION'
+    ]
+    NumericOptions = [
+      'ABSOLUTE',
+      'PERCENT'
+    ]
+
+    DateOperators = [
+      'PLUS',
+      'MINUS'
+    ]
+    
+    def self.included(base)
+      base.send :include, ActiveScaffold::Actions::BatchBase unless base < ActiveScaffold::Actions::BatchBase
+      base.before_filter :batch_update_authorized_filter, :only => [:batch_edit, :batch_update]
+      base.helper_method :batch_update_values
+    end
+
+    def batch_edit
+      do_batch_edit
+      respond_to_action(:batch_edit)
+    end
+
+    def batch_update
+      batch_action
+    end
+
+    
+    protected
+    def batch_edit_respond_to_html
+      if batch_successful?
+        render(:action => 'batch_update')
+      else
+        return_to_main
+      end
+    end
+
+    def batch_edit_respond_to_js
+      render(:partial => 'batch_update_form')
+    end
+
+    def batch_update_values
+      @batch_update_values || {}
+    end
+
+    def batch_update_respond_to_html
+      if params[:iframe]=='true' # was this an iframe post ?
+        flash[:info] = as_(:batch_processing_successful) if batch_successful?
+        do_refresh_list
+        responds_to_parent do
+          render :action => 'on_batch_update.js', :layout => false
+        end
+      else # just a regular post
+        if batch_successful?
+          flash[:info] = as_(:updated_model, :model => @record.to_label)
+          return_to_main
+        else
+          render(:action => 'batch_update')
+        end
+      end
+    end
+
+    def batch_update_respond_to_js
+      flash[:info] = as_(:batch_processing_successful) if batch_successful?
+      do_refresh_list
+      render :action => 'on_batch_update'
+    end
+
+    def do_batch_edit
+      self.successful = true
+      do_new
+    end
+
+    def before_do_batch_update
+      @batch_update_values = update_attribute_values_from_params(active_scaffold_config.batch_update.columns, params[:record])
+    end
+
+    def batch_update_listed
+      case active_scaffold_config.batch_update.process_mode
+      when :update then
+        each_record_in_scope {|record| update_record_in_batch(record) if authorized_for_job?(record)}
+      when :update_all then
+        updates = updates_for_update_all
+        unless updates.first.empty?
+          do_search if respond_to? :do_search
+          # all_conditions might fail cause joins are not working in update_all
+          active_scaffold_config.model.update_all(updates, all_conditions)
+        end
+      else
+        Rails.logger.error("Unknown process_mode: #{active_scaffold_config.batch_update.process_mode} for action batch_update")
+      end
+      
+    end
+
+    def batch_update_marked
+      case active_scaffold_config.batch_update.process_mode
+      when :update then
+        each_marked_record {|record| update_record_in_batch(record) if authorized_for_job?(record)}
+      when :update_all then
+        updates = updates_for_update_all
+        unless updates.first.empty?
+          active_scaffold_config.model.where(active_scaffold_config.model.primary_key => marked_records.to_a).update_all(updates)
+          do_demark_all
+        end
+      else
+        Rails.logger.error("Unknown process_mode: #{active_scaffold_config.batch_update.process_mode} for action batch_update")
+      end
+    end
+
+    def updates_for_update_all()
+      update_all = [[]]
+      batch_update_values.each do |attribute, value|
+        sql_set, value = get_update_all_attribute(value[:column], attribute, value[:value])
+        unless sql_set.nil?
+          update_all.first << sql_set
+          update_all << value if value.present?
+        end
+      end
+      update_all[0] = update_all.first.join(',')
+      update_all
+    end
+
+    def update_record_in_batch(record)
+      @successful = nil
+      @record = record
+
+      batch_update_values.each do |attribute, value|
+        set_record_attribute(value[:column], attribute, value[:value])
+      end
+      
+      update_save(:no_record_param_update => true)
+      if successful?
+        @record.as_marked = false if batch_scope == 'MARKED'
+      else
+        error_records << @record
+      end
+    end
+
+    def get_update_all_attribute(column, attribute, value)
+      form_ui = column_form_ui(column)
+      
+      if form_ui && (method = override_batch_update_all_value(form_ui))
+        update_value = send(method, column, value)
+        if update_value.nil?
+          sql_set = nil
+        else
+          sql_set = "#{attribute} = #{update_value}"
+          update_value = nil
+        end
+      else
+        sql_set = "#{attribute} = ?"
+        update_value = value[:value]
+      end
+      
+      return sql_set, update_value
+    end
+
+    def update_attribute_values_from_params(columns, attributes)
+      values = {}
+      attributes = {} unless attributes.is_a?(Hash)
+      columns.each :for => new_model, :crud_type => :update, :flatten => true do |column|
+        next unless attributes[column.name].is_a?(Hash) && params[:record][column.name][:operator] != 'NO_UPDATE'
+        value = attributes[column.name]
+        value = value.merge(:value => (value[:operator] == 'NULL') ? nil : column_value_from_param_value(nil, column, value[:value]))
+        values[column.name] = {:column => column, :value => value}
+      end
+      values
+    end
+    
+    # The default security delegates to ActiveRecordPermissions.
+    # You may override the method to customize.
+    def batch_update_authorized?(record = nil)
+      authorized_for?(:crud_type => :update)
+    end
+
+    def batch_update_ignore?(record = nil)
+      false
+    end
+
+    def batch_update_value_for_numeric(column, record, calculation_info)
+      current_value = record.send(column.name)
+      if ActiveScaffold::Actions::BatchUpdate::GenericOperators.include?(calculation_info[:operator]) || ActiveScaffold::Actions::BatchUpdate::NumericOperators.include?(calculation_info[:operator])
+        operand = self.class.condition_value_for_numeric(column, calculation_info[:value])
+        operand = current_value / 100 * operand  if calculation_info[:opt] == 'PERCENT'
+        case calculation_info[:operator]
+        when 'REPLACE' then operand
+        when 'NULL' then nil
+        when 'PLUS' then current_value.present? ? current_value + operand : nil
+        when 'MINUS' then current_value.present? ? current_value - operand : nil
+        when 'TIMES' then current_value.present? ? current_value * operand : nil
+        when 'DIVISION' then current_value.present? ? current_value / operand : nil
+        else
+          current_value
+        end
+      else
+        current_value
+      end
+    end
+    alias_method :batch_update_value_for_integer, :batch_update_value_for_numeric
+    alias_method :batch_update_value_for_decimal, :batch_update_value_for_numeric
+    alias_method :batch_update_value_for_float, :batch_update_value_for_numeric
+
+    def batch_update_all_value_for_numeric(column, calculation_info)
+      if ActiveScaffold::Actions::BatchUpdate::GenericOperators.include?(calculation_info[:operator]) || ActiveScaffold::Actions::BatchUpdate::NumericOperators.include?(calculation_info[:operator])
+        operand = active_scaffold_config.model.quote_value(self.class.condition_value_for_numeric(column, calculation_info[:value]))
+        if calculation_info[:opt] == 'PERCENT'
+          operand = "#{active_scaffold_config.model.connection.quote_column_name(column.name)} / 100.0 * #{operand}"
+        end
+        case calculation_info[:operator]
+        when 'REPLACE' then operand
+        when 'NULL' then active_scaffold_config.model.quote_value(nil)
+        when 'PLUS' then "#{active_scaffold_config.model.connection.quote_column_name(column.name)} + #{operand}"
+        when 'MINUS' then "#{active_scaffold_config.model.connection.quote_column_name(column.name)} - #{operand}"
+        when 'TIMES' then "#{active_scaffold_config.model.connection.quote_column_name(column.name)} * #{operand}"
+        when 'DIVISION' then "#{active_scaffold_config.model.connection.quote_column_name(column.name)} / #{operand}"
+        else
+          nil
+        end
+      else
+        nil
+      end
+    end
+    alias_method :batch_update_all_value_for_integer, :batch_update_all_value_for_numeric
+    alias_method :batch_update_all_value_for_decimal, :batch_update_all_value_for_numeric
+    alias_method :batch_update_all_value_for_float, :batch_update_all_value_for_numeric
+
+    def batch_update_value_for_date_picker(column, record, calculation_info)
+      current_value = record.send(column.name)
+      {"number"=>"", "unit"=>"DAYS", "value"=>"November 16, 2010", "operator"=>"REPLACE"}
+      if ActiveScaffold::Actions::BatchUpdate::GenericOperators.include?(calculation_info[:operator]) || ActiveScaffold::Actions::BatchUpdate::DateOperators.include?(calculation_info[:operator])
+        operand = self.class.condition_value_for_datetime(calculation_info[:value], column.column.type == :date ? :to_date : :to_time)
+        case calculation_info[:operator]
+        when 'REPLACE' then operand
+        when 'NULL' then nil
+        when 'PLUS' then
+          trend_number = [calculation_info['number'].to_i,  1].max
+          current_value.in((trend_number).send(calculation_info['unit'].downcase.singularize.to_sym))
+        when 'MINUS' then
+          trend_number = [calculation_info['number'].to_i,  1].max
+          current_value.ago((trend_number).send(calculation_info['unit'].downcase.singularize.to_sym))
+        else
+          current_value
+        end
+      else
+        current_value
+      end
+    end
+    alias_method :batch_update_value_for_calendar_date_select, :batch_update_value_for_date_picker
+
+    def override_batch_update_value(form_ui)
+      method = "batch_update_value_for_#{form_ui}"
+      method if respond_to? method
+    end
+
+    def override_batch_update_all_value(form_ui)
+      method = "batch_update_all_value_for_#{form_ui}"
+      method if respond_to? method
+    end
+
+    private
+
+    def batch_update_authorized_filter
+      link = active_scaffold_config.batch_update.link || active_scaffold_config.batch_update.class.link
+      raise ActiveScaffold::ActionNotAllowed unless self.send(link.security_method)
+    end
+    def batch_edit_formats
+      (default_formats + active_scaffold_config.formats).uniq
+    end
+  end
+end

data/lib/active_scaffold/config/batch_create.rb

@@ -0,0 +1,79 @@
+module ActiveScaffold::Config
+  class BatchCreate < ActiveScaffold::Config::Form
+    self.crud_type = :create
+    def initialize(*args)
+      super
+      @multipart = @core.create.multipart? if @core.actions.include? :create
+      @process_mode = self.class.process_mode
+      @list_mode_enabled = self.class.list_mode_enabled
+      @run_in_transaction = self.class.run_in_transaction
+      @layout = self.class.layout
+    end
+
+    # global level configuration
+    # --------------------------
+    # the ActionLink for this action
+    def self.link
+      @@link
+    end
+    def self.link=(val)
+      @@link = val
+    end
+    @@link = ActiveScaffold::DataStructures::ActionLink.new('batch_new', :label => :create, :type => :collection, :security_method => :batch_create_authorized?, :ignore_method => :batch_create_ignore?)
+
+    # configures where the plugin itself is located. there is no instance version of this.
+    cattr_accessor :plugin_directory
+    @@plugin_directory = File.expand_path(__FILE__).match(%{(^.*)/lib/active_scaffold/config/batch_create.rb})[1]
+
+    # configures how batch create should be processed
+    # :create => standard activerecord create including validations
+    cattr_accessor :process_mode
+    @@process_mode = :create
+
+    # you may update all records in list view or all marked records
+    # you might disable list mode with this switch if you think it is
+    # too "dangerous"
+    cattr_accessor :list_mode_enabled
+    @@list_mode_enabled = true
+
+    # run all create statements in a transaction, so no record is created
+    # if someone fails
+    cattr_accessor :run_in_transaction
+    @@run_in_transaction = true
+
+    # layout for create multiple records
+    cattr_accessor :layout
+    @@layout = :vertical
+
+    # instance-level configuration
+    # ----------------------------
+
+    # see class accessor
+    attr_accessor :process_mode
+
+    attr_accessor :list_mode_enabled
+
+    # you may use create_batch to create a record for each record
+    # of a belong_to association (reverse must be has_many)
+    # eg. player belongs to team
+    # you may batch create a player records for a list of teams
+    attr_accessor :default_batch_by_column
+
+    # run all create statements in a transaction, so no record is created
+    # if someone fails
+    attr_accessor :run_in_transaction
+
+    # layout for create multiple records
+    attr_accessor :layout
+
+    def action_group
+      @action_group || (default_batch_by_column ? 'collection.group' : 'collection')
+    end
+
+    # the label= method already exists in the Form base class
+    def label(model = nil)
+      model ||= @core.label(:count => 2)
+      @label ? as_(@label) : as_(:create_model, :model => model)
+    end
+  end
+end