Redmine

     assert v.valid?

   end

   def test_multi_list_field_validation

     f = CustomField.new(:field_format => 'list', :allow_multi => true, :possible_values => ['value1', 'value2'])

     v = CustomValuesCollection.new(:custom_field => f, :value => [])

     assert v.valid?

     v << CustomValue.new(:custom_field => f, :value => 'value1')

     assert v.valid?

     v << CustomValue.new(:custom_field => f, :value => 'value2')

     assert v.valid?

     v << CustomValue.new(:custom_field => f, :value => 'abc')

     assert !v.valid?

   end

   def test_multi_list_field_value

     f = CustomField.new(:field_format => 'list', :allow_multi => true, :possible_values => ['value1', 'value2'])

     v = CustomValuesCollection.new(:custom_field => f, :value => [])

     v << CustomValue.new(:custom_field => f, :value => 'value1')

     c = CustomValue.new(:custom_field => f, :value => 'value2')

     v << c

     assert_equal ['value1', 'value2'], v.value

     v << c

     assert ['value1', 'value2'], v.value

   end

   def test_int_field_validation

      #select_tag(field_name, blank_option + options_for_select(custom_field.possible_values_options(custom_value.customized), custom_value.value), :id => field_id)

      multi_image = custom_field.allow_multi ?

                    link_to_function(image_tag('bullet_toggle_plus.png'), "toggle_multi_custom('#{custom_field.id}');", :style => "vertical-align: bottom;") :

                    ''

      multiple = custom_field.allow_multi && custom_value.value.is_a?(Array) && custom_value.value.length > 1

      select_name = custom_field.allow_multi ? "#{name}[custom_multi_values][#{custom_field.id}][]" : field_name

      select_tag(select_name, blank_option + options_for_select(custom_field.possible_values, custom_value.value), :id => field_id, :multiple => multiple) + multi_image

    format_value((custom_value.value.is_a?(Array) ? custom_value.value.join("\n") : custom_value.value), custom_value.custom_field.field_format)

    # make sure only list field_format have allow_multi option

    self.allow_multi = false unless field_format == 'list'

	'custom_multi_values',

    #self.custom_values.each {|c| @custom_values_before_change.store c.custom_field_id, c.value }

	custom_field_values.each {|c| @custom_values_before_change.store c.custom_field.id, c.value }

                                                      :value => send(c)) unless send(c)==@issue_before_change.send(c)

      custom_field_values.each {|c|

    self.value = value.join(", ") if value && value.is_a?(Array)

    self.old_value = old_value.join(", ") if old_value && old_value.is_a?(Array)

class CustomValuesCollection < Array

  attr_accessor :custom_field

  def initialize(custom_field, custom_values=[])

    @custom_field = custom_field if custom_field.is_a?(CustomField)    

    custom_values.map{ |x| self << x }

    self

  end	

  def value

    self.uniq.map(&:value).delete_if {|x| x.blank?}

  end

  def value=(new_value)

    self.delete_if{ |x| true }

    new_value.map{ |x| self << x }

  end

  def save

    self.compact.each(&:save)

  end

  def valid?

    self.inject(true){ |bool,v| bool && v.valid? }

  end

  def validate

    self.uniq.map(&:validate)

  end

  def custom_field_id

    @custom_field.id

  end

  def method_missing(symbol, *args)

    if @custom_field.respond_to?(symbol)

      @custom_field.send(symbol, *args)

    elsif self.first && self.first.respond_to?(symbol)

      self.first.send(symbol, *args)

    else

      super

    end

  end

end

	@custom_values = @issue.custom_field_values

	@custom_values = @issue.custom_field_values

  p_multi = $("custom_field_allow_multi");

	  Element.show(p_multi.parentNode);

	  Element.hide(p_multi.parentNode);

      Element.hide(p_multi.parentNode);

	  Element.hide(p_multi.parentNode);

	<p><%= f.check_box :allow_multi %></p>

	<% @project.custom_field_values.each do |custom_value| %>

<script type="text/javascript">

//<![CDATA[

function toggle_multi_custom(field) {

  select = $('issue_custom_field_values_' + field);

    if (select.multiple == true) {

      select.multiple = false;

    } else {

      select.multiple = true;

  }

}

//]]>

</script>

class AddCustomFieldsMulti < ActiveRecord::Migration

  def self.up

    add_column :custom_fields, :allow_multi, :boolean, :default => false

  end

  def self.down

    remove_column :custom_fields, :allow_multi

  end

end

            if custom_value.is_a? CustomValuesCollection

              if custom_value.empty?

                values.each do |key, value|

                  if (custom_value.custom_field_id == key.to_i && value.is_a?(Array))

                    if value.empty?

                      custom_value << custom_values.build(:custom_field => custom_value.custom_field, :value => nil)

                    else

                      value.each do |v|

                        custom_value << custom_values.build(:custom_field => custom_value.custom_field, :value => v)

                      end

                    end

                  end

                end

              end

              CustomValue # otherwise Rails doesn't know the CustomValuesCollection class

              custom_value = CustomValuesCollection.new custom_value.custom_field, custom_value

              #end

            else

              custom_value.value = values[custom_value.custom_field_id.to_s] if values.has_key?(custom_value.custom_field_id.to_s)

            end

          @custom_field_values ||= available_custom_fields.collect do |x|

            if x.allow_multi

              CustomValue # otherwise Rails doesn't know the CustomValuesCollection class

              CustomValuesCollection.new x, custom_values.select{ |v| v.custom_field == x }

            else

              custom_values.detect { |v| v.custom_field == x } || custom_values.build(:custom_field => x, :value => nil)

            end

          end

        def custom_multi_values=(values)

          values.each do |key, value|

            value.delete_if {|v| v.to_s == ""} if value.length > 1

          end

          @old_custom_values ||= custom_values.select{ |x| x.custom_field.allow_multi }

          @custom_field_values_changed = true

          values = values.stringify_keys

          values.each do |key, value|

            custom_value = custom_field_values.detect{ |c| c.custom_field.id == key.to_i && c.allow_multi }

            value.each do |v|

              old = @old_custom_values.detect{ |u| u.custom_field == custom_value.custom_field && u.value == v }

              if old.blank?

                custom_value << custom_values.build(:custom_field => custom_value.custom_field, :value => v)

              else

                custom_value << old unless custom_value.include?(old)

                @old_custom_values.delete old

              end

            end if values.is_a?(Hash) && custom_value != nil && values.has_key?(custom_value.custom_field.id.to_s)

          end

          #delete old normal values

          @custom_field_values.each { |c| c.delete_if{ |x| @old_custom_values.include?(x) } if c.is_a?(CustomValuesCollection) }

          @custom_values.delete_if { |c| @old_custom_values.include?(c) }

		  @old_custom_values.each(&:destroy) unless @old_custom_values.blank?

end

  field_allow_multi: Allow multiple choices

  field_allow_multi: Erlaube mehrere Werte