jro_apps/redmine Commit - r10689:96fca0b08f6d

Replaces find(:all) calls....

Jean-Philippe Lang -

r10689:96fca0b08f6d

parent child

Context file:

r10689:96fca0b08f6d

Collapse all files

app/controllers/projects_controller.rb +4 -4

             # Redmine - project management software
             # Copyright (C) 2006-2012  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 ProjectsController < ApplicationController
               menu_item :overview
               menu_item :roadmap, :only => :roadmap
               menu_item :settings, :only => :settings
               before_filter :find_project, :except => [ :index, :list, :new, :create, :copy ]
               before_filter :authorize, :except => [ :index, :list, :new, :create, :copy, :archive, :unarchive, :destroy]
               before_filter :authorize_global, :only => [:new, :create]
               before_filter :require_admin, :only => [ :copy, :archive, :unarchive, :destroy ]
               accept_rss_auth :index
               accept_api_auth :index, :show, :create, :update, :destroy
               after_filter :only => [:create, :edit, :update, :archive, :unarchive, :destroy] do |controller|
                 if controller.request.post?
                   controller.send :expire_action, :controller => 'welcome', :action => 'robots'
                 end
               end
               helper :sort
               include SortHelper
               helper :custom_fields
               include CustomFieldsHelper
               helper :issues
               helper :queries
               include QueriesHelper
               helper :repositories
               include RepositoriesHelper
               include ProjectsHelper
               # Lists visible projects
               def index
                 respond_to do |format|
                   format.html {
                     scope = Project
                     unless params[:closed]
                       scope = scope.active
                     end
                     @projects = scope.visible.order('lft').all
                   }
                   format.api  {
                     @offset, @limit = api_offset_and_limit
                     @project_count = Project.visible.count
                     @projects = Project.visible.offset(@offset).limit(@limit).order('lft').all
                   }
                   format.atom {
                     projects = Project.visible.order('created_on DESC').limit(Setting.feeds_limit.to_i).all
                     render_feed(projects, :title => "#{Setting.app_title}: #{l(:label_project_latest)}")
                   }
                 end
               end
               def new
-                @issue_custom_fields = IssueCustomField.find(:all, :order => "#{CustomField.table_name}.position")
+                @issue_custom_fields = IssueCustomField.sorted.all
                 @trackers = Tracker.sorted.all
                 @project = Project.new
                 @project.safe_attributes = params[:project]
               end
               def create
-                @issue_custom_fields = IssueCustomField.find(:all, :order => "#{CustomField.table_name}.position")
+                @issue_custom_fields = IssueCustomField.sorted.all
                 @trackers = Tracker.sorted.all
                 @project = Project.new
                 @project.safe_attributes = params[:project]
                 if validate_parent_id && @project.save
                   @project.set_allowed_parent!(params[:project]['parent_id']) if params[:project].has_key?('parent_id')
                   # Add current user as a project member if he is not admin
                   unless User.current.admin?
                     r = Role.givable.find_by_id(Setting.new_project_user_role_id.to_i) || Role.givable.first
                     m = Member.new(:user => User.current, :roles => [r])
                     @project.members << m
                   end
                   respond_to do |format|
                     format.html {
                       flash[:notice] = l(:notice_successful_create)
                       redirect_to(params[:continue] ?
                         {:controller => 'projects', :action => 'new', :project => {:parent_id => @project.parent_id}.reject {|k,v| v.nil?}} :
                         {:controller => 'projects', :action => 'settings', :id => @project}
                       )
                     }
                     format.api  { render :action => 'show', :status => :created, :location => url_for(:controller => 'projects', :action => 'show', :id => @project.id) }
                   end
                 else
                   respond_to do |format|
                     format.html { render :action => 'new' }
                     format.api  { render_validation_errors(@project) }
                   end
                 end
               end
               def copy
-                @issue_custom_fields = IssueCustomField.find(:all, :order => "#{CustomField.table_name}.position")
+                @issue_custom_fields = IssueCustomField.sorted.all
                 @trackers = Tracker.sorted.all
                 @source_project = Project.find(params[:id])
                 if request.get?
                   @project = Project.copy_from(@source_project)
                   @project.identifier = Project.next_identifier if Setting.sequential_project_identifiers?
                 else
                   Mailer.with_deliveries(params[:notifications] == '1') do
                     @project = Project.new
                     @project.safe_attributes = params[:project]
                     if validate_parent_id && @project.copy(@source_project, :only => params[:only])
                       @project.set_allowed_parent!(params[:project]['parent_id']) if params[:project].has_key?('parent_id')
                       flash[:notice] = l(:notice_successful_create)
                       redirect_to :controller => 'projects', :action => 'settings', :id => @project
                     elsif !@project.new_record?
                       # Project was created
                       # But some objects were not copied due to validation failures
                       # (eg. issues from disabled trackers)
                       # TODO: inform about that
                       redirect_to :controller => 'projects', :action => 'settings', :id => @project
                     end
                   end
                 end
               rescue ActiveRecord::RecordNotFound
                 # source_project not found
                 render_404
               end
               # Show @project
               def show
                 if params[:jump]
                   # try to redirect to the requested menu item
                   redirect_to_project_menu_item(@project, params[:jump]) && return
                 end
                 @users_by_role = @project.users_by_role
                 @subprojects = @project.children.visible.all
                 @news = @project.news.limit(5).includes(:author, :project).reorder("#{News.table_name}.created_on DESC").all
                 @trackers = @project.rolled_up_trackers
                 cond = @project.project_condition(Setting.display_subprojects_issues?)
                 @open_issues_by_tracker = Issue.visible.open.where(cond).count(:group => :tracker)
                 @total_issues_by_tracker = Issue.visible.where(cond).count(:group => :tracker)
                 if User.current.allowed_to?(:view_time_entries, @project)
                   @total_hours = TimeEntry.visible.sum(:hours, :include => :project, :conditions => cond).to_f
                 end
                 @key = User.current.rss_key
                 respond_to do |format|
                   format.html
                   format.api
                 end
               end
               def settings
-                @issue_custom_fields = IssueCustomField.find(:all, :order => "#{CustomField.table_name}.position")
+                @issue_custom_fields = IssueCustomField.sorted.all
                 @issue_category ||= IssueCategory.new
                 @member ||= @project.members.new
                 @trackers = Tracker.sorted.all
                 @wiki ||= @project.wiki
               end
               def edit
               end
               def update
                 @project.safe_attributes = params[:project]
                 if validate_parent_id && @project.save
                   @project.set_allowed_parent!(params[:project]['parent_id']) if params[:project].has_key?('parent_id')
                   respond_to do |format|
                     format.html {
                       flash[:notice] = l(:notice_successful_update)
                       redirect_to :action => 'settings', :id => @project
                     }
                     format.api  { render_api_ok }
                   end
                 else
                   respond_to do |format|
                     format.html {
                       settings
                       render :action => 'settings'
                     }
                     format.api  { render_validation_errors(@project) }
                   end
                 end
               end
               def modules
                 @project.enabled_module_names = params[:enabled_module_names]
                 flash[:notice] = l(:notice_successful_update)
                 redirect_to :action => 'settings', :id => @project, :tab => 'modules'
               end
               def archive
                 if request.post?
                   unless @project.archive
                     flash[:error] = l(:error_can_not_archive_project)
                   end
                 end
                 redirect_to(url_for(:controller => 'admin', :action => 'projects', :status => params[:status]))
               end
               def unarchive
                 @project.unarchive if request.post? && !@project.active?
                 redirect_to(url_for(:controller => 'admin', :action => 'projects', :status => params[:status]))
               end
               def close
                 @project.close
                 redirect_to project_path(@project)
               end
               def reopen
                 @project.reopen
                 redirect_to project_path(@project)
               end
               # Delete @project
               def destroy
                 @project_to_destroy = @project
                 if api_request? || params[:confirm]
                   @project_to_destroy.destroy
                   respond_to do |format|
                     format.html { redirect_to :controller => 'admin', :action => 'projects' }
                     format.api  { render_api_ok }
                   end
                 end
                 # hide project in layout
                 @project = nil
               end
               private
               # Validates parent_id param according to user's permissions
               # TODO: move it to Project model in a validation that depends on User.current
               def validate_parent_id
                 return true if User.current.admin?
                 parent_id = params[:project] && params[:project][:parent_id]
                 if parent_id || @project.new_record?
                   parent = parent_id.blank? ? nil : Project.find_by_id(parent_id.to_i)
                   unless @project.allowed_parents.include?(parent)
                     @project.errors.add :parent_id, :invalid
                     return false
                   end
                 end
                 true
               end
             end

app/helpers/repositories_helper.rb +1 -1

             # encoding: utf-8
             #
             # Redmine - project management software
             # Copyright (C) 2006-2012  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 RepositoriesHelper
               def format_revision(revision)
                 if revision.respond_to? :format_identifier
                   revision.format_identifier
                 else
                   revision.to_s
                 end
               end
               def truncate_at_line_break(text, length = 255)
                 if text
                   text.gsub(%r{^(.{#{length}}[^\n]*)\n.+$}m, '\\1...')
                 end
               end
               def render_properties(properties)
                 unless properties.nil? || properties.empty?
                   content = ''
                   properties.keys.sort.each do |property|
                     content << content_tag('li', "<b>#{h property}</b>: <span>#{h properties[property]}</span>".html_safe)
                   end
                   content_tag('ul', content.html_safe, :class => 'properties')
                 end
               end
               def render_changeset_changes
-                changes = @changeset.filechanges.find(:all, :limit => 1000, :order => 'path').collect do |change|
+                changes = @changeset.filechanges.limit(1000).reorder('path').all.collect do |change|
                   case change.action
                   when 'A'
                     # Detects moved/copied files
                     if !change.from_path.blank?
                       change.action =
                          @changeset.filechanges.detect {|c| c.action == 'D' && c.path == change.from_path} ? 'R' : 'C'
                     end
                     change
                   when 'D'
                     @changeset.filechanges.detect {|c| c.from_path == change.path} ? nil : change
                   else
                     change
                   end
                 end.compact
                 tree = { }
                 changes.each do |change|
                   p = tree
                   dirs = change.path.to_s.split('/').select {|d| !d.blank?}
                   path = ''
                   dirs.each do |dir|
                     path += '/' + dir
                     p[:s] ||= {}
                     p = p[:s]
                     p[path] ||= {}
                     p = p[path]
                   end
                   p[:c] = change
                 end
                 render_changes_tree(tree[:s])
               end
               def render_changes_tree(tree)
                 return '' if tree.nil?
                 output = ''
                 output << '<ul>'
                 tree.keys.sort.each do |file|
                   style = 'change'
                   text = File.basename(h(file))
                   if s = tree[file][:s]
                     style << ' folder'
                     path_param = to_path_param(@repository.relative_path(file))
                     text = link_to(h(text), :controller => 'repositories',
                                          :action => 'show',
                                          :id => @project,
                                          :repository_id => @repository.identifier_param,
                                          :path => path_param,
                                          :rev => @changeset.identifier)
                     output << "<li class='#{style}'>#{text}"
                     output << render_changes_tree(s)
                     output << "</li>"
                   elsif c = tree[file][:c]
                     style << " change-#{c.action}"
                     path_param = to_path_param(@repository.relative_path(c.path))
                     text = link_to(h(text), :controller => 'repositories',
                                          :action => 'entry',
                                          :id => @project,
                                          :repository_id => @repository.identifier_param,
                                          :path => path_param,
                                          :rev => @changeset.identifier) unless c.action == 'D'
                     text << " - #{h(c.revision)}" unless c.revision.blank?
                     text << ' ('.html_safe + link_to(l(:label_diff), :controller => 'repositories',
                                                    :action => 'diff',
                                                    :id => @project,
                                                    :repository_id => @repository.identifier_param,
                                                    :path => path_param,
                                                    :rev => @changeset.identifier) + ') '.html_safe if c.action == 'M'
                     text << ' '.html_safe + content_tag('span', h(c.from_path), :class => 'copied-from') unless c.from_path.blank?
                     output << "<li class='#{style}'>#{text}</li>"
                   end
                 end
                 output << '</ul>'
                 output.html_safe
               end
               def repository_field_tags(form, repository)
                 method = repository.class.name.demodulize.underscore + "_field_tags"
                 if repository.is_a?(Repository) &&
                     respond_to?(method) && method != 'repository_field_tags'
                   send(method, form, repository)
                 end
               end
               def scm_select_tag(repository)
                 scm_options = [["--- #{l(:actionview_instancetag_blank_option)} ---", '']]
                 Redmine::Scm::Base.all.each do |scm|
                 if Setting.enabled_scm.include?(scm) ||
                       (repository && repository.class.name.demodulize == scm)
                     scm_options << ["Repository::#{scm}".constantize.scm_name, scm]
                   end
                 end
                 select_tag('repository_scm',
                            options_for_select(scm_options, repository.class.name.demodulize),
                            :disabled => (repository && !repository.new_record?),
                            :data => {:remote => true, :method => 'get'})
               end
               def with_leading_slash(path)
                 path.to_s.starts_with?('/') ? path : "/#{path}"
               end
               def without_leading_slash(path)
                 path.gsub(%r{^/+}, '')
               end
               def subversion_field_tags(form, repository)
                   content_tag('p', form.text_field(:url, :size => 60, :required => true,
                                    :disabled => !repository.safe_attribute?('url')) +
                                    '<br />'.html_safe +
                                    '(file:///, http://, https://, svn://, svn+[tunnelscheme]://)') +
                   content_tag('p', form.text_field(:login, :size => 30)) +
                   content_tag('p', form.password_field(
                                         :password, :size => 30, :name => 'ignore',
                                         :value => ((repository.new_record? || repository.password.blank?) ? '' : ('x'*15)),
                                         :onfocus => "this.value=''; this.name='repository[password]';",
                                         :onchange => "this.name='repository[password]';"))
               end
               def darcs_field_tags(form, repository)
                 content_tag('p', form.text_field(
                                  :url, :label => l(:field_path_to_repository),
                                  :size => 60, :required => true,
                                  :disabled => !repository.safe_attribute?('url'))) +
                 content_tag('p', form.select(
                                  :log_encoding, [nil] + Setting::ENCODINGS,
                                  :label => l(:field_commit_logs_encoding), :required => true))
               end
               def mercurial_field_tags(form, repository)
                 content_tag('p', form.text_field(
                                    :url, :label => l(:field_path_to_repository),
                                    :size => 60, :required => true,
                                    :disabled => !repository.safe_attribute?('url')
                                      ) +
                                  '<br />'.html_safe + l(:text_mercurial_repository_note)) +
                 content_tag('p', form.select(
                                     :path_encoding, [nil] + Setting::ENCODINGS,
                                     :label => l(:field_scm_path_encoding)
                                     ) +
                                  '<br />'.html_safe + l(:text_scm_path_encoding_note))
               end
               def git_field_tags(form, repository)
                 content_tag('p', form.text_field(
                                    :url, :label => l(:field_path_to_repository),
                                    :size => 60, :required => true,
                                    :disabled => !repository.safe_attribute?('url')
                                      ) +
                                   '<br />'.html_safe +
                                   l(:text_git_repository_note)) +
                 content_tag('p', form.select(
                                     :path_encoding, [nil] + Setting::ENCODINGS,
                                     :label => l(:field_scm_path_encoding)
                                     ) +
                                  '<br />'.html_safe + l(:text_scm_path_encoding_note)) +
                 content_tag('p', form.check_box(
                                     :extra_report_last_commit,
                                     :label => l(:label_git_report_last_commit)
                                      ))
               end
               def cvs_field_tags(form, repository)
                 content_tag('p', form.text_field(
                                  :root_url,
                                  :label => l(:field_cvsroot),
                                  :size => 60, :required => true,
                                  :disabled => !repository.safe_attribute?('root_url'))) +
                 content_tag('p', form.text_field(
                                  :url,
                                  :label => l(:field_cvs_module),
                                  :size => 30, :required => true,
                                  :disabled => !repository.safe_attribute?('url'))) +
                 content_tag('p', form.select(
                                  :log_encoding, [nil] + Setting::ENCODINGS,
                                  :label => l(:field_commit_logs_encoding), :required => true)) +
                 content_tag('p', form.select(
                                     :path_encoding, [nil] + Setting::ENCODINGS,
                                     :label => l(:field_scm_path_encoding)
                                     ) +
                                  '<br />'.html_safe + l(:text_scm_path_encoding_note))
               end
               def bazaar_field_tags(form, repository)
                 content_tag('p', form.text_field(
                                  :url, :label => l(:field_path_to_repository),
                                  :size => 60, :required => true,
                                  :disabled => !repository.safe_attribute?('url'))) +
                 content_tag('p', form.select(
                                  :log_encoding, [nil] + Setting::ENCODINGS,
                                  :label => l(:field_commit_logs_encoding), :required => true))
               end
               def filesystem_field_tags(form, repository)
                 content_tag('p', form.text_field(
                                  :url, :label => l(:field_root_directory),
                                  :size => 60, :required => true,
                                  :disabled => !repository.safe_attribute?('url'))) +
                 content_tag('p', form.select(
                                     :path_encoding, [nil] + Setting::ENCODINGS,
                                     :label => l(:field_scm_path_encoding)
                                     ) +
                                  '<br />'.html_safe + l(:text_scm_path_encoding_note))
               end
               def index_commits(commits, heads)
                 return nil if commits.nil? or commits.first.parents.nil?
                 refs_map = {}
                 heads.each do |head|
                   refs_map[head.scmid] ||= []
                   refs_map[head.scmid] << head
                 end
                 commits_by_scmid = {}
                 commits.reverse.each_with_index do |commit, commit_index|
                   commits_by_scmid[commit.scmid] = {
                     :parent_scmids => commit.parents.collect { |parent| parent.scmid },
                     :rdmid => commit_index,
                     :refs  => refs_map.include?(commit.scmid) ? refs_map[commit.scmid].join(" ") : nil,
                     :scmid => commit.scmid,
                     :href  => block_given? ? yield(commit.scmid) : commit.scmid
                   }
                 end
                 heads.sort! { |head1, head2| head1.to_s <=> head2.to_s }
                 space = nil
                 heads.each do |head|
                   if commits_by_scmid.include? head.scmid
                     space = index_head((space || -1) + 1, head, commits_by_scmid)
                   end
                 end
                 # when no head matched anything use first commit
                 space ||= index_head(0, commits.first, commits_by_scmid)
                 return commits_by_scmid, space
               end
               def index_head(space, commit, commits_by_scmid)
                 stack = [[space, commits_by_scmid[commit.scmid]]]
                 max_space = space
                 until stack.empty?
                   space, commit = stack.pop
                   commit[:space] = space if commit[:space].nil?
                   space -= 1
                   commit[:parent_scmids].each_with_index do |parent_scmid, parent_index|
                     parent_commit = commits_by_scmid[parent_scmid]
                     if parent_commit and parent_commit[:space].nil?
                       stack.unshift [space += 1, parent_commit]
                     end
                   end
                   max_space = space if max_space < space
                 end
                 max_space
               end
             end

app/helpers/timelog_helper.rb +1 -1

             # encoding: utf-8
             #
             # Redmine - project management software
             # Copyright (C) 2006-2012  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 TimelogHelper
               include ApplicationHelper
               def render_timelog_breadcrumb
                 links = []
                 links << link_to(l(:label_project_all), {:project_id => nil, :issue_id => nil})
                 links << link_to(h(@project), {:project_id => @project, :issue_id => nil}) if @project
                 if @issue
                   if @issue.visible?
                     links << link_to_issue(@issue, :subject => false)
                   else
                     links << "##{@issue.id}"
                   end
                 end
                 breadcrumb links
               end
               # Returns a collection of activities for a select field.  time_entry
               # is optional and will be used to check if the selected TimeEntryActivity
               # is active.
               def activity_collection_for_select_options(time_entry=nil, project=nil)
                 project ||= @project
                 if project.nil?
                   activities = TimeEntryActivity.shared.active
                 else
                   activities = project.activities
                 end
                 collection = []
                 if time_entry && time_entry.activity && !time_entry.activity.active?
                   collection << [ "--- #{l(:actionview_instancetag_blank_option)} ---", '' ]
                 else
                   collection << [ "--- #{l(:actionview_instancetag_blank_option)} ---", '' ] unless activities.detect(&:is_default)
                 end
                 activities.each { |a| collection << [a.name, a.id] }
                 collection
               end
               def select_hours(data, criteria, value)
               	if value.to_s.empty?
               		data.select {|row| row[criteria].blank? }
                 else
                 	data.select {|row| row[criteria].to_s == value.to_s}
                 end
               end
               def sum_hours(data)
                 sum = 0
                 data.each do |row|
                   sum += row['hours'].to_f
                 end
                 sum
               end
               def options_for_period_select(value)
                 options_for_select([[l(:label_all_time), 'all'],
                                     [l(:label_today), 'today'],
                                     [l(:label_yesterday), 'yesterday'],
                                     [l(:label_this_week), 'current_week'],
                                     [l(:label_last_week), 'last_week'],
                                     [l(:label_last_n_weeks, 2), 'last_2_weeks'],
                                     [l(:label_last_n_days, 7), '7_days'],
                                     [l(:label_this_month), 'current_month'],
                                     [l(:label_last_month), 'last_month'],
                                     [l(:label_last_n_days, 30), '30_days'],
                                     [l(:label_this_year), 'current_year']],
                                     value)
               end
               def entries_to_csv(entries)
                 decimal_separator = l(:general_csv_decimal_separator)
-                custom_fields = TimeEntryCustomField.find(:all)
+                custom_fields = TimeEntryCustomField.all
                 export = FCSV.generate(:col_sep => l(:general_csv_separator)) do |csv|
                   # csv header fields
                   headers = [l(:field_spent_on),
                              l(:field_user),
                              l(:field_activity),
                              l(:field_project),
                              l(:field_issue),
                              l(:field_tracker),
                              l(:field_subject),
                              l(:field_hours),
                              l(:field_comments)
                              ]
                   # Export custom fields
                   headers += custom_fields.collect(&:name)
                   csv << headers.collect {|c| Redmine::CodesetUtil.from_utf8(
                                                  c.to_s,
                                                  l(:general_csv_encoding) )  }
                   # csv lines
                   entries.each do |entry|
                     fields = [format_date(entry.spent_on),
                               entry.user,
                               entry.activity,
                               entry.project,
                               (entry.issue ? entry.issue.id : nil),
                               (entry.issue ? entry.issue.tracker : nil),
                               (entry.issue ? entry.issue.subject : nil),
                               entry.hours.to_s.gsub('.', decimal_separator),
                               entry.comments
                               ]
                     fields += custom_fields.collect {|f| show_value(entry.custom_field_values.detect {|v| v.custom_field_id == f.id}) }
                     csv << fields.collect {|c| Redmine::CodesetUtil.from_utf8(
                                                  c.to_s,
                                                  l(:general_csv_encoding) )  }
                   end
                 end
                 export
               end
               def format_criteria_value(criteria_options, value)
                 if value.blank?
                   "[#{l(:label_none)}]"
                 elsif k = criteria_options[:klass]
                   obj = k.find_by_id(value.to_i)
                   if obj.is_a?(Issue)
                     obj.visible? ? "#{obj.tracker} ##{obj.id}: #{obj.subject}" : "##{obj.id}"
                   else
                     obj
                   end
                 else
                   format_value(value, criteria_options[:format])
                 end
               end
               def report_to_csv(report)
                 decimal_separator = l(:general_csv_decimal_separator)
                 export = FCSV.generate(:col_sep => l(:general_csv_separator)) do |csv|
                   # Column headers
                   headers = report.criteria.collect {|criteria| l(report.available_criteria[criteria][:label]) }
                   headers += report.periods
                   headers << l(:label_total)
                   csv << headers.collect {|c| Redmine::CodesetUtil.from_utf8(
                                                 c.to_s,
                                                 l(:general_csv_encoding) ) }
                   # Content
                   report_criteria_to_csv(csv, report.available_criteria, report.columns, report.criteria, report.periods, report.hours)
                   # Total row
                   str_total = Redmine::CodesetUtil.from_utf8(l(:label_total), l(:general_csv_encoding))
                   row = [ str_total ] + [''] * (report.criteria.size - 1)
                   total = 0
                   report.periods.each do |period|
                     sum = sum_hours(select_hours(report.hours, report.columns, period.to_s))
                     total += sum
                     row << (sum > 0 ? ("%.2f" % sum).gsub('.',decimal_separator) : '')
                   end
                   row << ("%.2f" % total).gsub('.',decimal_separator)
                   csv << row
                 end
                 export
               end
               def report_criteria_to_csv(csv, available_criteria, columns, criteria, periods, hours, level=0)
                 decimal_separator = l(:general_csv_decimal_separator)
                 hours.collect {|h| h[criteria[level]].to_s}.uniq.each do |value|
                   hours_for_value = select_hours(hours, criteria[level], value)
                   next if hours_for_value.empty?
                   row = [''] * level
                   row << Redmine::CodesetUtil.from_utf8(
                                     format_criteria_value(available_criteria[criteria[level]], value).to_s,
                                     l(:general_csv_encoding) )
                   row += [''] * (criteria.length - level - 1)
                   total = 0
                   periods.each do |period|
                     sum = sum_hours(select_hours(hours_for_value, columns, period.to_s))
                     total += sum
                     row << (sum > 0 ? ("%.2f" % sum).gsub('.',decimal_separator) : '')
                   end
                   row << ("%.2f" % total).gsub('.',decimal_separator)
                   csv << row
                   if criteria.length > level + 1
                     report_criteria_to_csv(csv, available_criteria, columns, criteria, periods, hours_for_value, level + 1)
                   end
                 end
               end
             end

app/models/custom_field.rb +2 0

             # Redmine - project management software
             # Copyright (C) 2006-2012  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
               acts_as_list :scope => 'type = \'#{self.class}\''
               serialize :possible_values
               validates_presence_of :name, :field_format
               validates_uniqueness_of :name, :scope => :type
               validates_length_of :name, :maximum => 30
               validates_inclusion_of :field_format, :in => Redmine::CustomFieldFormat.available_formats
               validate :validate_custom_field
               before_validation :set_searchable
+              scope :sorted, order("#{table_name}.position ASC")
               CUSTOM_FIELDS_TABS = [
                 {:name => 'IssueCustomField', :partial => 'custom_fields/index',
                  :label => :label_issue_plural},
                 {:name => 'TimeEntryCustomField', :partial => 'custom_fields/index',
                  :label => :label_spent_time},
                 {:name => 'ProjectCustomField', :partial => 'custom_fields/index',
                  :label => :label_project_plural},
                 {:name => 'VersionCustomField', :partial => 'custom_fields/index',
                  :label => :label_version_plural},
                 {:name => 'UserCustomField', :partial => 'custom_fields/index',
                  :label => :label_user_plural},
                 {:name => 'GroupCustomField', :partial => 'custom_fields/index',
                  :label => :label_group_plural},
                 {:name => 'TimeEntryActivityCustomField', :partial => 'custom_fields/index',
                  :label => TimeEntryActivity::OptionName},
                 {:name => 'IssuePriorityCustomField', :partial => 'custom_fields/index',
                  :label => IssuePriority::OptionName},
                 {:name => 'DocumentCategoryCustomField', :partial => 'custom_fields/index',
                  :label => DocumentCategory::OptionName}
               ]
               CUSTOM_FIELDS_NAMES = CUSTOM_FIELDS_TABS.collect{|v| v[:name]}
               def field_format=(arg)
                 # cannot change format of a saved custom field
                 super if new_record?
               end
               def set_searchable
                 # make sure these fields are not searchable
                 self.searchable = false if %w(int float date bool).include?(field_format)
                 # make sure only these fields can have multiple values
                 self.multiple = false unless %w(list user version).include?(field_format)
                 true
               end
               def validate_custom_field
                 if self.field_format == "list"
                   errors.add(:possible_values, :blank) if self.possible_values.nil? || self.possible_values.empty?
                   errors.add(:possible_values, :invalid) unless self.possible_values.is_a? Array
                 end
                 if regexp.present?
                   begin
                     Regexp.new(regexp)
                   rescue
                     errors.add(:regexp, :invalid)
                   end
                 end
                 if default_value.present? && !valid_field_value?(default_value)
                   errors.add(:default_value, :invalid)
                 end
               end
               def possible_values_options(obj=nil)
                 case field_format
                 when 'user', 'version'
                   if obj.respond_to?(:project) && obj.project
                     case field_format
                     when 'user'
                       obj.project.users.sort.collect {|u| [u.to_s, u.id.to_s]}
                     when 'version'
                       obj.project.shared_versions.sort.collect {|u| [u.to_s, u.id.to_s]}
                     end
                   elsif obj.is_a?(Array)
                     obj.collect {|o| possible_values_options(o)}.reduce(:&)
                   else
                     []
                   end
                 when 'bool'
                   [[l(:general_text_Yes), '1'], [l(:general_text_No), '0']]
                 else
                   possible_values || []
                 end
               end
               def possible_values(obj=nil)
                 case field_format
                 when 'user', 'version'
                   possible_values_options(obj).collect(&:last)
                 when 'bool'
                   ['1', '0']
                 else
                   values = super()
                   if values.is_a?(Array)
                     values.each do |value|
                       value.force_encoding('UTF-8') if value.respond_to?(:force_encoding)
                     end
                   end
                   values || []
                 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)
                 casted = nil
                 unless value.blank?
                   case field_format
                   when 'string', 'text', 'list'
                     casted = value
                   when 'date'
                     casted = begin; value.to_date; rescue; nil end
                   when 'bool'
                     casted = (value == '1' ? true : false)
                   when 'int'
                     casted = value.to_i
                   when 'float'
                     casted = value.to_f
                   when 'user', 'version'
                     casted = (value.blank? ? nil : field_format.classify.constantize.find_by_id(value.to_i))
                   end
                 end
                 casted
               end
               def value_from_keyword(keyword, customized)
                 possible_values_options = possible_values_options(customized)
                 if possible_values_options.present?
                   keyword = keyword.to_s.downcase
                   possible_values_options.detect {|text, id| text.downcase == keyword}.try(:last)
                 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?
                 case field_format
                   when 'string', 'text', 'list', 'date', 'bool'
                     # COALESCE is here to make sure that blank and NULL values are sorted equally
                     "COALESCE((SELECT cv_sort.value FROM #{CustomValue.table_name} cv_sort" +
                       " WHERE cv_sort.customized_type='#{self.class.customized_class.base_class.name}'" +
                       " AND cv_sort.customized_id=#{self.class.customized_class.table_name}.id" +
                       " AND cv_sort.custom_field_id=#{id} LIMIT 1), '')"
                   when 'int', 'float'
                     # 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
                     "(SELECT CAST(cv_sort.value AS decimal(60,3)) FROM #{CustomValue.table_name} cv_sort" +
                       " WHERE cv_sort.customized_type='#{self.class.customized_class.base_class.name}'" +
                       " AND cv_sort.customized_id=#{self.class.customized_class.table_name}.id" +
                       " AND cv_sort.custom_field_id=#{id} AND cv_sort.value <> '' AND cv_sort.value IS NOT NULL LIMIT 1)"
                   when 'user', 'version'
                     value_class.fields_for_order_statement(value_join_alias)
                   else
                     nil
                 end
               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?
                 case field_format
                   when 'list', 'date', 'bool', 'int'
                     order_statement
                   when 'user', 'version'
                     "COALESCE((SELECT cv_sort.value FROM #{CustomValue.table_name} cv_sort" +
                       " WHERE cv_sort.customized_type='#{self.class.customized_class.base_class.name}'" +
                       " AND cv_sort.customized_id=#{self.class.customized_class.table_name}.id" +
                       " AND cv_sort.custom_field_id=#{id} LIMIT 1), '')"
                   else
                     nil
                 end
               end
               def join_for_order_statement
                 case field_format
                   when 'user', 'version'
                     "LEFT OUTER JOIN #{CustomValue.table_name} #{join_alias}" +
                       " ON #{join_alias}.customized_type = '#{self.class.customized_class.base_class.name}'" +
                       " AND #{join_alias}.customized_id = #{self.class.customized_class.table_name}.id" +
                       " AND #{join_alias}.custom_field_id = #{id}" +
                       " AND #{join_alias}.value <> ''" +
                       " AND #{join_alias}.id = (SELECT max(#{join_alias}_2.id) FROM #{CustomValue.table_name} #{join_alias}_2" +
                         " WHERE #{join_alias}_2.customized_type = #{join_alias}.customized_type" +
                         " AND #{join_alias}_2.customized_id = #{join_alias}.customized_id" +
                         " AND #{join_alias}_2.custom_field_id = #{join_alias}.custom_field_id)" +
                       " LEFT OUTER JOIN #{value_class.table_name} #{value_join_alias}" +
                       " ON CAST(#{join_alias}.value as decimal(60,0)) = #{value_join_alias}.id"
                   else
                     nil
                 end
               end
               def join_alias
                 "cf_#{id}"
               end
               def value_join_alias
                 join_alias + "_" + field_format
               end
               def <=>(field)
                 position <=> field.position
               end
               # Returns the class that values represent
               def value_class
                 case field_format
                   when 'user', 'version'
                     field_format.classify.constantize
                   else
                     nil
                 end
               end
               def self.customized_class
                 self.name =~ /^(.+)CustomField$/
                 begin; $1.constantize; rescue nil; end
               end
               # to move in project_custom_field
               def self.for_all
                 find(:all, :conditions => ["is_for_all=?", true], :order => 'position')
               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_field_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
                   value.each {|v| errs += validate_field_value_format(v)}
                 else
                   if is_required? && value.blank?
                     errs << ::I18n.t('activerecord.errors.messages.blank')
                   end
                   errs += validate_field_value_format(value)
                 end
                 errs
               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
               # Returns the error message for the given value regarding its format
               def validate_field_value_format(value)
                 errs = []
                 if value.present?
                   errs << ::I18n.t('activerecord.errors.messages.invalid') unless regexp.blank? or value =~ Regexp.new(regexp)
                   errs << ::I18n.t('activerecord.errors.messages.too_short', :count => min_length) if min_length > 0 and value.length < min_length
                   errs << ::I18n.t('activerecord.errors.messages.too_long', :count => max_length) if max_length > 0 and value.length > max_length
                   # Format specific validations
                   case field_format
                   when 'int'
                     errs << ::I18n.t('activerecord.errors.messages.not_a_number') unless value =~ /^[+-]?\d+$/
                   when 'float'
                     begin; Kernel.Float(value); rescue; errs << ::I18n.t('activerecord.errors.messages.invalid') end
                   when 'date'
                     errs << ::I18n.t('activerecord.errors.messages.not_a_date') unless value =~ /^\d{4}-\d{2}-\d{2}$/ && begin; value.to_date; rescue; false end
                   when 'list'
                     errs << ::I18n.t('activerecord.errors.messages.inclusion') unless possible_values.include?(value)
                   end
                 end
                 errs
               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