jro_apps/redmine Commit - r1578:ce6cf66f6c3a

Custom fields refactoring: most of code moved from controllers to models (using new module ActsAsCustomizable)....

Jean-Philippe Lang -

r1578:ce6cf66f6c3a

parent child

Context file:

r1578:ce6cf66f6c3a

Expand all files

vendor/plugins/acts_as_customizable/init.rb created 644 +2 0

@@ -0,0 +1,2
	1	require File.dirname(__FILE__) + '/lib/acts_as_customizable'
	2	ActiveRecord::Base.send(:include, Redmine::Acts::Customizable)

vendor/plugins/acts_as_customizable/lib/acts_as_customizable.rb created 644 +82 0

@@ -0,0 +1,82
	1	# redMine - project management software
	2	# Copyright (C) 2006-2008 Jean-Philippe Lang
	3	#
	4	# This program is free software; you can redistribute it and/or
	5	# modify it under the terms of the GNU General Public License
	6	# as published by the Free Software Foundation; either version 2
	7	# of the License, or (at your option) any later version.
	8	#
	9	# This program is distributed in the hope that it will be useful,
	10	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	# GNU General Public License for more details.
	13	#
	14	# You should have received a copy of the GNU General Public License
	15	# along with this program; if not, write to the Free Software
	16	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	17
	18	module Redmine
	19	module Acts
	20	module Customizable
	21	def self.included(base)
	22	base.extend ClassMethods
	23	end
	24
	25	module ClassMethods
	26	def acts_as_customizable(options = {})
	27	return if self.included_modules.include?(Redmine::Acts::Customizable::InstanceMethods)
	28	cattr_accessor :customizable_options
	29	self.customizable_options = options
	30	has_many :custom_values, :dependent => :delete_all, :as => :customized
	31	before_validation_on_create { \|customized\| customized.custom_field_values }
	32	# Trigger validation only if custom values were changed
	33	validates_associated :custom_values, :on => :update, :if => Proc.new { \|customized\| customized.custom_field_values_changed? }
	34	send :include, Redmine::Acts::Customizable::InstanceMethods
	35	# Save custom values when saving the customized object
	36	after_save :save_custom_field_values
	37	end
	38	end
	39
	40	module InstanceMethods
	41	def self.included(base)
	42	base.extend ClassMethods
	43	end
	44
	45	def available_custom_fields
	46	CustomField.find(:all, :conditions => "type = '#{self.class.name}CustomField'",
	47	:order => 'position')
	48	end
	49
	50	def custom_field_values=(values)
	51	@custom_field_values_changed = true
	52	values = values.stringify_keys
	53	custom_field_values.each do \|custom_value\|
	54	custom_value.value = values[custom_value.custom_field_id.to_s] if values.has_key?(custom_value.custom_field_id.to_s)
	55	end if values.is_a?(Hash)
	56	end
	57
	58	def custom_field_values
	59	@custom_field_values \|\|= available_custom_fields.collect { \|x\| custom_values.detect { \|v\| v.custom_field == x } \|\| custom_values.build(:custom_field => x, :value => nil) }
	60	end
	61
	62	def custom_field_values_changed?
	63	@custom_field_values_changed == true
	64	end
	65
	66	def custom_value_for(c)
	67	field_id = (c.is_a?(CustomField) ? c.id : c.to_i)
	68	custom_values.detect {\|v\| v.custom_field_id == field_id }
	69	end
	70
	71	def save_custom_field_values
	72	custom_field_values.each(&:save)
	73	@custom_field_values_changed = false
	74	@custom_field_values = nil
	75	end
	76
	77	module ClassMethods
	78	end
	79	end
	80	end
	81	end
	82	end

app/controllers/account_controller.rb 0 -5

                 redirect_to(home_url) && return unless Setting.self_registration?
                 if request.get?
                   @user = User.new(:language => Setting.default_language)
-                  @custom_values = UserCustomField.find(:all).collect { |x| CustomValue.new(:custom_field => x, :customized => @user) }
                 else
                   @user = User.new(params[:user])
                   @user.admin = false
                   @user.login = params[:user][:login]
                   @user.status = User::STATUS_REGISTERED
                   @user.password, @user.password_confirmation = params[:password], params[:password_confirmation]
-                  @custom_values = UserCustomField.find(:all).collect { |x| CustomValue.new(:custom_field => x,
-                                                                                            :customized => @user,
-                                                                                            :value => (params["custom_fields"] ? params["custom_fields"][x.id.to_s] : nil)) }
-                  @user.custom_values = @custom_values
                   case Setting.self_registration
                   when '1'
                     # Email activation

app/controllers/issues_controller.rb +5 -19

               end
               def show
-                @custom_values = @project.custom_fields_for_issues(@issue.tracker).collect { |x| @issue.custom_values.find_by_custom_field_id(x.id) || CustomValue.new(:custom_field => x, :customized => @issue) }
                 @journals = @issue.journals.find(:all, :include => [:user, :details], :order => "#{Journal.table_name}.created_on ASC")
                 @journals.each_with_index {|j,i| j.indice = i+1}
                 @journals.reverse! if User.current.wants_comments_in_reverse_order?
               # Add a new issue
               # The new issue will be created from an existing one if copy_from parameter is given
               def new
-                @issue = params[:copy_from] ? Issue.new.copy_from(params[:copy_from]) : Issue.new(params[:issue])
+                @issue = Issue.new
+                @issue.copy_from(params[:copy_from]) if params[:copy_from]
                 @issue.project = @project
-                @issue.author = User.current
                 @issue.tracker ||= @project.trackers.find(params[:tracker_id] ? params[:tracker_id] : :first)
                 if @issue.tracker.nil?
                   flash.now[:error] = 'No tracker is associated to this project. Please check the Project settings.'
                   render :nothing => true, :layout => true
                   return
                 end
+                @issue.attributes = params[:issue]
+                @issue.author = User.current
                 default_status = IssueStatus.default
                 unless default_status
                 if request.get? || request.xhr?
                   @issue.start_date ||= Date.today
-                  @custom_values = @issue.custom_values.empty? ?
-                    @project.custom_fields_for_issues(@issue.tracker).collect { |x| CustomValue.new(:custom_field => x, :customized => @issue) } :
-                    @issue.custom_values
                 else
                   requested_status = IssueStatus.find_by_id(params[:issue][:status_id])
                   # Check that the user is allowed to apply the requested status
                   @issue.status = (@allowed_statuses.include? requested_status) ? requested_status : default_status
-                  @custom_values = @project.custom_fields_for_issues(@issue.tracker).collect { |x| CustomValue.new(:custom_field => x,
-                                                                                                                   :customized => @issue,
-                                                                                                                   :value => (params[:custom_fields] ? params[:custom_fields][x.id.to_s] : nil)) }
-                  @issue.custom_values = @custom_values
                   if @issue.save
                     attach_files(@issue, params[:attachments])
                     flash[:notice] = l(:notice_successful_create)
                 @allowed_statuses = @issue.new_statuses_allowed_to(User.current)
                 @activities = Enumeration::get_values('ACTI')
                 @priorities = Enumeration::get_values('IPRI')
-                @custom_values = []
                 @edit_allowed = User.current.allowed_to?(:edit_issues, @project)
                 @notes = params[:notes]
                   @issue.attributes = attrs
                 end
-                if request.get?
+                if request.post?
-                  @custom_values = @project.custom_fields_for_issues(@issue.tracker).collect { |x| @issue.custom_values.find_by_custom_field_id(x.id) || CustomValue.new(:custom_field => x, :customized => @issue) }
-                else
-                  # Update custom fields if user has :edit permission
-                  if @edit_allowed && params[:custom_fields]
-                    @custom_values = @project.custom_fields_for_issues(@issue.tracker).collect { |x| CustomValue.new(:custom_field => x, :customized => @issue, :value => params["custom_fields"][x.id.to_s]) }
-                    @issue.custom_values = @custom_values
-                  end
                   @time_entry = TimeEntry.new(:project => @project, :issue => @issue, :user => User.current, :spent_on => Date.today)
                   @time_entry.attributes = params[:time_entry]
                   attachments = attach_files(@issue, params[:attachments])

app/controllers/projects_controller.rb +2 -12

               # Add a new project
               def add
-                @custom_fields = IssueCustomField.find(:all, :order => "#{CustomField.table_name}.position")
+                @issue_custom_fields = IssueCustomField.find(:all, :order => "#{CustomField.table_name}.position")
                 @trackers = Tracker.all
                 @root_projects = Project.find(:all,
                                               :conditions => "parent_id IS NULL AND status = #{Project::STATUS_ACTIVE}",
                                               :order => 'name')
                 @project = Project.new(params[:project])
                 if request.get?
-                  @custom_values = ProjectCustomField.find(:all, :order => "#{CustomField.table_name}.position").collect { |x| CustomValue.new(:custom_field => x, :customized => @project) }
                   @project.trackers = Tracker.all
                   @project.is_public = Setting.default_projects_public?
                   @project.enabled_module_names = Redmine::AccessControl.available_project_modules
                 else
-                  @project.custom_fields = CustomField.find(params[:custom_field_ids]) if params[:custom_field_ids]
-                  @custom_values = ProjectCustomField.find(:all, :order => "#{CustomField.table_name}.position").collect { |x| CustomValue.new(:custom_field => x, :customized => @project, :value => (params[:custom_fields] ? params["custom_fields"][x.id.to_s] : nil)) }
-                  @project.custom_values = @custom_values
                   @project.enabled_module_names = params[:enabled_modules]
                   if @project.save
                     flash[:notice] = l(:notice_successful_create)
               # Show @project
               def show
-                @custom_values = @project.custom_values.find(:all, :include => :custom_field, :order => "#{CustomField.table_name}.position")
                 @members_by_role = @project.members.find(:all, :include => [:user, :role], :order => 'position').group_by {|m| m.role}
                 @subprojects = @project.children.find(:all, :conditions => Project.visible_by(User.current))
                 @news = @project.news.find(:all, :limit => 5, :include => [ :author, :project ], :order => "#{News.table_name}.created_on DESC")
                 @root_projects = Project.find(:all,
                                               :conditions => ["parent_id IS NULL AND status = #{Project::STATUS_ACTIVE} AND id <> ?", @project.id],
                                               :order => 'name')
-                @custom_fields = IssueCustomField.find(:all)
+                @issue_custom_fields = IssueCustomField.find(:all, :order => "#{CustomField.table_name}.position")
                 @issue_category ||= IssueCategory.new
                 @member ||= @project.members.new
                 @trackers = Tracker.all
-                @custom_values ||= ProjectCustomField.find(:all, :order => "#{CustomField.table_name}.position").collect { |x| @project.custom_values.find_by_custom_field_id(x.id) || CustomValue.new(:custom_field => x) }
                 @repository ||= @project.repository
                 @wiki ||= @project.wiki
               end
               # Edit @project
               def edit
                 if request.post?
-                  if params[:custom_fields]
-                    @custom_values = ProjectCustomField.find(:all, :order => "#{CustomField.table_name}.position").collect { |x| CustomValue.new(:custom_field => x, :customized => @project, :value => params["custom_fields"][x.id.to_s]) }
-                    @project.custom_values = @custom_values
-                  end
                   @project.attributes = params[:project]
                   if @project.save
                     flash[:notice] = l(:notice_successful_update)

app/controllers/timelog_controller.rb +1 -1

                                        }
                 # Add list and boolean custom fields as available criterias
-                @project.all_custom_fields.select {|cf| %w(list bool).include? cf.field_format }.each do |cf|
+                @project.all_issue_custom_fields.select {|cf| %w(list bool).include? cf.field_format }.each do |cf|
                   @available_criterias["cf_#{cf.id}"] = {:sql => "(SELECT c.value FROM custom_values c WHERE c.custom_field_id = #{cf.id} AND c.customized_type = 'Issue' AND c.customized_id = issues.id)",
                                                          :format => cf.field_format,
                                                          :label => cf.name}

app/controllers/users_controller.rb +1 -10

               def add
                 if request.get?
                   @user = User.new(:language => Setting.default_language)
-                  @custom_values = UserCustomField.find(:all, :order => "#{CustomField.table_name}.position").collect { |x| CustomValue.new(:custom_field => x, :customized => @user) }
                 else
                   @user = User.new(params[:user])
                   @user.admin = params[:user][:admin] || false
                   @user.login = params[:user][:login]
                   @user.password, @user.password_confirmation = params[:password], params[:password_confirmation] unless @user.auth_source_id
-                  @custom_values = UserCustomField.find(:all, :order => "#{CustomField.table_name}.position").collect { |x| CustomValue.new(:custom_field => x, :customized => @user, :value => (params[:custom_fields] ? params["custom_fields"][x.id.to_s] : nil)) }
-                  @user.custom_values = @custom_values
                   if @user.save
                     Mailer.deliver_account_information(@user, params[:password]) if params[:send_information]
                     flash[:notice] = l(:notice_successful_create)
               def edit
                 @user = User.find(params[:id])
-                if request.get?
+                if request.post?
-                  @custom_values = UserCustomField.find(:all, :order => "#{CustomField.table_name}.position").collect { |x| @user.custom_values.find_by_custom_field_id(x.id) || CustomValue.new(:custom_field => x) }
-                else
                   @user.admin = params[:user][:admin] if params[:user][:admin]
                   @user.login = params[:user][:login] if params[:user][:login]
                   @user.password, @user.password_confirmation = params[:password], params[:password_confirmation] unless params[:password].nil? or params[:password].empty? or @user.auth_source_id
-                  if params[:custom_fields]
-                    @custom_values = UserCustomField.find(:all, :order => "#{CustomField.table_name}.position").collect { |x| CustomValue.new(:custom_field => x, :customized => @user, :value => params["custom_fields"][x.id.to_s]) }
-                    @user.custom_values = @custom_values
-                  end
                   if @user.update_attributes(params[:user])
                     flash[:notice] = l(:notice_successful_update)
                     # Give a string to redirect_to otherwise it would use status param as the response code

app/helpers/custom_fields_helper.rb +15 -12

               end
               # Return custom field html tag corresponding to its format
-              def custom_field_tag(custom_value)
+              def custom_field_tag(name, custom_value)
                 custom_field = custom_value.custom_field
-                field_name = "custom_fields[#{custom_field.id}]"
+                field_name = "#{name}[custom_field_values][#{custom_field.id}]"
-                field_id = "custom_fields_#{custom_field.id}"
+                field_id = "#{name}_custom_field_values_#{custom_field.id}"
                 case custom_field.field_format
                 when "date"
-                  text_field('custom_value', 'value', :name => field_name, :id => field_id, :size => 10) +
+                  text_field_tag(field_name, custom_value.value, :id => field_id, :size => 10) +
                   calendar_for(field_id)
                 when "text"
-                  text_area 'custom_value', 'value', :name => field_name, :id => field_id, :rows => 3, :style => 'width:99%'
+                  text_area_tag(field_name, custom_value.value, :id => field_id, :rows => 3, :style => 'width:90%')
                 when "bool"
-                  check_box 'custom_value', 'value', :name => field_name, :id => field_id
+                  check_box_tag(field_name, custom_value.value, :id => field_id)
                 when "list"
-                  select 'custom_value', 'value', custom_field.possible_values, { :include_blank => true }, :name => field_name, :id => field_id
+                  blank_option = custom_field.is_required? ?
+                                   (custom_field.default_value.blank? ? "<option value=\"\">--- #{l(:actionview_instancetag_blank_option)} ---</option>" : '') :
+                                   '<option></option>'
+                  select_tag(field_name, blank_option + options_for_select(custom_field.possible_values, custom_value.value), :id => field_id)
                 else
-                  text_field 'custom_value', 'value', :name => field_name, :id => field_id
+                  text_field_tag(field_name, custom_value.value, :id => field_id)
                 end
               end
               # Return custom field label tag
-              def custom_field_label_tag(custom_value)
+              def custom_field_label_tag(name, custom_value)
                 content_tag "label", custom_value.custom_field.name +
             	(custom_value.custom_field.is_required? ? " <span class=\"required\">*</span>" : ""),
-            	:for => "custom_fields_#{custom_value.custom_field.id}",
+            	:for => "#{name}_custom_field_values_#{custom_value.custom_field.id}",
             	:class => (custom_value.errors.empty? ? nil : "error" )
               end
               # Return custom field tag with its label tag
-              def custom_field_tag_with_label(custom_value)
+              def custom_field_tag_with_label(name, custom_value)
-                custom_field_label_tag(custom_value) + custom_field_tag(custom_value)
+                custom_field_label_tag(name, custom_value) + custom_field_tag(name, custom_value)
               end
               # Return a string used to display a custom value

app/helpers/issues_helper.rb +1 -1

                               ]
                   # Export project custom fields if project is given
                   # otherwise export custom fields marked as "For all projects"
-                  custom_fields = project.nil? ? IssueCustomField.for_all : project.all_custom_fields
+                  custom_fields = project.nil? ? IssueCustomField.for_all : project.all_issue_custom_fields
                   custom_fields.each {|f| headers << f.name}
                   # Description in the last column
                   headers << l(:field_description)

app/models/issue.rb +6 -8

               has_many :journals, :as => :journalized, :dependent => :destroy
               has_many :attachments, :as => :container, :dependent => :destroy
               has_many :time_entries, :dependent => :delete_all
-              has_many :custom_values, :dependent => :delete_all, :as => :customized
-              has_many :custom_fields, :through => :custom_values
               has_and_belongs_to_many :changesets, :order => "revision ASC"
               has_many :relations_from, :class_name => 'IssueRelation', :foreign_key => 'issue_from_id', :dependent => :delete_all
               has_many :relations_to, :class_name => 'IssueRelation', :foreign_key => 'issue_to_id', :dependent => :delete_all
+              acts_as_customizable
               acts_as_watchable
               acts_as_searchable :columns => ['subject', "#{table_name}.description"], :include => :project, :with => {:journal => :issue}
               acts_as_event :title => Proc.new {|o| "#{o.tracker.name} ##{o.id}: #{o.subject}"},
               validates_length_of :subject, :maximum => 255
               validates_inclusion_of :done_ratio, :in => 0..100
               validates_numericality_of :estimated_hours, :allow_nil => true
-              validates_associated :custom_values, :on => :update
               def after_initialize
                 if new_record?
                 end
               end
+              # Overrides Redmine::Acts::Customizable::InstanceMethods#available_custom_fields
+              def available_custom_fields
+                (project && tracker) ? project.all_issue_custom_fields.select {|c| tracker.custom_fields.include? c } : []
+              end
               def copy_from(arg)
                 issue = arg.is_a?(Issue) ? arg : Issue.find(arg)
                 self.attributes = issue.attributes.dup
                 end
               end
-              def custom_value_for(custom_field)
-                self.custom_values.each {|v| return v if v.custom_field_id == custom_field.id }
-                return nil
-              end
               def init_journal(user, notes = "")
                 @current_journal ||= Journal.new(:journalized => self, :user => user, :notes => notes)
                 @issue_before_change = self.clone

app/models/project.rb +4 -9

               has_many :members, :include => :user, :conditions => "#{User.table_name}.status=#{User::STATUS_ACTIVE}"
               has_many :users, :through => :members
-              has_many :custom_values, :dependent => :delete_all, :as => :customized
               has_many :enabled_modules, :dependent => :delete_all
               has_and_belongs_to_many :trackers, :order => "#{Tracker.table_name}.position"
               has_many :issues, :dependent => :destroy, :order => "#{Issue.table_name}.created_on DESC", :include => [:status, :tracker]
               has_many :changesets, :through => :repository
               has_one :wiki, :dependent => :destroy
               # Custom field for the project issues
-              has_and_belongs_to_many :custom_fields,
+              has_and_belongs_to_many :issue_custom_fields,
                                       :class_name => 'IssueCustomField',
                                       :order => "#{CustomField.table_name}.position",
                                       :join_table => "#{table_name_prefix}custom_fields_projects#{table_name_suffix}",
               acts_as_tree :order => "name", :counter_cache => true
+              acts_as_customizable
               acts_as_searchable :columns => ['name', 'description'], :project_key => 'id', :permission => nil
               acts_as_event :title => Proc.new {|o| "#{l(:label_project)}: #{o.name}"},
                             :url => Proc.new {|o| {:controller => 'projects', :action => 'show', :id => o.id}}
               validates_presence_of :name, :identifier
               validates_uniqueness_of :name, :identifier
-              validates_associated :custom_values, :on => :update
               validates_associated :repository, :wiki
               validates_length_of :name, :maximum => 30
               validates_length_of :homepage, :maximum => 255
               # Returns an array of all custom fields enabled for project issues
               # (explictly associated custom fields and custom fields enabled for all projects)
-              def custom_fields_for_issues(tracker)
+              def all_issue_custom_fields
-                all_custom_fields.select {|c| tracker.custom_fields.include? c }
+                @all_issue_custom_fields ||= (IssueCustomField.for_all + issue_custom_fields).uniq
-              end
-              def all_custom_fields
-                @all_custom_fields ||= (IssueCustomField.for_all + custom_fields).uniq
               end
               def project

app/models/query.rb +2 -2

                   unless @project.active_children.empty?
                     @available_filters["subproject_id"] = { :type => :list_subprojects, :order => 13, :values => @project.active_children.collect{|s| [s.name, s.id.to_s] } }
                   end
-                  add_custom_fields_filters(@project.all_custom_fields)
+                  add_custom_fields_filters(@project.all_issue_custom_fields)
                 else
                   # global filters for cross project issue list
                   add_custom_fields_filters(IssueCustomField.find(:all, :conditions => {:is_filter => true, :is_for_all => true}))
                 return @available_columns if @available_columns
                 @available_columns = Query.available_columns
                 @available_columns += (project ?
-                                        project.all_custom_fields :
+                                        project.all_issue_custom_fields :
                                         IssueCustomField.find(:all, :conditions => {:is_for_all => true})
                                        ).collect {|cf| QueryCustomFieldColumn.new(cf) }
               end

app/models/user.rb +6 -2

               has_many :memberships, :class_name => 'Member', :include => [ :project, :role ], :conditions => "#{Project.table_name}.status=#{Project::STATUS_ACTIVE}", :order => "#{Project.table_name}.name", :dependent => :delete_all
               has_many :projects, :through => :memberships
-              has_many :custom_values, :dependent => :delete_all, :as => :customized
               has_many :issue_categories, :foreign_key => 'assigned_to_id', :dependent => :nullify
               has_one :preference, :dependent => :destroy, :class_name => 'UserPreference'
               has_one :rss_token, :dependent => :destroy, :class_name => 'Token', :conditions => "action='feeds'"
               belongs_to :auth_source
+              acts_as_customizable
               attr_accessor :password, :password_confirmation
               attr_accessor :last_before_login_on
               # Prevents unauthorized assignments
               validates_length_of :mail, :maximum => 60, :allow_nil => true
               validates_length_of :password, :minimum => 4, :allow_nil => true
               validates_confirmation_of :password, :allow_nil => true
-              validates_associated :custom_values, :on => :update
               def before_create
                 self.mail_notification = false
                 errors.add_to_base 'An anonymous user already exists.' if AnonymousUser.find(:first)
               end
+              def available_custom_fields
+                []
+              end
               # Overrides a few properties
               def logged?; false end
               def admin; false end

app/views/account/register.rhtml +2 -2

             <p><label for="user_language"><%=l(:field_language)%></label>
             <%= select("user", "language", lang_options_for_select) %></p>
-            <% for @custom_value in @custom_values %>
+            <% @user.custom_field_values.each do |value| %>
-            	<p><%= custom_field_tag_with_label @custom_value %></p>
+            	<p><%= custom_field_tag_with_label :user, value %></p>
             <% end %>
             <!--[eoform:user]-->
             </div>

app/views/issues/_form_custom_fields.rhtml +7 -6

@@ -1,11 +1,12
1	<div class="splitcontentleft">	1	<div class="splitcontentleft">
2	<% i = 1 %>	2	<% i = 1 %>
3	<% for @custom_value in values %>	3	<% split_on = @issue.custom_field_values.size / 2 %>
4	<p><%= custom_field_tag_with_label @custom_value %></p>	4	<% @issue.custom_field_values.each do \|value\| %>
5	<% if i == values.size / 2 %>	5	<p><%= custom_field_tag_with_label :issue, value %></p>
		6	<% if i == split_on -%>
6	</div><div class="splitcontentright">	7	</div><div class="splitcontentright">
7	<% end %>	8	<% end -%>
8	<% i += 1 %>	9	<% i += 1 -%>
9	<% end %>	10	<% end -%>
10	</div>	11	</div>
11	<div style="clear:both;"> </div>	12	<div style="clear:both;"> </div>

app/views/issues/show.rhtml +3 -3

                 <% end %>
             </tr>
             <tr>
-            <% n = 0
+            <% n = 0 -%>
-            for custom_value in @custom_values %>
+            <% @issue.custom_values.each do |value| -%>
-                <td valign="top"><b><%= custom_value.custom_field.name %>:</b></td><td valign="top"><%= simple_format(h(show_value(custom_value))) %></td>
+                <td valign="top"><b><%=h value.custom_field.name %>:</b></td><td valign="top"><%= simple_format(h(show_value(value))) %></td>
             <% n = n + 1
                if (n > 1)
                     n = 0 %>

app/views/projects/_form.rhtml +6 -6

             <p><%= f.check_box :is_public %></p>
             <%= wikitoolbar_for 'project_description' %>
-            <% for @custom_value in @custom_values %>
+            <% @project.custom_field_values.each do |value| %>
-            	<p><%= custom_field_tag_with_label @custom_value %></p>
+            	<p><%= custom_field_tag_with_label :project, value %></p>
             <% end %>
             </div>
             </fieldset>
             <% end %>
-            <% unless @custom_fields.empty? %>
+            <% unless @issue_custom_fields.empty? %>
             <fieldset class="box"><legend><%=l(:label_custom_field_plural)%></legend>
-            <% for custom_field in @custom_fields %>
+            <% @issue_custom_fields.each do |custom_field| %>
                 <label class="floating">
-            	<%= check_box_tag 'project[custom_field_ids][]', custom_field.id, ((@project.custom_fields.include? custom_field) or custom_field.is_for_all?), (custom_field.is_for_all? ? {:disabled => "disabled"} : {}) %>
+            	<%= check_box_tag 'project[issue_custom_field_ids][]', custom_field.id, (@project.all_issue_custom_fields.include? custom_field), (custom_field.is_for_all? ? {:disabled => "disabled"} : {}) %>
             	<%= custom_field.name %>
             	</label>
             <% end %>
-            <%= hidden_field_tag 'project[custom_field_ids][]', '' %>
+            <%= hidden_field_tag 'project[issue_custom_field_ids][]', '' %>
             </fieldset>
             <% end %>
             <!--[eoform:project]-->

app/views/projects/show.rhtml +1 -1

             	<% if @project.parent %>
             	<li><%=l(:field_parent)%>: <%= link_to h(@project.parent.name), :controller => 'projects', :action => 'show', :id => @project.parent %></li>
             	<% end %>
-            	<% for custom_value in @custom_values %>
+            	<% @project.custom_values.each do |custom_value| %>
             	<% if !custom_value.value.empty? %>
             	   <li><%= custom_value.custom_field.name%>: <%=h show_value(custom_value) %></li>
             	<% end %>

app/views/users/_form.rhtml +3 -3

             <p><%= f.text_field :mail, :required => true %></p>
             <p><%= f.select :language, lang_options_for_select %></p>
-            <% for @custom_value in @custom_values %>
+            <% @user.custom_field_values.each do |value| %>
-            	<p><%= custom_field_tag_with_label @custom_value %></p>
+            	<p><%= custom_field_tag_with_label :user, value %></p>
-            <% end if @custom_values%>
+            <% end %>
             <p><%= f.check_box :admin, :disabled => (@user == User.current) %></p>
             </div>

test/fixtures/custom_fields.yml +9 -2

               is_filter: true
               type: IssueCustomField
               max_length: 0
-              possible_values: MySQL|PostgreSQL|Oracle
+              possible_values:
+              - MySQL
+              - PostgreSQL
+              - Oracle
               id: 1
               is_required: false
               field_format: list
               is_filter: true
               type: ProjectCustomField
               max_length: 0
-              possible_values: Stable|Beta|Alpha|Planning
+              possible_values:
+              - Stable
+              - Beta
+              - Alpha
+              - Planning
               id: 3
               is_required: true
               field_format: list

test/functional/issues_controller_test.rb +82 -5

@@ -170,7 +170,7 class IssuesControllerTest < Test::Unit::TestCase
170	assert_response :success	170	assert_response :success
171	assert_template 'new'	171	assert_template 'new'
172		172
173	assert_tag :tag => 'input', :attributes => { :name => 'custom_fields[2]',	173	assert_tag :tag => 'input', :attributes => { :name => 'issue[custom_field_values][2]',
174	:value => 'Default string' }	174	:value => 'Default string' }
175	end	175	end
176		176
@@ -203,8 +203,8 class IssuesControllerTest < Test::Unit::TestCase
203	:subject => 'This is the test_new issue',	203	:subject => 'This is the test_new issue',
204	:description => 'This is the description',	204	:description => 'This is the description',
205	:priority_id => 5,	205	:priority_id => 5,
206	:estimated_hours => ''},	206	:estimated_hours => '',
207	:custom_fields => {'2' => 'Value for field 2'}	207	:custom_field_values => {'2' => 'Value for field 2'}}
208	assert_redirected_to 'issues/show'	208	assert_redirected_to 'issues/show'
209		209
210	issue = Issue.find_by_subject('This is the test_new issue')	210	issue = Issue.find_by_subject('This is the test_new issue')
@@ -226,6 +226,50 class IssuesControllerTest < Test::Unit::TestCase
226	assert_redirected_to 'issues/show'	226	assert_redirected_to 'issues/show'
227	end	227	end
228		228
		229	def test_post_new_with_required_custom_field_and_without_custom_fields_param
		230	field = IssueCustomField.find_by_name('Database')
		231	field.update_attribute(:is_required, true)
		232
		233	@request.session[:user_id] = 2
		234	post :new, :project_id => 1,
		235	:issue => {:tracker_id => 1,
		236	:subject => 'This is the test_new issue',
		237	:description => 'This is the description',
		238	:priority_id => 5}
		239	assert_response :success
		240	assert_template 'new'
		241	issue = assigns(:issue)
		242	assert_not_nil issue
		243	assert_equal 'activerecord_error_invalid', issue.errors.on(:custom_values)
		244	end
		245
		246	def test_post_should_preserve_fields_values_on_validation_failure
		247	@request.session[:user_id] = 2
		248	post :new, :project_id => 1,
		249	:issue => {:tracker_id => 1,
		250	:subject => 'This is the test_new issue',
		251	# empty description
		252	:description => '',
		253	:priority_id => 6,
		254	:custom_field_values => {'1' => 'Oracle', '2' => 'Value for field 2'}}
		255	assert_response :success
		256	assert_template 'new'
		257
		258	assert_tag :input, :attributes => { :name => 'issue[subject]',
		259	:value => 'This is the test_new issue' }
		260	assert_tag :select, :attributes => { :name => 'issue[priority_id]' },
		261	:child => { :tag => 'option', :attributes => { :selected => 'selected',
		262	:value => '6' },
		263	:content => 'High' }
		264	# Custom fields
		265	assert_tag :select, :attributes => { :name => 'issue[custom_field_values][1]' },
		266	:child => { :tag => 'option', :attributes => { :selected => 'selected',
		267	:value => 'Oracle' },
		268	:content => 'Oracle' }
		269	assert_tag :input, :attributes => { :name => 'issue[custom_field_values][2]',
		270	:value => 'Value for field 2'}
		271	end
		272
229	def test_copy_issue	273	def test_copy_issue
230	@request.session[:user_id] = 2	274	@request.session[:user_id] = 2
231	get :new, :project_id => 1, :copy_from => 1	275	get :new, :project_id => 1, :copy_from => 1
@@ -280,18 +324,28 class IssuesControllerTest < Test::Unit::TestCase
280	assert_select_rjs :show, "update"	324	assert_select_rjs :show, "update"
281	end	325	end
282		326
283	def test_post_edit	327	def test_post_edit_without_custom_fields_param
284	@request.session[:user_id] = 2	328	@request.session[:user_id] = 2
285	ActionMailer::Base.deliveries.clear	329	ActionMailer::Base.deliveries.clear
286		330
287	issue = Issue.find(1)	331	issue = Issue.find(1)
		332	assert_equal '125', issue.custom_value_for(2).value
288	old_subject = issue.subject	333	old_subject = issue.subject
289	new_subject = 'Subject modified by IssuesControllerTest#test_post_edit'	334	new_subject = 'Subject modified by IssuesControllerTest#test_post_edit'
290		335
291	post :edit, :id => 1, :issue => {:subject => new_subject}	336	assert_difference('Journal.count') do
		337	assert_difference('JournalDetail.count', 2) do
		338	post :edit, :id => 1, :issue => {:subject => new_subject,
		339	:priority_id => '6',
		340	:category_id => '1' # no change
		341	}
		342	end
		343	end
292	assert_redirected_to 'issues/show/1'	344	assert_redirected_to 'issues/show/1'
293	issue.reload	345	issue.reload
294	assert_equal new_subject, issue.subject	346	assert_equal new_subject, issue.subject
		347	# Make sure custom fields were not cleared
		348	assert_equal '125', issue.custom_value_for(2).value
295		349
296	mail = ActionMailer::Base.deliveries.last	350	mail = ActionMailer::Base.deliveries.last
297	assert_kind_of TMail::Mail, mail	351	assert_kind_of TMail::Mail, mail
@@ -299,6 +353,29 class IssuesControllerTest < Test::Unit::TestCase
299	assert mail.body.include?("Subject changed from #{old_subject} to #{new_subject}")	353	assert mail.body.include?("Subject changed from #{old_subject} to #{new_subject}")
300	end	354	end
301		355
		356	def test_post_edit_with_custom_field_change
		357	@request.session[:user_id] = 2
		358	issue = Issue.find(1)
		359	assert_equal '125', issue.custom_value_for(2).value
		360
		361	assert_difference('Journal.count') do
		362	assert_difference('JournalDetail.count', 3) do
		363	post :edit, :id => 1, :issue => {:subject => 'Custom field change',
		364	:priority_id => '6',
		365	:category_id => '1', # no change
		366	:custom_field_values => { '2' => 'New custom value' }
		367	}
		368	end
		369	end
		370	assert_redirected_to 'issues/show/1'
		371	issue.reload
		372	assert_equal 'New custom value', issue.custom_value_for(2).value
		373
		374	mail = ActionMailer::Base.deliveries.last
		375	assert_kind_of TMail::Mail, mail
		376	assert mail.body.include?("Searchable field changed from 125 to New custom value")
		377	end
		378
302	def test_post_edit_with_status_and_assignee_change	379	def test_post_edit_with_status_and_assignee_change
303	issue = Issue.find(1)	380	issue = Issue.find(1)
304	assert_equal 1, issue.status_id	381	assert_equal 1, issue.status_id

test/functional/projects_controller_test.rb +1 -1

               def test_edit
                 @request.session[:user_id] = 2 # manager
                 post :edit, :id => 1, :project => {:name => 'Test changed name',
-                                                   :custom_field_ids => ['']}
+                                                   :issue_custom_field_ids => ['']}
                 assert_redirected_to 'projects/settings/ecookbook'
                 project = Project.find(1)
                 assert_equal 'Test changed name', project.name

test/integration/admin_test.rb +3 -2

                 post "projects/add", :project => { :name => "blog",
                                                    :description => "weblog",
                                                    :identifier => "blog",
-                                                   :is_public => 1 },
+                                                   :is_public => 1,
-                                     'custom_fields[3]' => 'Beta'
+                                                   :custom_field_values => { '3' => 'Beta' }
+                                                   }
                 assert_redirected_to "admin/projects"
                 assert_equal 'Successful creation.', flash[:notice]

test/unit/issue_test.rb +77 -1

@@ -18,7 +18,13
18	require File.dirname(__FILE__) + '/../test_helper'	18	require File.dirname(__FILE__) + '/../test_helper'
19		19
20	class IssueTest < Test::Unit::TestCase	20	class IssueTest < Test::Unit::TestCase
21	fixtures :projects, :users, :members, :trackers, :projects_trackers, :issue_statuses, :issue_categories, :enumerations, :issues, :custom_fields, :custom_values, :time_entries	21	fixtures :projects, :users, :members,
		22	:trackers, :projects_trackers,
		23	:issue_statuses, :issue_categories,
		24	:enumerations,
		25	:issues,
		26	:custom_fields, :custom_fields_projects, :custom_fields_trackers, :custom_values,
		27	:time_entries
22		28
23	def test_create	29	def test_create
24	issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3, :status_id => 1, :priority => Enumeration.get_values('IPRI').first, :subject => 'test_create', :description => 'IssueTest#test_create', :estimated_hours => '1:30')	30	issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3, :status_id => 1, :priority => Enumeration.get_values('IPRI').first, :subject => 'test_create', :description => 'IssueTest#test_create', :estimated_hours => '1:30')
@@ -27,6 +33,76 class IssueTest < Test::Unit::TestCase
27	assert_equal 1.5, issue.estimated_hours	33	assert_equal 1.5, issue.estimated_hours
28	end	34	end
29		35
		36	def test_create_with_required_custom_field
		37	field = IssueCustomField.find_by_name('Database')
		38	field.update_attribute(:is_required, true)
		39
		40	issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :subject => 'test_create', :description => 'IssueTest#test_create_with_required_custom_field')
		41	assert issue.available_custom_fields.include?(field)
		42	# No value for the custom field
		43	assert !issue.save
		44	assert_equal 'activerecord_error_invalid', issue.errors.on(:custom_values)
		45	# Blank value
		46	issue.custom_field_values = { field.id => '' }
		47	assert !issue.save
		48	assert_equal 'activerecord_error_invalid', issue.errors.on(:custom_values)
		49	# Invalid value
		50	issue.custom_field_values = { field.id => 'SQLServer' }
		51	assert !issue.save
		52	assert_equal 'activerecord_error_invalid', issue.errors.on(:custom_values)
		53	# Valid value
		54	issue.custom_field_values = { field.id => 'PostgreSQL' }
		55	assert issue.save
		56	issue.reload
		57	assert_equal 'PostgreSQL', issue.custom_value_for(field).value
		58	end
		59
		60	def test_update_issue_with_required_custom_field
		61	field = IssueCustomField.find_by_name('Database')
		62	field.update_attribute(:is_required, true)
		63
		64	issue = Issue.find(1)
		65	assert_nil issue.custom_value_for(field)
		66	assert issue.available_custom_fields.include?(field)
		67	# No change to custom values, issue can be saved
		68	assert issue.save
		69	# Blank value
		70	issue.custom_field_values = { field.id => '' }
		71	assert !issue.save
		72	# Valid value
		73	issue.custom_field_values = { field.id => 'PostgreSQL' }
		74	assert issue.save
		75	issue.reload
		76	assert_equal 'PostgreSQL', issue.custom_value_for(field).value
		77	end
		78
		79	def test_should_not_update_attributes_if_custom_fields_validation_fails
		80	issue = Issue.find(1)
		81	field = IssueCustomField.find_by_name('Database')
		82	assert issue.available_custom_fields.include?(field)
		83
		84	issue.custom_field_values = { field.id => 'Invalid' }
		85	issue.subject = 'Should be not be saved'
		86	assert !issue.save
		87
		88	issue.reload
		89	assert_equal "Can't print recipes", issue.subject
		90	end
		91
		92	def test_should_not_recreate_custom_values_objects_on_update
		93	field = IssueCustomField.find_by_name('Database')
		94
		95	issue = Issue.find(1)
		96	issue.custom_field_values = { field.id => 'PostgreSQL' }
		97	assert issue.save
		98	custom_value = issue.custom_value_for(field)
		99	issue.reload
		100	issue.custom_field_values = { field.id => 'MySQL' }
		101	assert issue.save
		102	issue.reload
		103	assert_equal custom_value.id, issue.custom_value_for(field).id
		104	end
		105
30	def test_category_based_assignment	106	def test_category_based_assignment
31	issue = Issue.create(:project_id => 1, :tracker_id => 1, :author_id => 3, :status_id => 1, :priority => Enumeration.get_values('IPRI').first, :subject => 'Assignment test', :description => 'Assignment test', :category_id => 1)	107	issue = Issue.create(:project_id => 1, :tracker_id => 1, :author_id => 3, :status_id => 1, :priority => Enumeration.get_values('IPRI').first, :subject => 'Assignment test', :description => 'Assignment test', :category_id => 1)
32	assert_equal IssueCategory.find(1).assigned_to, issue.assigned_to	108	assert_equal IssueCategory.find(1).assigned_to, issue.assigned_to

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