jro_apps/redmine Commit - r12663:4c7a76785d9f

Fixed that non-empty blank strings as custom field values are not properly validated (#16169)....

Jean-Philippe Lang -

r12663:4c7a76785d9f

parent child

Context file:

r12663:4c7a76785d9f

Collapse all files

app/models/custom_field.rb 0 -2

             # Redmine - project management software
             # Copyright (C) 2006-2014  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class CustomField < ActiveRecord::Base
               include Redmine::SubclassFactory
               has_many :custom_values, :dependent => :delete_all
               has_and_belongs_to_many :roles, :join_table => "#{table_name_prefix}custom_fields_roles#{table_name_suffix}", :foreign_key => "custom_field_id"
               acts_as_list :scope => 'type = \'#{self.class}\''
               serialize :possible_values
               store :format_store
               validates_presence_of :name, :field_format
               validates_uniqueness_of :name, :scope => :type
               validates_length_of :name, :maximum => 30
               validates_inclusion_of :field_format, :in => Proc.new { Redmine::FieldFormat.available_formats }
               validate :validate_custom_field
               before_validation :set_searchable
               before_save do |field|
                 field.format.before_custom_field_save(field)
               end
               after_save :handle_multiplicity_change
               after_save do |field|
                 if field.visible_changed? && field.visible
                   field.roles.clear
                 end
               end
               scope :sorted, lambda { order("#{table_name}.position ASC") }
               scope :visible, lambda {|*args|
                 user = args.shift || User.current
                 if user.admin?
                   # nop
                 elsif user.memberships.any?
                   where("#{table_name}.visible = ? OR #{table_name}.id IN (SELECT DISTINCT cfr.custom_field_id FROM #{Member.table_name} m" +
                     " INNER JOIN #{MemberRole.table_name} mr ON mr.member_id = m.id" +
                     " INNER JOIN #{table_name_prefix}custom_fields_roles#{table_name_suffix} cfr ON cfr.role_id = mr.role_id" +
                     " WHERE m.user_id = ?)",
                     true, user.id)
                 else
                   where(:visible => true)
                 end
               }
               def visible_by?(project, user=User.current)
                 visible? || user.admin?
               end
               def format
                 @format ||= Redmine::FieldFormat.find(field_format)
               end
               def field_format=(arg)
                 # cannot change format of a saved custom field
                 if new_record?
                   @format = nil
                   super
                 end
               end
               def set_searchable
                 # make sure these fields are not searchable
                 self.searchable = false unless format.class.searchable_supported
                 # make sure only these fields can have multiple values
                 self.multiple = false unless format.class.multiple_supported
                 true
               end
               def validate_custom_field
                 format.validate_custom_field(self).each do |attribute, message|
                   errors.add attribute, message
                 end
                 if regexp.present?
                   begin
                     Regexp.new(regexp)
                   rescue
                     errors.add(:regexp, :invalid)
                   end
                 end
                 if default_value.present?
                   validate_field_value(default_value).each do |message|
                     errors.add :default_value, message
                   end
                 end
               end
               def possible_custom_value_options(custom_value)
                 format.possible_custom_value_options(custom_value)
               end
               def possible_values_options(object=nil)
                 if object.is_a?(Array)
                   object.map {|o| format.possible_values_options(self, o)}.reduce(:&) || []
                 else
                   format.possible_values_options(self, object) || []
                 end
               end
               def possible_values
                 values = super()
                 if values.is_a?(Array)
                   values.each do |value|
                     value.force_encoding('UTF-8') if value.respond_to?(:force_encoding)
                   end
                   values
                 else
                   []
                 end
               end
               # Makes possible_values accept a multiline string
               def possible_values=(arg)
                 if arg.is_a?(Array)
                   super(arg.compact.collect(&:strip).select {|v| !v.blank?})
                 else
                   self.possible_values = arg.to_s.split(/[\n\r]+/)
                 end
               end
               def cast_value(value)
                 format.cast_value(self, value)
               end
               def value_from_keyword(keyword, customized)
                 possible_values_options = possible_values_options(customized)
                 if possible_values_options.present?
                   keyword = keyword.to_s.downcase
                   if v = possible_values_options.detect {|text, id| text.downcase == keyword}
                     if v.is_a?(Array)
                       v.last
                     else
                       v
                     end
                   end
                 else
                   keyword
                 end
               end
               # Returns a ORDER BY clause that can used to sort customized
               # objects by their value of the custom field.
               # Returns nil if the custom field can not be used for sorting.
               def order_statement
                 return nil if multiple?
                 format.order_statement(self)
               end
               # Returns a GROUP BY clause that can used to group by custom value
               # Returns nil if the custom field can not be used for grouping.
               def group_statement
                 return nil if multiple?
                 format.group_statement(self)
               end
               def join_for_order_statement
                 format.join_for_order_statement(self)
               end
               def visibility_by_project_condition(project_key=nil, user=User.current, id_column=nil)
                 if visible? || user.admin?
                   "1=1"
                 elsif user.anonymous?
                   "1=0"
                 else
                   project_key ||= "#{self.class.customized_class.table_name}.project_id"
                   id_column ||= id
                   "#{project_key} IN (SELECT DISTINCT m.project_id FROM #{Member.table_name} m" +
                     " INNER JOIN #{MemberRole.table_name} mr ON mr.member_id = m.id" +
                     " INNER JOIN #{table_name_prefix}custom_fields_roles#{table_name_suffix} cfr ON cfr.role_id = mr.role_id" +
                     " WHERE m.user_id = #{user.id} AND cfr.custom_field_id = #{id_column})"
                 end
               end
               def self.visibility_condition
                 if user.admin?
                   "1=1"
                 elsif user.anonymous?
                   "#{table_name}.visible"
                 else
                   "#{project_key} IN (SELECT DISTINCT m.project_id FROM #{Member.table_name} m" +
                     " INNER JOIN #{MemberRole.table_name} mr ON mr.member_id = m.id" +
                     " INNER JOIN #{table_name_prefix}custom_fields_roles#{table_name_suffix} cfr ON cfr.role_id = mr.role_id" +
                     " WHERE m.user_id = #{user.id} AND cfr.custom_field_id = #{id})"
                 end
               end
               def <=>(field)
                 position <=> field.position
               end
               # Returns the class that values represent
               def value_class
                 format.target_class if format.respond_to?(:target_class)
               end
               def self.customized_class
                 self.name =~ /^(.+)CustomField$/
                 $1.constantize rescue nil
               end
               # to move in project_custom_field
               def self.for_all
                 where(:is_for_all => true).order('position').all
               end
               def type_name
                 nil
               end
               # Returns the error messages for the given value
               # or an empty array if value is a valid value for the custom field
               def validate_custom_value(custom_value)
                 value = custom_value.value
                 errs = []
                 if value.is_a?(Array)
                   if !multiple?
                     errs << ::I18n.t('activerecord.errors.messages.invalid')
                   end
                   if is_required? && value.detect(&:present?).nil?
                     errs << ::I18n.t('activerecord.errors.messages.blank')
                   end
                 else
                   if is_required? && value.blank?
                     errs << ::I18n.t('activerecord.errors.messages.blank')
                   end
                 end
-                if custom_value.value.present?
                 errs += format.validate_custom_value(custom_value)
-                end
                 errs
               end
               # Returns the error messages for the default custom field value
               def validate_field_value(value)
                 validate_custom_value(CustomValue.new(:custom_field => self, :value => value))
               end
               # Returns true if value is a valid value for the custom field
               def valid_field_value?(value)
                 validate_field_value(value).empty?
               end
               def format_in?(*args)
                 args.include?(field_format)
               end
               protected
               # Removes multiple values for the custom field after setting the multiple attribute to false
               # We kepp the value with the highest id for each customized object
               def handle_multiplicity_change
                 if !new_record? && multiple_was && !multiple
                   ids = custom_values.
                     where("EXISTS(SELECT 1 FROM #{CustomValue.table_name} cve WHERE cve.custom_field_id = #{CustomValue.table_name}.custom_field_id" +
                       " AND cve.customized_type = #{CustomValue.table_name}.customized_type AND cve.customized_id = #{CustomValue.table_name}.customized_id" +
                       " AND cve.id > #{CustomValue.table_name}.id)").
                     pluck(:id)
                   if ids.any?
                     custom_values.where(:id => ids).delete_all
                   end
                 end
               end
             end
             require_dependency 'redmine/field_format'

lib/redmine/field_format.rb +6 -5

             # Redmine - project management software
             # Copyright (C) 2006-2014  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             module Redmine
               module FieldFormat
                 def self.add(name, klass)
                   all[name.to_s] = klass.instance
                 end
                 def self.delete(name)
                   all.delete(name.to_s)
                 end
                 def self.all
                   @formats ||= Hash.new(Base.instance)
                 end
                 def self.available_formats
                   all.keys
                 end
                 def self.find(name)
                   all[name.to_s]
                 end
                 # Return an array of custom field formats which can be used in select_tag
                 def self.as_select(class_name=nil)
                   formats = all.values.select do |format|
                     format.class.customized_class_names.nil? || format.class.customized_class_names.include?(class_name)
                   end
                   formats.map {|format| [::I18n.t(format.label), format.name] }.sort_by(&:first)
                 end
                 class Base
                   include Singleton
                   include Redmine::I18n
                   include ERB::Util
                   class_attribute :format_name
                   self.format_name = nil
                   # Set this to true if the format supports multiple values
                   class_attribute :multiple_supported
                   self.multiple_supported = false
                   # Set this to true if the format supports textual search on custom values
                   class_attribute :searchable_supported
                   self.searchable_supported = false
                   # Restricts the classes that the custom field can be added to
                   # Set to nil for no restrictions
                   class_attribute :customized_class_names
                   self.customized_class_names = nil
                   # Name of the partial for editing the custom field
                   class_attribute :form_partial
                   self.form_partial = nil
                   def self.add(name)
                     self.format_name = name
                     Redmine::FieldFormat.add(name, self)
                   end
                   private_class_method :add
                   def self.field_attributes(*args)
                     CustomField.store_accessor :format_store, *args
                   end
                   field_attributes :url_pattern
                   def name
                     self.class.format_name
                   end
                   def label
                     "label_#{name}"
                   end
                   def cast_custom_value(custom_value)
                     cast_value(custom_value.custom_field, custom_value.value, custom_value.customized)
                   end
                   def cast_value(custom_field, value, customized=nil)
                     if value.blank?
                       nil
                     elsif value.is_a?(Array)
                       value.map do |v|
                         cast_single_value(custom_field, v, customized)
                       end.sort
                     else
                       cast_single_value(custom_field, value, customized)
                     end
                   end
                   def cast_single_value(custom_field, value, customized=nil)
                     value.to_s
                   end
                   def target_class
                     nil
                   end
                   def possible_custom_value_options(custom_value)
                     possible_values_options(custom_value.custom_field, custom_value.customized)
                   end
                   def possible_values_options(custom_field, object=nil)
                     []
                   end
                   # Returns the validation errors for custom_field
                   # Should return an empty array if custom_field is valid
                   def validate_custom_field(custom_field)
                     []
                   end
                   # Returns the validation error messages for custom_value
                   # Should return an empty array if custom_value is valid
                   def validate_custom_value(custom_value)
-                    errors = Array.wrap(custom_value.value).reject(&:blank?).map do |value|
+                    values = Array.wrap(custom_value.value).reject {|value| value.to_s == ''}
+                    errors = values.map do |value|
                       validate_single_value(custom_value.custom_field, value, custom_value.customized)
                     end
                     errors.flatten.uniq
                   end
                   def validate_single_value(custom_field, value, customized=nil)
                     []
                   end
                   def formatted_custom_value(view, custom_value, html=false)
                     formatted_value(view, custom_value.custom_field, custom_value.value, custom_value.customized, html)
                   end
                   def formatted_value(view, custom_field, value, customized=nil, html=false)
                     casted = cast_value(custom_field, value, customized)
                     if custom_field.url_pattern.present?
                       texts_and_urls = Array.wrap(casted).map do |single_value|
                         text = view.format_object(single_value, false).to_s
                         url = url_from_pattern(custom_field, single_value, customized)
                         [text, url]
                       end
                       links = texts_and_urls.sort_by(&:first).map {|text, url| view.link_to text, url}
                       links.join(', ').html_safe
                     else
                       casted
                     end
                   end
                   # Returns an URL generated with the custom field URL pattern
                   # and variables substitution:
                   # %value% => the custom field value
                   # %id% => id of the customized object
                   # %project_id% => id of the project of the customized object if defined
                   # %project_identifier% => identifier of the project of the customized object if defined
                   # %m1%, %m2%... => capture groups matches of the custom field regexp if defined
                   def url_from_pattern(custom_field, value, customized)
                     url = custom_field.url_pattern.to_s.dup
                     url.gsub!('%value%') {value.to_s}
                     url.gsub!('%id%') {customized.id.to_s}
                     url.gsub!('%project_id%') {(customized.respond_to?(:project) ? customized.project.try(:id) : nil).to_s}
                     url.gsub!('%project_identifier%') {(customized.respond_to?(:project) ? customized.project.try(:identifier) : nil).to_s}
                     if custom_field.regexp.present?
                       url.gsub!(%r{%m(\d+)%}) do
                         m = $1.to_i
                         if matches ||= value.to_s.match(Regexp.new(custom_field.regexp))
                           matches[m].to_s
                         end
                       end
                     end
                     url
                   end
                   protected :url_from_pattern
                   def edit_tag(view, tag_id, tag_name, custom_value, options={})
                     view.text_field_tag(tag_name, custom_value.value, options.merge(:id => tag_id))
                   end
                   def bulk_edit_tag(view, tag_id, tag_name, custom_field, objects, value, options={})
                     view.text_field_tag(tag_name, value, options.merge(:id => tag_id)) +
                       bulk_clear_tag(view, tag_id, tag_name, custom_field, value)
                   end
                   def bulk_clear_tag(view, tag_id, tag_name, custom_field, value)
                     if custom_field.is_required?
                       ''.html_safe
                     else
                       view.content_tag('label',
                         view.check_box_tag(tag_name, '__none__', (value == '__none__'), :id => nil, :data => {:disables => "##{tag_id}"}) + l(:button_clear),
                         :class => 'inline'
                       )
                     end
                   end
                   protected :bulk_clear_tag
                   def query_filter_options(custom_field, query)
                     {:type => :string}
                   end
                   def before_custom_field_save(custom_field)
                   end
                   # Returns a ORDER BY clause that can used to sort customized
                   # objects by their value of the custom field.
                   # Returns nil if the custom field can not be used for sorting.
                   def order_statement(custom_field)
                     # COALESCE is here to make sure that blank and NULL values are sorted equally
                     "COALESCE(#{join_alias custom_field}.value, '')"
                   end
                   # Returns a GROUP BY clause that can used to group by custom value
                   # Returns nil if the custom field can not be used for grouping.
                   def group_statement(custom_field)
                     nil
                   end
                   # Returns a JOIN clause that is added to the query when sorting by custom values
                   def join_for_order_statement(custom_field)
                     alias_name = join_alias(custom_field)
                     "LEFT OUTER JOIN #{CustomValue.table_name} #{alias_name}" +
                       " ON #{alias_name}.customized_type = '#{custom_field.class.customized_class.base_class.name}'" +
                       " AND #{alias_name}.customized_id = #{custom_field.class.customized_class.table_name}.id" +
                       " AND #{alias_name}.custom_field_id = #{custom_field.id}" +
                       " AND (#{custom_field.visibility_by_project_condition})" +
                       " AND #{alias_name}.value <> ''" +
                       " AND #{alias_name}.id = (SELECT max(#{alias_name}_2.id) FROM #{CustomValue.table_name} #{alias_name}_2" +
                         " WHERE #{alias_name}_2.customized_type = #{alias_name}.customized_type" +
                         " AND #{alias_name}_2.customized_id = #{alias_name}.customized_id" +
                         " AND #{alias_name}_2.custom_field_id = #{alias_name}.custom_field_id)"
                   end
                   def join_alias(custom_field)
                     "cf_#{custom_field.id}"
                   end
                   protected :join_alias
                 end
                 class Unbounded < Base
                   def validate_single_value(custom_field, value, customized=nil)
                     errs = super
-                    if value.present?
+                    value = value.to_s
                     unless custom_field.regexp.blank? or value =~ Regexp.new(custom_field.regexp)
                       errs << ::I18n.t('activerecord.errors.messages.invalid')
                     end
                     if custom_field.min_length && value.length < custom_field.min_length
                       errs << ::I18n.t('activerecord.errors.messages.too_short', :count => custom_field.min_length)
                     end
                     if custom_field.max_length && custom_field.max_length > 0 && value.length > custom_field.max_length
                       errs << ::I18n.t('activerecord.errors.messages.too_long', :count => custom_field.max_length)
                     end
-                    end
                     errs
                   end
                 end
                 class StringFormat < Unbounded
                   add 'string'
                   self.searchable_supported = true
                   self.form_partial = 'custom_fields/formats/string'
                   field_attributes :text_formatting
                   def formatted_value(view, custom_field, value, customized=nil, html=false)
                     if html
                       if custom_field.url_pattern.present?
                         super
                       elsif custom_field.text_formatting == 'full'
                         view.textilizable(value, :object => customized)
                       else
                         value.to_s
                       end
                     else
                       value.to_s
                     end
                   end
                 end
                 class TextFormat < Unbounded
                   add 'text'
                   self.searchable_supported = true
                   self.form_partial = 'custom_fields/formats/text'
                   def formatted_value(view, custom_field, value, customized=nil, html=false)
                     if html
                       if custom_field.text_formatting == 'full'
                         view.textilizable(value, :object => customized)
                       else
                         view.simple_format(html_escape(value))
                       end
                     else
                       value.to_s
                     end
                   end
                   def edit_tag(view, tag_id, tag_name, custom_value, options={})
                     view.text_area_tag(tag_name, custom_value.value, options.merge(:id => tag_id, :rows => 3))
                   end
                   def bulk_edit_tag(view, tag_id, tag_name, custom_field, objects, value, options={})
                     view.text_area_tag(tag_name, value, options.merge(:id => tag_id, :rows => 3)) +
                       '<br />'.html_safe +
                       bulk_clear_tag(view, tag_id, tag_name, custom_field, value)
                   end
                   def query_filter_options(custom_field, query)
                     {:type => :text}
                   end
                 end
                 class LinkFormat < StringFormat
                   add 'link'
                   self.searchable_supported = false
                   self.form_partial = 'custom_fields/formats/link'
                   def formatted_value(view, custom_field, value, customized=nil, html=false)
                     if html
                       if custom_field.url_pattern.present?
                         url = url_from_pattern(custom_field, value, customized)
                       else
                         url = value.to_s
                         unless url =~ %r{\A[a-z]+://}i
                           # no protocol found, use http by default
                           url = "http://" + url
                         end
                       end
                       view.link_to value.to_s, url
                     else
                       value.to_s
                     end
                   end
                 end
                 class Numeric < Unbounded
                   self.form_partial = 'custom_fields/formats/numeric'
                   def order_statement(custom_field)
                     # Make the database cast values into numeric
                     # Postgresql will raise an error if a value can not be casted!
                     # CustomValue validations should ensure that it doesn't occur
                     "CAST(CASE #{join_alias custom_field}.value WHEN '' THEN '0' ELSE #{join_alias custom_field}.value END AS decimal(30,3))"
                   end
                 end
                 class IntFormat < Numeric
                   add 'int'
                   def label
                     "label_integer"
                   end
                   def cast_single_value(custom_field, value, customized=nil)
                     value.to_i
                   end
                   def validate_single_value(custom_field, value, customized=nil)
                     errs = super
                     errs << ::I18n.t('activerecord.errors.messages.not_a_number') unless value =~ /^[+-]?\d+$/
                     errs
                   end
                   def query_filter_options(custom_field, query)
                     {:type => :integer}
                   end
                   def group_statement(custom_field)
                     order_statement(custom_field)
                   end
                 end
                 class FloatFormat < Numeric
                   add 'float'
                   def cast_single_value(custom_field, value, customized=nil)
                     value.to_f
                   end
                   def validate_single_value(custom_field, value, customized=nil)
                     errs = super
                     errs << ::I18n.t('activerecord.errors.messages.invalid') unless (Kernel.Float(value) rescue nil)
                     errs
                   end
                   def query_filter_options(custom_field, query)
                     {:type => :float}
                   end
                 end
                 class DateFormat < Unbounded
                   add 'date'
                   self.form_partial = 'custom_fields/formats/date'
                   def cast_single_value(custom_field, value, customized=nil)
                     value.to_date rescue nil
                   end
                   def validate_single_value(custom_field, value, customized=nil)
                     if value =~ /^\d{4}-\d{2}-\d{2}$/ && (value.to_date rescue false)
                       []
                     else
                       [::I18n.t('activerecord.errors.messages.not_a_date')]
                     end
                   end
                   def edit_tag(view, tag_id, tag_name, custom_value, options={})
                     view.text_field_tag(tag_name, custom_value.value, options.merge(:id => tag_id, :size => 10)) +
                       view.calendar_for(tag_id)
                   end
                   def bulk_edit_tag(view, tag_id, tag_name, custom_field, objects, value, options={})
                     view.text_field_tag(tag_name, value, options.merge(:id => tag_id, :size => 10)) +
                       view.calendar_for(tag_id) +
                       bulk_clear_tag(view, tag_id, tag_name, custom_field, value)
                   end
                   def query_filter_options(custom_field, query)
                     {:type => :date}
                   end
                   def group_statement(custom_field)
                     order_statement(custom_field)
                   end
                 end
                 class List < Base
                   self.multiple_supported = true
                   field_attributes :edit_tag_style
                   def edit_tag(view, tag_id, tag_name, custom_value, options={})
                     if custom_value.custom_field.edit_tag_style == 'check_box'
                       check_box_edit_tag(view, tag_id, tag_name, custom_value, options)
                     else
                       select_edit_tag(view, tag_id, tag_name, custom_value, options)
                     end
                   end
                   def bulk_edit_tag(view, tag_id, tag_name, custom_field, objects, value, options={})
                     opts = []
                     opts << [l(:label_no_change_option), ''] unless custom_field.multiple?
                     opts << [l(:label_none), '__none__'] unless custom_field.is_required?
                     opts += possible_values_options(custom_field, objects)
                     view.select_tag(tag_name, view.options_for_select(opts, value), options.merge(:multiple => custom_field.multiple?))
                   end
                   def query_filter_options(custom_field, query)
                     {:type => :list_optional, :values => possible_values_options(custom_field, query.project)}
                   end
                   protected
                   # Renders the edit tag as a select tag
                   def select_edit_tag(view, tag_id, tag_name, custom_value, options={})
                     blank_option = ''.html_safe
                     unless custom_value.custom_field.multiple?
                       if custom_value.custom_field.is_required?
                         unless custom_value.custom_field.default_value.present?
                           blank_option = view.content_tag('option', "--- #{l(:actionview_instancetag_blank_option)} ---", :value => '')
                         end
                       else
                         blank_option = view.content_tag('option', '&nbsp;'.html_safe, :value => '')
                       end
                     end
                     options_tags = blank_option + view.options_for_select(possible_custom_value_options(custom_value), custom_value.value)
                     s = view.select_tag(tag_name, options_tags, options.merge(:id => tag_id, :multiple => custom_value.custom_field.multiple?))
                     if custom_value.custom_field.multiple?
                       s << view.hidden_field_tag(tag_name, '')
                     end
                     s
                   end
                   # Renders the edit tag as check box or radio tags
                   def check_box_edit_tag(view, tag_id, tag_name, custom_value, options={})
                     opts = []
                     unless custom_value.custom_field.multiple? || custom_value.custom_field.is_required?
                       opts << ["(#{l(:label_none)})", '']
                     end
                     opts += possible_custom_value_options(custom_value)
                     s = ''.html_safe
                     tag_method = custom_value.custom_field.multiple? ? :check_box_tag : :radio_button_tag
                     opts.each do |label, value|
                       value ||= label
                       checked = (custom_value.value.is_a?(Array) && custom_value.value.include?(value)) || custom_value.value.to_s == value
                       tag = view.send(tag_method, tag_name, value, checked, :id => tag_id)
                       # set the id on the first tag only
                       tag_id = nil
                       s << view.content_tag('label', tag + ' ' + label)
                     end
                     css = "#{options[:class]} check_box_group"
                     view.content_tag('span', s, options.merge(:class => css))
                   end
                 end
                 class ListFormat < List
                   add 'list'
                   self.searchable_supported = true
                   self.form_partial = 'custom_fields/formats/list'
                   def possible_custom_value_options(custom_value)
                     options = possible_values_options(custom_value.custom_field)
                     missing = [custom_value.value].flatten.reject(&:blank?) - options
                     if missing.any?
                       options += missing
                     end
                     options
                   end
                   def possible_values_options(custom_field, object=nil)
                     custom_field.possible_values
                   end
                   def validate_custom_field(custom_field)
                     errors = []
                     errors << [:possible_values, :blank] if custom_field.possible_values.blank?
                     errors << [:possible_values, :invalid] unless custom_field.possible_values.is_a? Array
                     errors
                   end
                   def validate_custom_value(custom_value)
-                    invalid_values = Array.wrap(custom_value.value) - Array.wrap(custom_value.value_was) - custom_value.custom_field.possible_values
+                    values = Array.wrap(custom_value.value).reject {|value| value.to_s == ''}
-                    if invalid_values.select(&:present?).any?
+                    invalid_values = values - Array.wrap(custom_value.value_was) - custom_value.custom_field.possible_values
+                    if invalid_values.any?
                       [::I18n.t('activerecord.errors.messages.inclusion')]
                     else
                       []
                     end
                   end
                   def group_statement(custom_field)
                     order_statement(custom_field)
                   end
                 end
                 class BoolFormat < List
                   add 'bool'
                   self.multiple_supported = false
                   self.form_partial = 'custom_fields/formats/bool'
                   def label
                     "label_boolean"
                   end
                   def cast_single_value(custom_field, value, customized=nil)
                     value == '1' ? true : false
                   end
                   def possible_values_options(custom_field, object=nil)
                     [[::I18n.t(:general_text_Yes), '1'], [::I18n.t(:general_text_No), '0']]
                   end
                   def group_statement(custom_field)
                     order_statement(custom_field)
                   end
                 end
                 class RecordList < List
                   self.customized_class_names = %w(Issue TimeEntry Version Project)
                   def cast_single_value(custom_field, value, customized=nil)
                     target_class.find_by_id(value.to_i) if value.present?
                   end
                   def target_class
                     @target_class ||= self.class.name[/^(.*::)?(.+)Format$/, 2].constantize rescue nil
                   end
                   def possible_custom_value_options(custom_value)
                     options = possible_values_options(custom_value.custom_field, custom_value.customized)
                     missing = [custom_value.value_was].flatten.reject(&:blank?) - options.map(&:last)
                     if missing.any?
                       options += target_class.where(:id => missing.map(&:to_i)).map {|o| [o.to_s, o.id.to_s]}
                       #TODO: use #sort_by! when ruby1.8 support is dropped
                       options = options.sort_by(&:first)
                     end
                     options
                   end
                   def order_statement(custom_field)
                     if target_class.respond_to?(:fields_for_order_statement)
                       target_class.fields_for_order_statement(value_join_alias(custom_field))
                     end
                   end
                   def group_statement(custom_field)
                     "COALESCE(#{join_alias custom_field}.value, '')"
                   end
                   def join_for_order_statement(custom_field)
                     alias_name = join_alias(custom_field)
                     "LEFT OUTER JOIN #{CustomValue.table_name} #{alias_name}" +
                       " ON #{alias_name}.customized_type = '#{custom_field.class.customized_class.base_class.name}'" +
                       " AND #{alias_name}.customized_id = #{custom_field.class.customized_class.table_name}.id" +
                       " AND #{alias_name}.custom_field_id = #{custom_field.id}" +
                       " AND (#{custom_field.visibility_by_project_condition})" +
                       " AND #{alias_name}.value <> ''" +
                       " AND #{alias_name}.id = (SELECT max(#{alias_name}_2.id) FROM #{CustomValue.table_name} #{alias_name}_2" +
                         " WHERE #{alias_name}_2.customized_type = #{alias_name}.customized_type" +
                         " AND #{alias_name}_2.customized_id = #{alias_name}.customized_id" +
                         " AND #{alias_name}_2.custom_field_id = #{alias_name}.custom_field_id)" +
                       " LEFT OUTER JOIN #{target_class.table_name} #{value_join_alias custom_field}" +
                       " ON CAST(CASE #{alias_name}.value WHEN '' THEN '0' ELSE #{alias_name}.value END AS decimal(30,0)) = #{value_join_alias custom_field}.id"
                   end
                   def value_join_alias(custom_field)
                     join_alias(custom_field) + "_" + custom_field.field_format
                   end
                   protected :value_join_alias
                 end
                 class UserFormat < RecordList
                   add 'user'
                   self.form_partial = 'custom_fields/formats/user'
                   field_attributes :user_role
                   def possible_values_options(custom_field, object=nil)
                     if object.is_a?(Array)
                       projects = object.map {|o| o.respond_to?(:project) ? o.project : nil}.compact.uniq
                       projects.map {|project| possible_values_options(custom_field, project)}.reduce(:&) || []
                     elsif object.respond_to?(:project) && object.project
                       scope = object.project.users
                       if custom_field.user_role.is_a?(Array)
                         role_ids = custom_field.user_role.map(&:to_s).reject(&:blank?).map(&:to_i)
                         if role_ids.any?
                           scope = scope.where("#{Member.table_name}.id IN (SELECT DISTINCT member_id FROM #{MemberRole.table_name} WHERE role_id IN (?))", role_ids)
                         end
                       end
                       scope.sorted.collect {|u| [u.to_s, u.id.to_s]}
                     else
                       []
                     end
                   end
                   def before_custom_field_save(custom_field)
                     super
                     if custom_field.user_role.is_a?(Array)
                       custom_field.user_role.map!(&:to_s).reject!(&:blank?)
                     end
                   end
                 end
                 class VersionFormat < RecordList
                   add 'version'
                   self.form_partial = 'custom_fields/formats/version'
                   field_attributes :version_status
                   def possible_values_options(custom_field, object=nil)
                     if object.is_a?(Array)
                       projects = object.map {|o| o.respond_to?(:project) ? o.project : nil}.compact.uniq
                       projects.map {|project| possible_values_options(custom_field, project)}.reduce(:&) || []
                     elsif object.respond_to?(:project) && object.project
                       scope = object.project.shared_versions
                       if custom_field.version_status.is_a?(Array)
                         statuses = custom_field.version_status.map(&:to_s).reject(&:blank?)
                         if statuses.any?
                           scope = scope.where(:status => statuses.map(&:to_s))
                         end
                       end
                       scope.sort.collect {|u| [u.to_s, u.id.to_s]}
                     else
                       []
                     end
                   end
                   def before_custom_field_save(custom_field)
                     super
                     if custom_field.version_status.is_a?(Array)
                       custom_field.version_status.map!(&:to_s).reject!(&:blank?)
                     end
                   end
                 end
               end
             end

test/unit/custom_field_test.rb +8 0

             # Redmine - project management software
             # Copyright (C) 2006-2014  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../test_helper', __FILE__)
             class CustomFieldTest < ActiveSupport::TestCase
               fixtures :custom_fields
               def test_create
                 field = UserCustomField.new(:name => 'Money money money', :field_format => 'float')
                 assert field.save
               end
               def test_before_validation
                 field = CustomField.new(:name => 'test_before_validation', :field_format => 'int')
                 field.searchable = true
                 assert field.save
                 assert_equal false, field.searchable
                 field.searchable = true
                 assert field.save
                 assert_equal false, field.searchable
               end
               def test_regexp_validation
                 field = IssueCustomField.new(:name => 'regexp', :field_format => 'text', :regexp => '[a-z0-9')
                 assert !field.save
                 assert_include I18n.t('activerecord.errors.messages.invalid'),
                                field.errors[:regexp]
                 field.regexp = '[a-z0-9]'
                 assert field.save
               end
               def test_default_value_should_be_validated
                 field = CustomField.new(:name => 'Test', :field_format => 'int')
                 field.default_value = 'abc'
                 assert !field.valid?
                 field.default_value = '6'
                 assert field.valid?
               end
               def test_default_value_should_not_be_validated_when_blank
                 field = CustomField.new(:name => 'Test', :field_format => 'list', :possible_values => ['a', 'b'], :is_required => true, :default_value => '')
                 assert field.valid?
               end
               def test_field_format_should_be_validated
                 field = CustomField.new(:name => 'Test', :field_format => 'foo')
                 assert !field.valid?
               end
               def test_field_format_validation_should_accept_formats_added_at_runtime
                 Redmine::FieldFormat.add 'foobar', Class.new(Redmine::FieldFormat::Base)
                 field = CustomField.new(:name => 'Some Custom Field', :field_format => 'foobar')
                 assert field.valid?, 'field should be valid'
               ensure
                 Redmine::FieldFormat.delete 'foobar'
               end
               def test_should_not_change_field_format_of_existing_custom_field
                 field = CustomField.find(1)
                 field.field_format = 'int'
                 assert_equal 'list', field.field_format
               end
               def test_possible_values_should_accept_an_array
                 field = CustomField.new
                 field.possible_values = ["One value", ""]
                 assert_equal ["One value"], field.possible_values
               end
               def test_possible_values_should_accept_a_string
                 field = CustomField.new
                 field.possible_values = "One value"
                 assert_equal ["One value"], field.possible_values
               end
               def test_possible_values_should_accept_a_multiline_string
                 field = CustomField.new
                 field.possible_values = "One value\nAnd another one  \r\n \n"
                 assert_equal ["One value", "And another one"], field.possible_values
               end
               if "string".respond_to?(:encoding)
                 def test_possible_values_stored_as_binary_should_be_utf8_encoded
                   field = CustomField.find(11)
                   assert_kind_of Array, field.possible_values
                   assert field.possible_values.size > 0
                   field.possible_values.each do |value|
                     assert_equal "UTF-8", value.encoding.name
                   end
                 end
               end
               def test_destroy
                 field = CustomField.find(1)
                 assert field.destroy
               end
               def test_new_subclass_instance_should_return_an_instance
                 f = CustomField.new_subclass_instance('IssueCustomField')
                 assert_kind_of IssueCustomField, f
               end
               def test_new_subclass_instance_should_set_attributes
                 f = CustomField.new_subclass_instance('IssueCustomField', :name => 'Test')
                 assert_kind_of IssueCustomField, f
                 assert_equal 'Test', f.name
               end
               def test_new_subclass_instance_with_invalid_class_name_should_return_nil
                 assert_nil CustomField.new_subclass_instance('WrongClassName')
               end
               def test_new_subclass_instance_with_non_subclass_name_should_return_nil
                 assert_nil CustomField.new_subclass_instance('Project')
               end
               def test_string_field_validation_with_blank_value
                 f = CustomField.new(:field_format => 'string')
                 assert f.valid_field_value?(nil)
                 assert f.valid_field_value?('')
                 f.is_required = true
                 assert !f.valid_field_value?(nil)
                 assert !f.valid_field_value?('')
               end
               def test_string_field_validation_with_min_and_max_lengths
                 f = CustomField.new(:field_format => 'string', :min_length => 2, :max_length => 5)
                 assert f.valid_field_value?(nil)
                 assert f.valid_field_value?('')
+                assert !f.valid_field_value?(' ')
                 assert f.valid_field_value?('a' * 2)
                 assert !f.valid_field_value?('a')
                 assert !f.valid_field_value?('a' * 6)
               end
               def test_string_field_validation_with_regexp
                 f = CustomField.new(:field_format => 'string', :regexp => '^[A-Z0-9]*$')
                 assert f.valid_field_value?(nil)
                 assert f.valid_field_value?('')
+                assert !f.valid_field_value?(' ')
                 assert f.valid_field_value?('ABC')
                 assert !f.valid_field_value?('abc')
               end
               def test_date_field_validation
                 f = CustomField.new(:field_format => 'date')
                 assert f.valid_field_value?(nil)
                 assert f.valid_field_value?('')
+                assert !f.valid_field_value?(' ')
                 assert f.valid_field_value?('1975-07-14')
                 assert !f.valid_field_value?('1975-07-33')
                 assert !f.valid_field_value?('abc')
               end
               def test_list_field_validation
                 f = CustomField.new(:field_format => 'list', :possible_values => ['value1', 'value2'])
                 assert f.valid_field_value?(nil)
                 assert f.valid_field_value?('')
+                assert !f.valid_field_value?(' ')
                 assert f.valid_field_value?('value2')
                 assert !f.valid_field_value?('abc')
               end
               def test_int_field_validation
                 f = CustomField.new(:field_format => 'int')
                 assert f.valid_field_value?(nil)
                 assert f.valid_field_value?('')
+                assert !f.valid_field_value?(' ')
                 assert f.valid_field_value?('123')
                 assert f.valid_field_value?('+123')
                 assert f.valid_field_value?('-123')
                 assert !f.valid_field_value?('6abc')
               end
               def test_float_field_validation
                 f = CustomField.new(:field_format => 'float')
                 assert f.valid_field_value?(nil)
                 assert f.valid_field_value?('')
+                assert !f.valid_field_value?(' ')
                 assert f.valid_field_value?('11.2')
                 assert f.valid_field_value?('-6.250')
                 assert f.valid_field_value?('5')
                 assert !f.valid_field_value?('6abc')
               end
               def test_multi_field_validation
                 f = CustomField.new(:field_format => 'list', :multiple => 'true', :possible_values => ['value1', 'value2'])
                 assert f.valid_field_value?(nil)
                 assert f.valid_field_value?('')
+                assert !f.valid_field_value?(' ')
                 assert f.valid_field_value?([])
                 assert f.valid_field_value?([nil])
                 assert f.valid_field_value?([''])
+                assert !f.valid_field_value?([' '])
                 assert f.valid_field_value?('value2')
                 assert !f.valid_field_value?('abc')
                 assert f.valid_field_value?(['value2'])
                 assert !f.valid_field_value?(['abc'])
                 assert f.valid_field_value?(['', 'value2'])
                 assert !f.valid_field_value?(['', 'abc'])
                 assert f.valid_field_value?(['value1', 'value2'])
                 assert !f.valid_field_value?(['value1', 'abc'])
               end
               def test_changing_multiple_to_false_should_delete_multiple_values
                 field = ProjectCustomField.create!(:name => 'field', :field_format => 'list', :multiple => 'true', :possible_values => ['field1', 'field2'])
                 other = ProjectCustomField.create!(:name => 'other', :field_format => 'list', :multiple => 'true', :possible_values => ['other1', 'other2'])
                 item_with_multiple_values = Project.generate!(:custom_field_values => {field.id => ['field1', 'field2'], other.id => ['other1', 'other2']})
                 item_with_single_values = Project.generate!(:custom_field_values => {field.id => ['field1'], other.id => ['other2']})
                 assert_difference 'CustomValue.count', -1 do
                   field.multiple = false
                   field.save!
                 end
                 item_with_multiple_values = Project.find(item_with_multiple_values.id)
                 assert_kind_of String, item_with_multiple_values.custom_field_value(field)
                 assert_kind_of Array, item_with_multiple_values.custom_field_value(other)
                 assert_equal 2, item_with_multiple_values.custom_field_value(other).size
               end
               def test_value_class_should_return_the_class_used_for_fields_values
                 assert_equal User, CustomField.new(:field_format => 'user').value_class
                 assert_equal Version, CustomField.new(:field_format => 'version').value_class
               end
               def test_value_class_should_return_nil_for_other_fields
                 assert_nil CustomField.new(:field_format => 'text').value_class
                 assert_nil CustomField.new.value_class
               end
               def test_value_from_keyword_for_list_custom_field
                 field = CustomField.find(1)
                 assert_equal 'PostgreSQL', field.value_from_keyword('postgresql', Issue.find(1))
               end
               def test_visibile_scope_with_admin_should_return_all_custom_fields
                 CustomField.delete_all
                 fields = [
                   CustomField.generate!(:visible => true),
                   CustomField.generate!(:visible => false),
                   CustomField.generate!(:visible => false, :role_ids => [1, 3]),
                   CustomField.generate!(:visible => false, :role_ids => [1, 2]),
                 ]
                 assert_equal 4, CustomField.visible(User.find(1)).count
               end
               def test_visibile_scope_with_non_admin_user_should_return_visible_custom_fields
                 CustomField.delete_all
                 fields = [
                   CustomField.generate!(:visible => true),
                   CustomField.generate!(:visible => false),
                   CustomField.generate!(:visible => false, :role_ids => [1, 3]),
                   CustomField.generate!(:visible => false, :role_ids => [1, 2]),
                 ]
                 user = User.generate!
                 User.add_to_project(user, Project.first, Role.find(3))
                 assert_equal [fields[0], fields[2]], CustomField.visible(user).order("id").to_a
               end
               def test_visibile_scope_with_anonymous_user_should_return_visible_custom_fields
                 CustomField.delete_all
                 fields = [
                   CustomField.generate!(:visible => true),
                   CustomField.generate!(:visible => false),
                   CustomField.generate!(:visible => false, :role_ids => [1, 3]),
                   CustomField.generate!(:visible => false, :role_ids => [1, 2]),
                 ]
                 assert_equal [fields[0]], CustomField.visible(User.anonymous).order("id").to_a
               end
               def test_float_cast_blank_value_should_return_nil
                 field = CustomField.new(:field_format => 'float')
                 assert_equal nil, field.cast_value(nil)
                 assert_equal nil, field.cast_value('')
               end
               def test_float_cast_valid_value_should_return_float
                 field = CustomField.new(:field_format => 'float')
                 assert_equal 12.0, field.cast_value('12')
                 assert_equal 12.5, field.cast_value('12.5')
                 assert_equal 12.5, field.cast_value('+12.5')
                 assert_equal -12.5, field.cast_value('-12.5')
               end
             end

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages