module ActiveScaffold module Helpers # Helpers that assist with the rendering of a Form Column module SearchColumnHelpers # This method decides which input to use for the given column. # It does not do any rendering. It only decides which method is responsible for rendering. def active_scaffold_search_for(column) options = active_scaffold_search_options(column) # first, check if the dev has created an override for this specific field for search if override_search_field?(column) send(override_search_field(column), @record, options[:name]) # first, check if the dev has created an override for this specific field elsif override_form_field?(column) send(override_form_field(column), @record, options[:name]) # second, check if the dev has specified a valid search_ui for this column, using specific ui for searches elsif column.search_ui and override_search?(column.search_ui) send(override_search(column.search_ui), column, options) # third, check if the dev has specified a valid search_ui for this column, using generic ui for forms elsif column.search_ui and override_input?(column.search_ui) send(override_input(column.search_ui), column, options) # fallback: we get to make the decision else if column.association or column.virtual? active_scaffold_search_text(column, options) else # regular model attribute column # if we (or someone else) have created a custom render option for the column type, use that if override_search?(column.column.type) send(override_search(column.column.type), column, options) # if we (or someone else) have created a custom render option for the column type, use that elsif override_input?(column.column.type) send(override_input(column.column.type), column, options) # final ultimate fallback: use rails' generic input method else # for textual fields we pass different options text_types = [:text, :string, :integer, :float, :decimal] options = active_scaffold_input_text_options(options) if text_types.include?(column.column.type) input(:record, column.name, options.merge(column.options)) end end end end # the standard active scaffold options used for class, name and scope def active_scaffold_search_options(column) { :name => "search[#{column.name}]", :class => "#{column.name}-input", :id => "search_#{column.name}"} end ## ## Search input methods ## def active_scaffold_search_multi_select(column, options) associated_options = @record.send(column.association.name).collect {|r| [r.to_label, r.id]} select_options = associated_options | options_for_association(column.association, true) return as_(:no_options) if select_options.empty? html = "<ul class=\"checkbox-list\" id=\"#{options[:id]}\">" associated_ids = associated_options.collect {|a| a[1]} select_options.each_with_index do |option, i| label, id = option this_name = "#{options[:name]}[#{i}][id]" this_id = "#{options[:id]}_#{i}_id" html << "<li>" html << check_box_tag(this_name, id, associated_ids.include?(id), :id => this_id) html << "<label for='#{this_id}'>" html << label html << "</label>" html << "</li>" end html << '</ul>' html << javascript_tag("new DraggableLists('#{options[:id]}')") if column.options[:draggable_lists] html end def active_scaffold_search_select(column, options) if column.association associated = @record.send(column.association.name) associated = associated.first if associated.is_a?(Array) # for columns with plural association select_options = options_for_association(column.association, true) select_options.unshift([ associated.to_label, associated.id ]) unless associated.nil? or select_options.find {|label, id| id == associated.id} selected = associated.nil? ? nil : associated.id method = column.association.macro == :belongs_to ? column.association.primary_key_name : column.name options[:name] += '[id]' select(:record, method, select_options.uniq, {:selected => selected, :include_blank => as_(:_select_)}, options) else select(:record, column.name, column.options, { :selected => @record.send(column.name) }, options) end end def active_scaffold_search_text(column, options) text_field :record, column.name, active_scaffold_input_text_options(options) end # we can't use active_scaffold_input_boolean because we need to have a nil value even when column can't be null # to decide whether search for this field or not def active_scaffold_search_boolean(column, options) select_options = [] select_options << [as_(:_select_), nil] select_options << [as_(:true), true] select_options << [as_(:false), false] select_tag(options[:name], options_for_select(select_options, @record.send(column.name))) end # we can't use checkbox ui because it's not possible to decide whether search for this field or not alias_method :active_scaffold_search_checkbox, :active_scaffold_search_boolean def active_scaffold_search_integer(column, options) html = [] html << select_tag("#{options[:name]}[opt]", options_for_select(ActiveScaffold::Finder::NumericComparators.collect {|comp| [as_(comp.downcase.to_sym), comp]}), :id => "#{options[:id]}_opt", :onchange => "Element[this.value == 'BETWEEN' ? 'show' : 'hide']('#{options[:id]}_between');") html << text_field_tag("#{options[:name]}[from]", nil, active_scaffold_input_text_options(:id => options[:id], :size => 10)) html << content_tag(:span, ' - ' + text_field_tag("#{options[:name]}[to]", nil, active_scaffold_input_text_options(:id => "#{options[:id]}_to", :size => 10)), :id => "#{options[:id]}_between", :style => "display:none") html * ' ' end alias_method :active_scaffold_search_decimal, :active_scaffold_search_integer alias_method :active_scaffold_search_float, :active_scaffold_search_integer def active_scaffold_search_datetime(column, options) options = column.options.merge(options) helper = "select_#{'date' unless options[:discard_date]}#{'time' unless options[:discard_time]}" html = [] html << send(helper, nil, {:include_blank => true, :prefix => "#{options[:name]}[from]"}.merge(options)) html << send(helper, nil, {:include_blank => true, :prefix => "#{options[:name]}[to]"}.merge(options)) html * ' - ' end def active_scaffold_search_date(column, options) active_scaffold_search_datetime(column, options.merge!(:discard_time => true)) end def active_scaffold_search_time(column, options) active_scaffold_search_datetime(column, options.merge!(:discard_date => true)) end alias_method :active_scaffold_search_timestamp, :active_scaffold_search_datetime ## ## Search column override signatures ## def override_search_field?(column) respond_to?(override_search_field(column)) end # the naming convention for overriding form fields with helpers def override_search_field(column) "#{column.name}_search_column" end def override_search?(search_ui) respond_to?(override_search(search_ui)) end # the naming convention for overriding search input types with helpers def override_search(form_ui) "active_scaffold_search_#{form_ui}" end end end end