jro_apps/redmine Commit - r15839:aa354e627516

Don't join all associations by default (#24865)....

Jean-Philippe Lang -

r15839:aa354e627516

parent child

Context file:

r15839:aa354e627516

Collapse all files

app/controllers/issues_controller.rb +2 -3

             # Redmine - project management software
             # Copyright (C) 2006-2016  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 IssuesController < ApplicationController
               default_search_scope :issues
               before_action :find_issue, :only => [:show, :edit, :update]
               before_action :find_issues, :only => [:bulk_edit, :bulk_update, :destroy]
               before_action :authorize, :except => [:index, :new, :create]
               before_action :find_optional_project, :only => [:index, :new, :create]
               before_action :build_new_issue_from_params, :only => [:new, :create]
               accept_rss_auth :index, :show
               accept_api_auth :index, :show, :create, :update, :destroy
               rescue_from Query::StatementInvalid, :with => :query_statement_invalid
               helper :journals
               helper :projects
               helper :custom_fields
               helper :issue_relations
               helper :watchers
               helper :attachments
               helper :queries
               include QueriesHelper
               helper :repositories
               helper :sort
               include SortHelper
               helper :timelog
               def index
                 retrieve_query
                 sort_init(@query.sort_criteria.empty? ? [['id', 'desc']] : @query.sort_criteria)
                 sort_update(@query.sortable_columns)
                 @query.sort_criteria = sort_criteria.to_a
                 if @query.valid?
                   case params[:format]
                   when 'csv', 'pdf'
                     @limit = Setting.issues_export_limit.to_i
                     if params[:columns] == 'all'
                       @query.column_names = @query.available_inline_columns.map(&:name)
                     end
                   when 'atom'
                     @limit = Setting.feeds_limit.to_i
                   when 'xml', 'json'
                     @offset, @limit = api_offset_and_limit
                     @query.column_names = %w(author)
                   else
                     @limit = per_page_option
                   end
                   @issue_count = @query.issue_count
                   @issue_pages = Paginator.new @issue_count, @limit, params['page']
                   @offset ||= @issue_pages.offset
-                  @issues = @query.issues(:include => [:assigned_to, :tracker, :priority, :category, :fixed_version],
+                  @issues = @query.issues(:order => sort_clause,
-                                          :order => sort_clause,
                                           :offset => @offset,
                                           :limit => @limit)
                   @issue_count_by_group = @query.issue_count_by_group
                   respond_to do |format|
                     format.html { render :template => 'issues/index', :layout => !request.xhr? }
                     format.api  {
                       Issue.load_visible_relations(@issues) if include_in_api_response?('relations')
                     }
                     format.atom { render_feed(@issues, :title => "#{@project || Setting.app_title}: #{l(:label_issue_plural)}") }
                     format.csv  { send_data(query_to_csv(@issues, @query, params[:csv]), :type => 'text/csv; header=present', :filename => 'issues.csv') }
                     format.pdf  { send_file_headers! :type => 'application/pdf', :filename => 'issues.pdf' }
                   end
                 else
                   respond_to do |format|
                     format.html { render(:template => 'issues/index', :layout => !request.xhr?) }
                     format.any(:atom, :csv, :pdf) { head 422 }
                     format.api { render_validation_errors(@query) }
                   end
                 end
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               def show
                 @journals = @issue.visible_journals_with_index
                 @changesets = @issue.changesets.visible.preload(:repository, :user).to_a
                 @relations = @issue.relations.select {|r| r.other_issue(@issue) && r.other_issue(@issue).visible? }
                 if User.current.wants_comments_in_reverse_order?
                   @journals.reverse!
                   @changesets.reverse!
                 end
                 respond_to do |format|
                   format.html {
                     @allowed_statuses = @issue.new_statuses_allowed_to(User.current)
                     @priorities = IssuePriority.active
                     @time_entry = TimeEntry.new(:issue => @issue, :project => @issue.project)
                     @relation = IssueRelation.new
                     retrieve_previous_and_next_issue_ids
                     render :template => 'issues/show'
                   }
                   format.api
                   format.atom { render :template => 'journals/index', :layout => false, :content_type => 'application/atom+xml' }
                   format.pdf  {
                     send_file_headers! :type => 'application/pdf', :filename => "#{@project.identifier}-#{@issue.id}.pdf"
                   }
                 end
               end
               def new
                 respond_to do |format|
                   format.html { render :action => 'new', :layout => !request.xhr? }
                   format.js
                 end
               end
               def create
                 unless User.current.allowed_to?(:add_issues, @issue.project, :global => true)
                   raise ::Unauthorized
                 end
                 call_hook(:controller_issues_new_before_save, { :params => params, :issue => @issue })
                 @issue.save_attachments(params[:attachments] || (params[:issue] && params[:issue][:uploads]))
                 if @issue.save
                   call_hook(:controller_issues_new_after_save, { :params => params, :issue => @issue})
                   respond_to do |format|
                     format.html {
                       render_attachment_warning_if_needed(@issue)
                       flash[:notice] = l(:notice_issue_successful_create, :id => view_context.link_to("##{@issue.id}", issue_path(@issue), :title => @issue.subject))
                       redirect_after_create
                     }
                     format.api  { render :action => 'show', :status => :created, :location => issue_url(@issue) }
                   end
                   return
                 else
                   respond_to do |format|
                     format.html {
                       if @issue.project.nil?
                         render_error :status => 422
                       else
                         render :action => 'new'
                       end
                     }
                     format.api  { render_validation_errors(@issue) }
                   end
                 end
               end
               def edit
                 return unless update_issue_from_params
                 respond_to do |format|
                   format.html { }
                   format.js
                 end
               end
               def update
                 return unless update_issue_from_params
                 @issue.save_attachments(params[:attachments] || (params[:issue] && params[:issue][:uploads]))
                 saved = false
                 begin
                   saved = save_issue_with_child_records
                 rescue ActiveRecord::StaleObjectError
                   @conflict = true
                   if params[:last_journal_id]
                     @conflict_journals = @issue.journals_after(params[:last_journal_id]).to_a
                     @conflict_journals.reject!(&:private_notes?) unless User.current.allowed_to?(:view_private_notes, @issue.project)
                   end
                 end
                 if saved
                   render_attachment_warning_if_needed(@issue)
                   flash[:notice] = l(:notice_successful_update) unless @issue.current_journal.new_record?
                   respond_to do |format|
                     format.html { redirect_back_or_default issue_path(@issue, previous_and_next_issue_ids_params) }
                     format.api  { render_api_ok }
                   end
                 else
                   respond_to do |format|
                     format.html { render :action => 'edit' }
                     format.api  { render_validation_errors(@issue) }
                   end
                 end
               end
               # Bulk edit/copy a set of issues
               def bulk_edit
                 @issues.sort!
                 @copy = params[:copy].present?
                 @notes = params[:notes]
                 if @copy
                   unless User.current.allowed_to?(:copy_issues, @projects)
                     raise ::Unauthorized
                   end
                 else
                   unless @issues.all?(&:attributes_editable?)
                     raise ::Unauthorized
                   end
                 end
                 edited_issues = Issue.where(:id => @issues.map(&:id)).to_a
                 @allowed_projects = Issue.allowed_target_projects
                 if params[:issue]
                   @target_project = @allowed_projects.detect {|p| p.id.to_s == params[:issue][:project_id].to_s}
                   if @target_project
                     target_projects = [@target_project]
                     edited_issues.each {|issue| issue.project = @target_project}
                   end
                 end
                 target_projects ||= @projects
                 @trackers = target_projects.map {|p| Issue.allowed_target_trackers(p) }.reduce(:&)
                 if params[:issue]
                   @target_tracker = @trackers.detect {|t| t.id.to_s == params[:issue][:tracker_id].to_s}
                   if @target_tracker
                     edited_issues.each {|issue| issue.tracker = @target_tracker}
                   end
                 end
                 if @copy
                   # Copied issues will get their default statuses
                   @available_statuses = []
                 else
                   @available_statuses = edited_issues.map(&:new_statuses_allowed_to).reduce(:&)
                 end
                 if params[:issue]
                   @target_status = @available_statuses.detect {|t| t.id.to_s == params[:issue][:status_id].to_s}
                   if @target_status
                     edited_issues.each {|issue| issue.status = @target_status}
                   end
                 end
                 @custom_fields = edited_issues.map{|i|i.editable_custom_fields}.reduce(:&).select {|field| field.format.bulk_edit_supported}
                 @assignables = target_projects.map(&:assignable_users).reduce(:&)
                 @versions = target_projects.map {|p| p.shared_versions.open}.reduce(:&)
                 @categories = target_projects.map {|p| p.issue_categories}.reduce(:&)
                 if @copy
                   @attachments_present = @issues.detect {|i| i.attachments.any?}.present?
                   @subtasks_present = @issues.detect {|i| !i.leaf?}.present?
                 end
                 @safe_attributes = edited_issues.map(&:safe_attribute_names).reduce(:&)
                 @issue_params = params[:issue] || {}
                 @issue_params[:custom_field_values] ||= {}
               end
               def bulk_update
                 @issues.sort!
                 @copy = params[:copy].present?
                 attributes = parse_params_for_bulk_update(params[:issue])
                 copy_subtasks = (params[:copy_subtasks] == '1')
                 copy_attachments = (params[:copy_attachments] == '1')
                 if @copy
                   unless User.current.allowed_to?(:copy_issues, @projects)
                     raise ::Unauthorized
                   end
                   target_projects = @projects
                   if attributes['project_id'].present?
                     target_projects = Project.where(:id => attributes['project_id']).to_a
                   end
                   unless User.current.allowed_to?(:add_issues, target_projects)
                     raise ::Unauthorized
                   end
                 else
                   unless @issues.all?(&:attributes_editable?)
                     raise ::Unauthorized
                   end
                 end
                 unsaved_issues = []
                 saved_issues = []
                 if @copy && copy_subtasks
                   # Descendant issues will be copied with the parent task
                   # Don't copy them twice
                   @issues.reject! {|issue| @issues.detect {|other| issue.is_descendant_of?(other)}}
                 end
                 @issues.each do |orig_issue|
                   orig_issue.reload
                   if @copy
                     issue = orig_issue.copy({},
                       :attachments => copy_attachments,
                       :subtasks => copy_subtasks,
                       :link => link_copy?(params[:link_copy])
                     )
                   else
                     issue = orig_issue
                   end
                   journal = issue.init_journal(User.current, params[:notes])
                   issue.safe_attributes = attributes
                   call_hook(:controller_issues_bulk_edit_before_save, { :params => params, :issue => issue })
                   if issue.save
                     saved_issues << issue
                   else
                     unsaved_issues << orig_issue
                   end
                 end
                 if unsaved_issues.empty?
                   flash[:notice] = l(:notice_successful_update) unless saved_issues.empty?
                   if params[:follow]
                     if @issues.size == 1 && saved_issues.size == 1
                       redirect_to issue_path(saved_issues.first)
                     elsif saved_issues.map(&:project).uniq.size == 1
                       redirect_to project_issues_path(saved_issues.map(&:project).first)
                     end
                   else
                     redirect_back_or_default _project_issues_path(@project)
                   end
                 else
                   @saved_issues = @issues
                   @unsaved_issues = unsaved_issues
                   @issues = Issue.visible.where(:id => @unsaved_issues.map(&:id)).to_a
                   bulk_edit
                   render :action => 'bulk_edit'
                 end
               end
               def destroy
                 raise Unauthorized unless @issues.all?(&:deletable?)
                 # all issues and their descendants are about to be deleted
                 issues_and_descendants_ids = Issue.self_and_descendants(@issues).pluck(:id)
                 time_entries = TimeEntry.where(:issue_id => issues_and_descendants_ids)
                 @hours = time_entries.sum(:hours).to_f
                 if @hours > 0
                   case params[:todo]
                   when 'destroy'
                     # nothing to do
                   when 'nullify'
                     time_entries.update_all(:issue_id => nil)
                   when 'reassign'
                     reassign_to = @project && @project.issues.find_by_id(params[:reassign_to_id])
                     if reassign_to.nil?
                       flash.now[:error] = l(:error_issue_not_found_in_project)
                       return
                     elsif issues_and_descendants_ids.include?(reassign_to.id)
                       flash.now[:error] = l(:error_cannot_reassign_time_entries_to_an_issue_about_to_be_deleted)
                       return
                     else
                       time_entries.update_all(:issue_id => reassign_to.id, :project_id => reassign_to.project_id)
                     end
                   else
                     # display the destroy form if it's a user request
                     return unless api_request?
                   end
                 end
                 @issues.each do |issue|
                   begin
                     issue.reload.destroy
                   rescue ::ActiveRecord::RecordNotFound # raised by #reload if issue no longer exists
                     # nothing to do, issue was already deleted (eg. by a parent)
                   end
                 end
                 respond_to do |format|
                   format.html { redirect_back_or_default _project_issues_path(@project) }
                   format.api  { render_api_ok }
                 end
               end
               # Overrides Redmine::MenuManager::MenuController::ClassMethods for
               # when the "New issue" tab is enabled
               def current_menu_item
                 if Setting.new_item_menu_tab == '1' && [:new, :create].include?(action_name.to_sym)
                   :new_issue
                 else
                   super
                 end
               end
               private
               def retrieve_previous_and_next_issue_ids
                 if params[:prev_issue_id].present? || params[:next_issue_id].present?
                   @prev_issue_id = params[:prev_issue_id].presence.try(:to_i)
                   @next_issue_id = params[:next_issue_id].presence.try(:to_i)
                   @issue_position = params[:issue_position].presence.try(:to_i)
                   @issue_count = params[:issue_count].presence.try(:to_i)
                 else
                   retrieve_query_from_session
                   if @query
                     sort_init(@query.sort_criteria.empty? ? [['id', 'desc']] : @query.sort_criteria)
                     sort_update(@query.sortable_columns, 'issues_index_sort')
                     limit = 500
-                    issue_ids = @query.issue_ids(:order => sort_clause, :limit => (limit + 1), :include => [:assigned_to, :tracker, :priority, :category, :fixed_version])
+                    issue_ids = @query.issue_ids(:order => sort_clause, :limit => (limit + 1))
                     if (idx = issue_ids.index(@issue.id)) && idx < limit
                       if issue_ids.size < 500
                         @issue_position = idx + 1
                         @issue_count = issue_ids.size
                       end
                       @prev_issue_id = issue_ids[idx - 1] if idx > 0
                       @next_issue_id = issue_ids[idx + 1] if idx < (issue_ids.size - 1)
                     end
                   end
                 end
               end
               def previous_and_next_issue_ids_params
                 {
                   :prev_issue_id => params[:prev_issue_id],
                   :next_issue_id => params[:next_issue_id],
                   :issue_position => params[:issue_position],
                   :issue_count => params[:issue_count]
                 }.reject {|k,v| k.blank?}
               end
               # Used by #edit and #update to set some common instance variables
               # from the params
               def update_issue_from_params
                 @time_entry = TimeEntry.new(:issue => @issue, :project => @issue.project)
                 if params[:time_entry]
                   @time_entry.safe_attributes = params[:time_entry]
                 end
                 @issue.init_journal(User.current)
                 issue_attributes = params[:issue]
                 if issue_attributes && params[:conflict_resolution]
                   case params[:conflict_resolution]
                   when 'overwrite'
                     issue_attributes = issue_attributes.dup
                     issue_attributes.delete(:lock_version)
                   when 'add_notes'
                     issue_attributes = issue_attributes.slice(:notes, :private_notes)
                   when 'cancel'
                     redirect_to issue_path(@issue)
                     return false
                   end
                 end
                 @issue.safe_attributes = issue_attributes
                 @priorities = IssuePriority.active
                 @allowed_statuses = @issue.new_statuses_allowed_to(User.current)
                 true
               end
               # Used by #new and #create to build a new issue from the params
               # The new issue will be copied from an existing one if copy_from parameter is given
               def build_new_issue_from_params
                 @issue = Issue.new
                 if params[:copy_from]
                   begin
                     @issue.init_journal(User.current)
                     @copy_from = Issue.visible.find(params[:copy_from])
                     unless User.current.allowed_to?(:copy_issues, @copy_from.project)
                       raise ::Unauthorized
                     end
                     @link_copy = link_copy?(params[:link_copy]) || request.get?
                     @copy_attachments = params[:copy_attachments].present? || request.get?
                     @copy_subtasks = params[:copy_subtasks].present? || request.get?
                     @issue.copy_from(@copy_from, :attachments => @copy_attachments, :subtasks => @copy_subtasks, :link => @link_copy)
                     @issue.parent_issue_id = @copy_from.parent_id
                   rescue ActiveRecord::RecordNotFound
                     render_404
                     return
                   end
                 end
                 @issue.project = @project
                 if request.get?
                   @issue.project ||= @issue.allowed_target_projects.first
                 end
                 @issue.author ||= User.current
                 @issue.start_date ||= User.current.today if Setting.default_issue_start_date_to_creation_date?
                 attrs = (params[:issue] || {}).deep_dup
                 if action_name == 'new' && params[:was_default_status] == attrs[:status_id]
                   attrs.delete(:status_id)
                 end
                 if action_name == 'new' && params[:form_update_triggered_by] == 'issue_project_id'
                   # Discard submitted version when changing the project on the issue form
                   # so we can use the default version for the new project
                   attrs.delete(:fixed_version_id)
                 end
                 @issue.safe_attributes = attrs
                 if @issue.project
                   @issue.tracker ||= @issue.allowed_target_trackers.first
                   if @issue.tracker.nil?
                     if @issue.project.trackers.any?
                       # None of the project trackers is allowed to the user
                       render_error :message => l(:error_no_tracker_allowed_for_new_issue_in_project), :status => 403
                     else
                       # Project has no trackers
                       render_error l(:error_no_tracker_in_project)
                     end
                     return false
                   end
                   if @issue.status.nil?
                     render_error l(:error_no_default_issue_status)
                     return false
                   end
                 elsif request.get?
                   render_error :message => l(:error_no_projects_with_tracker_allowed_for_new_issue), :status => 403
                   return false
                 end
                 @priorities = IssuePriority.active
                 @allowed_statuses = @issue.new_statuses_allowed_to(User.current)
               end
               # Saves @issue and a time_entry from the parameters
               def save_issue_with_child_records
                 Issue.transaction do
                   if params[:time_entry] && (params[:time_entry][:hours].present? || params[:time_entry][:comments].present?) && User.current.allowed_to?(:log_time, @issue.project)
                     time_entry = @time_entry || TimeEntry.new
                     time_entry.project = @issue.project
                     time_entry.issue = @issue
                     time_entry.user = User.current
                     time_entry.spent_on = User.current.today
                     time_entry.attributes = params[:time_entry]
                     @issue.time_entries << time_entry
                   end
                   call_hook(:controller_issues_edit_before_save, { :params => params, :issue => @issue, :time_entry => time_entry, :journal => @issue.current_journal})
                   if @issue.save
                     call_hook(:controller_issues_edit_after_save, { :params => params, :issue => @issue, :time_entry => time_entry, :journal => @issue.current_journal})
                   else
                     raise ActiveRecord::Rollback
                   end
                 end
               end
               # Returns true if the issue copy should be linked
               # to the original issue
               def link_copy?(param)
                 case Setting.link_copied_issue
                 when 'yes'
                   true
                 when 'no'
                   false
                 when 'ask'
                   param == '1'
                 end
               end
               # Redirects user after a successful issue creation
               def redirect_after_create
                 if params[:continue]
                   attrs = {:tracker_id => @issue.tracker, :parent_issue_id => @issue.parent_issue_id}.reject {|k,v| v.nil?}
                   if params[:project_id]
                     redirect_to new_project_issue_path(@issue.project, :issue => attrs)
                   else
                     attrs.merge! :project_id => @issue.project_id
                     redirect_to new_issue_path(:issue => attrs)
                   end
                 else
                   redirect_to issue_path(@issue)
                 end
               end
             end

app/models/issue_query.rb +18 -3

             # Redmine - project management software
             # Copyright (C) 2006-2016  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 IssueQuery < Query
               self.queried_class = Issue
               self.view_permission = :view_issues
               self.available_columns = [
                 QueryColumn.new(:id, :sortable => "#{Issue.table_name}.id", :default_order => 'desc', :caption => '#', :frozen => true),
                 QueryColumn.new(:project, :sortable => "#{Project.table_name}.name", :groupable => true),
                 QueryColumn.new(:tracker, :sortable => "#{Tracker.table_name}.position", :groupable => true),
                 QueryColumn.new(:parent, :sortable => ["#{Issue.table_name}.root_id", "#{Issue.table_name}.lft ASC"], :default_order => 'desc', :caption => :field_parent_issue),
                 QueryColumn.new(:status, :sortable => "#{IssueStatus.table_name}.position", :groupable => true),
                 QueryColumn.new(:priority, :sortable => "#{IssuePriority.table_name}.position", :default_order => 'desc', :groupable => true),
                 QueryColumn.new(:subject, :sortable => "#{Issue.table_name}.subject"),
                 QueryColumn.new(:author, :sortable => lambda {User.fields_for_order_statement("authors")}, :groupable => true),
                 QueryColumn.new(:assigned_to, :sortable => lambda {User.fields_for_order_statement}, :groupable => true),
                 QueryColumn.new(:updated_on, :sortable => "#{Issue.table_name}.updated_on", :default_order => 'desc'),
                 QueryColumn.new(:category, :sortable => "#{IssueCategory.table_name}.name", :groupable => true),
                 QueryColumn.new(:fixed_version, :sortable => lambda {Version.fields_for_order_statement}, :groupable => true),
                 QueryColumn.new(:start_date, :sortable => "#{Issue.table_name}.start_date"),
                 QueryColumn.new(:due_date, :sortable => "#{Issue.table_name}.due_date"),
                 QueryColumn.new(:estimated_hours, :sortable => "#{Issue.table_name}.estimated_hours", :totalable => true),
                 QueryColumn.new(:total_estimated_hours,
                   :sortable => "COALESCE((SELECT SUM(estimated_hours) FROM #{Issue.table_name} subtasks" +
                     " WHERE subtasks.root_id = #{Issue.table_name}.root_id AND subtasks.lft >= #{Issue.table_name}.lft AND subtasks.rgt <= #{Issue.table_name}.rgt), 0)",
                   :default_order => 'desc'),
                 QueryColumn.new(:done_ratio, :sortable => "#{Issue.table_name}.done_ratio", :groupable => true),
                 QueryColumn.new(:created_on, :sortable => "#{Issue.table_name}.created_on", :default_order => 'desc'),
                 QueryColumn.new(:closed_on, :sortable => "#{Issue.table_name}.closed_on", :default_order => 'desc'),
                 QueryColumn.new(:relations, :caption => :label_related_issues),
                 QueryColumn.new(:description, :inline => false)
               ]
               def initialize(attributes=nil, *args)
                 super attributes
                 self.filters ||= { 'status_id' => {:operator => "o", :values => [""]} }
               end
               def draw_relations
                 r = options[:draw_relations]
                 r.nil? || r == '1'
               end
               def draw_relations=(arg)
                 options[:draw_relations] = (arg == '0' ? '0' : nil)
               end
               def draw_progress_line
                 r = options[:draw_progress_line]
                 r == '1'
               end
               def draw_progress_line=(arg)
                 options[:draw_progress_line] = (arg == '1' ? '1' : nil)
               end
               def build_from_params(params)
                 super
                 self.draw_relations = params[:draw_relations] || (params[:query] && params[:query][:draw_relations])
                 self.draw_progress_line = params[:draw_progress_line] || (params[:query] && params[:query][:draw_progress_line])
                 self
               end
               def initialize_available_filters
                 add_available_filter "status_id",
                   :type => :list_status, :values => lambda { IssueStatus.sorted.collect{|s| [s.name, s.id.to_s] } }
                 add_available_filter("project_id",
                   :type => :list, :values => lambda { project_values }
                 ) if project.nil?
                 add_available_filter "tracker_id",
                   :type => :list, :values => trackers.collect{|s| [s.name, s.id.to_s] }
                 add_available_filter "priority_id",
                   :type => :list, :values => IssuePriority.all.collect{|s| [s.name, s.id.to_s] }
                 add_available_filter("author_id",
                   :type => :list, :values => lambda { author_values }
                 )
                 add_available_filter("assigned_to_id",
                   :type => :list_optional, :values => lambda { assigned_to_values }
                 )
                 add_available_filter("member_of_group",
                   :type => :list_optional, :values => lambda { Group.givable.visible.collect {|g| [g.name, g.id.to_s] } }
                 )
                 add_available_filter("assigned_to_role",
                   :type => :list_optional, :values => lambda { Role.givable.collect {|r| [r.name, r.id.to_s] } }
                 )
                 add_available_filter "fixed_version_id",
                   :type => :list_optional, :values => lambda { fixed_version_values }
                 add_available_filter "fixed_version.due_date",
                   :type => :date,
                   :name => l(:label_attribute_of_fixed_version, :name => l(:field_effective_date))
                 add_available_filter "fixed_version.status",
                   :type => :list,
                   :name => l(:label_attribute_of_fixed_version, :name => l(:field_status)),
                   :values => Version::VERSION_STATUSES.map{|s| [l("version_status_#{s}"), s] }
                 add_available_filter "category_id",
                   :type => :list_optional,
                   :values => lambda { project.issue_categories.collect{|s| [s.name, s.id.to_s] } } if project
                 add_available_filter "subject", :type => :text
                 add_available_filter "description", :type => :text
                 add_available_filter "created_on", :type => :date_past
                 add_available_filter "updated_on", :type => :date_past
                 add_available_filter "closed_on", :type => :date_past
                 add_available_filter "start_date", :type => :date
                 add_available_filter "due_date", :type => :date
                 add_available_filter "estimated_hours", :type => :float
                 add_available_filter "done_ratio", :type => :integer
                 if User.current.allowed_to?(:set_issues_private, nil, :global => true) ||
                   User.current.allowed_to?(:set_own_issues_private, nil, :global => true)
                   add_available_filter "is_private",
                     :type => :list,
                     :values => [[l(:general_text_yes), "1"], [l(:general_text_no), "0"]]
                 end
                 if User.current.logged?
                   add_available_filter "watcher_id",
                     :type => :list, :values => [["<< #{l(:label_me)} >>", "me"]]
                 end
                 if project && !project.leaf?
                   add_available_filter "subproject_id",
                     :type => :list_subprojects,
                     :values => lambda { subproject_values }
                 end
                 issue_custom_fields = project ? project.all_issue_custom_fields : IssueCustomField.where(:is_for_all => true)
                 add_custom_fields_filters(issue_custom_fields)
                 add_associations_custom_fields_filters :project, :author, :assigned_to, :fixed_version
                 IssueRelation::TYPES.each do |relation_type, options|
                   add_available_filter relation_type, :type => :relation, :label => options[:name], :values => lambda {all_projects_values}
                 end
                 add_available_filter "parent_id", :type => :tree, :label => :field_parent_issue
                 add_available_filter "child_id", :type => :tree, :label => :label_subtask_plural
                 add_available_filter "issue_id", :type => :integer, :label => :label_issue
                 Tracker.disabled_core_fields(trackers).each {|field|
                   delete_available_filter field
                 }
               end
               def available_columns
                 return @available_columns if @available_columns
                 @available_columns = self.class.available_columns.dup
                 @available_columns += (project ?
                                         project.all_issue_custom_fields :
                                         IssueCustomField
                                        ).visible.collect {|cf| QueryCustomFieldColumn.new(cf) }
                 if User.current.allowed_to?(:view_time_entries, project, :global => true)
                   index = @available_columns.find_index {|column| column.name == :total_estimated_hours}
                   index = (index ? index + 1 : -1)
                   # insert the column after total_estimated_hours or at the end
                   @available_columns.insert index, QueryColumn.new(:spent_hours,
                     :sortable => "COALESCE((SELECT SUM(hours) FROM #{TimeEntry.table_name} WHERE #{TimeEntry.table_name}.issue_id = #{Issue.table_name}.id), 0)",
                     :default_order => 'desc',
                     :caption => :label_spent_time,
                     :totalable => true
                   )
                   @available_columns.insert index+1, QueryColumn.new(:total_spent_hours,
                     :sortable => "COALESCE((SELECT SUM(hours) FROM #{TimeEntry.table_name} JOIN #{Issue.table_name} subtasks ON subtasks.id = #{TimeEntry.table_name}.issue_id" +
                       " WHERE subtasks.root_id = #{Issue.table_name}.root_id AND subtasks.lft >= #{Issue.table_name}.lft AND subtasks.rgt <= #{Issue.table_name}.rgt), 0)",
                     :default_order => 'desc',
                     :caption => :label_total_spent_time
                   )
                 end
                 if User.current.allowed_to?(:set_issues_private, nil, :global => true) ||
                   User.current.allowed_to?(:set_own_issues_private, nil, :global => true)
                   @available_columns << QueryColumn.new(:is_private, :sortable => "#{Issue.table_name}.is_private")
                 end
                 disabled_fields = Tracker.disabled_core_fields(trackers).map {|field| field.sub(/_id$/, '')}
                 @available_columns.reject! {|column|
                   disabled_fields.include?(column.name.to_s)
                 }
                 @available_columns
               end
               def default_columns_names
                 @default_columns_names ||= begin
                   default_columns = Setting.issue_list_default_columns.map(&:to_sym)
                   project.present? ? default_columns : [:project] | default_columns
                 end
               end
               def default_totalable_names
                 Setting.issue_list_default_totals.map(&:to_sym)
               end
               def base_scope
                 Issue.visible.joins(:status, :project).where(statement)
               end
               # Returns the issue count
               def issue_count
                 base_scope.count
               rescue ::ActiveRecord::StatementInvalid => e
                 raise StatementInvalid.new(e.message)
               end
               # Returns the issue count by group or nil if query is not grouped
               def issue_count_by_group
                 grouped_query do |scope|
                   scope.count
                 end
               end
               # Returns sum of all the issue's estimated_hours
               def total_for_estimated_hours(scope)
                 map_total(scope.sum(:estimated_hours)) {|t| t.to_f.round(2)}
               end
               # Returns sum of all the issue's time entries hours
               def total_for_spent_hours(scope)
                 total = if group_by_column.try(:name) == :project
                   # TODO: remove this when https://github.com/rails/rails/issues/21922 is fixed
                   # We have to do a custom join without the time_entries.project_id column
                   # that would trigger a ambiguous column name error
                   scope.joins("JOIN (SELECT issue_id, hours FROM #{TimeEntry.table_name}) AS joined_time_entries ON joined_time_entries.issue_id = #{Issue.table_name}.id").
                     sum("joined_time_entries.hours")
                 else
                   scope.joins(:time_entries).sum("#{TimeEntry.table_name}.hours")
                 end
                 map_total(total) {|t| t.to_f.round(2)}
               end
               # Returns the issues
               # Valid options are :order, :offset, :limit, :include, :conditions
               def issues(options={})
                 order_option = [group_by_sort_order, options[:order]].flatten.reject(&:blank?)
                 scope = Issue.visible.
                   joins(:status, :project).
                   where(statement).
                   includes(([:status, :project] + (options[:include] || [])).uniq).
                   where(options[:conditions]).
                   order(order_option).
                   joins(joins_for_order_statement(order_option.join(','))).
                   limit(options[:limit]).
                   offset(options[:offset])
-                scope = scope.preload(:custom_values)
+                scope = scope.preload([:tracker, :priority, :author, :assigned_to, :fixed_version, :category] & columns.map(&:name))
-                if has_column?(:author)
+                if has_custom_field_column?
-                  scope = scope.preload(:author)
+                  scope = scope.preload(:custom_values)
                 end
                 issues = scope.to_a
                 if has_column?(:spent_hours)
                   Issue.load_visible_spent_hours(issues)
                 end
                 if has_column?(:total_spent_hours)
                   Issue.load_visible_total_spent_hours(issues)
                 end
                 if has_column?(:relations)
                   Issue.load_visible_relations(issues)
                 end
                 issues
               rescue ::ActiveRecord::StatementInvalid => e
                 raise StatementInvalid.new(e.message)
               end
               # Returns the issues ids
               def issue_ids(options={})
                 order_option = [group_by_sort_order, options[:order]].flatten.reject(&:blank?)
                 Issue.visible.
                   joins(:status, :project).
                   where(statement).
                   includes(([:status, :project] + (options[:include] || [])).uniq).
                   references(([:status, :project] + (options[:include] || [])).uniq).
                   where(options[:conditions]).
                   order(order_option).
                   joins(joins_for_order_statement(order_option.join(','))).
                   limit(options[:limit]).
                   offset(options[:offset]).
                   pluck(:id)
               rescue ::ActiveRecord::StatementInvalid => e
                 raise StatementInvalid.new(e.message)
               end
               # Returns the journals
               # Valid options are :order, :offset, :limit
               def journals(options={})
                 Journal.visible.
                   joins(:issue => [:project, :status]).
                   where(statement).
                   order(options[:order]).
                   limit(options[:limit]).
                   offset(options[:offset]).
                   preload(:details, :user, {:issue => [:project, :author, :tracker, :status]}).
                   to_a
               rescue ::ActiveRecord::StatementInvalid => e
                 raise StatementInvalid.new(e.message)
               end
               # Returns the versions
               # Valid options are :conditions
               def versions(options={})
                 Version.visible.
                   where(project_statement).
                   where(options[:conditions]).
                   includes(:project).
                   references(:project).
                   to_a
               rescue ::ActiveRecord::StatementInvalid => e
                 raise StatementInvalid.new(e.message)
               end
               def sql_for_watcher_id_field(field, operator, value)
                 db_table = Watcher.table_name
                 "#{Issue.table_name}.id #{ operator == '=' ? 'IN' : 'NOT IN' } (SELECT #{db_table}.watchable_id FROM #{db_table} WHERE #{db_table}.watchable_type='Issue' AND " +
                   sql_for_field(field, '=', value, db_table, 'user_id') + ')'
               end
               def sql_for_member_of_group_field(field, operator, value)
                 if operator == '*' # Any group
                   groups = Group.givable
                   operator = '=' # Override the operator since we want to find by assigned_to
                 elsif operator == "!*"
                   groups = Group.givable
                   operator = '!' # Override the operator since we want to find by assigned_to
                 else
                   groups = Group.where(:id => value).to_a
                 end
                 groups ||= []
                 members_of_groups = groups.inject([]) {|user_ids, group|
                   user_ids + group.user_ids + [group.id]
                 }.uniq.compact.sort.collect(&:to_s)
                 '(' + sql_for_field("assigned_to_id", operator, members_of_groups, Issue.table_name, "assigned_to_id", false) + ')'
               end
               def sql_for_assigned_to_role_field(field, operator, value)
                 case operator
                 when "*", "!*" # Member / Not member
                   sw = operator == "!*" ? 'NOT' : ''
                   nl = operator == "!*" ? "#{Issue.table_name}.assigned_to_id IS NULL OR" : ''
                   "(#{nl} #{Issue.table_name}.assigned_to_id #{sw} IN (SELECT DISTINCT #{Member.table_name}.user_id FROM #{Member.table_name}" +
                     " WHERE #{Member.table_name}.project_id = #{Issue.table_name}.project_id))"
                 when "=", "!"
                   role_cond = value.any? ?
                     "#{MemberRole.table_name}.role_id IN (" + value.collect{|val| "'#{self.class.connection.quote_string(val)}'"}.join(",") + ")" :
                     "1=0"
                   sw = operator == "!" ? 'NOT' : ''
                   nl = operator == "!" ? "#{Issue.table_name}.assigned_to_id IS NULL OR" : ''
                   "(#{nl} #{Issue.table_name}.assigned_to_id #{sw} IN (SELECT DISTINCT #{Member.table_name}.user_id FROM #{Member.table_name}, #{MemberRole.table_name}" +
                     " WHERE #{Member.table_name}.project_id = #{Issue.table_name}.project_id AND #{Member.table_name}.id = #{MemberRole.table_name}.member_id AND #{role_cond}))"
                 end
               end
               def sql_for_fixed_version_status_field(field, operator, value)
                 where = sql_for_field(field, operator, value, Version.table_name, "status")
                 version_ids = versions(:conditions => [where]).map(&:id)
                 nl = operator == "!" ? "#{Issue.table_name}.fixed_version_id IS NULL OR" : ''
                 "(#{nl} #{sql_for_field("fixed_version_id", "=", version_ids, Issue.table_name, "fixed_version_id")})"
               end
               def sql_for_fixed_version_due_date_field(field, operator, value)
                 where = sql_for_field(field, operator, value, Version.table_name, "effective_date")
                 version_ids = versions(:conditions => [where]).map(&:id)
                 nl = operator == "!*" ? "#{Issue.table_name}.fixed_version_id IS NULL OR" : ''
                 "(#{nl} #{sql_for_field("fixed_version_id", "=", version_ids, Issue.table_name, "fixed_version_id")})"
               end
               def sql_for_is_private_field(field, operator, value)
                 op = (operator == "=" ? 'IN' : 'NOT IN')
                 va = value.map {|v| v == '0' ? self.class.connection.quoted_false : self.class.connection.quoted_true}.uniq.join(',')
                 "#{Issue.table_name}.is_private #{op} (#{va})"
               end
               def sql_for_parent_id_field(field, operator, value)
                 case operator
                 when "="
                   "#{Issue.table_name}.parent_id = #{value.first.to_i}"
                 when "~"
                   root_id, lft, rgt = Issue.where(:id => value.first.to_i).pluck(:root_id, :lft, :rgt).first
                   if root_id && lft && rgt
                     "#{Issue.table_name}.root_id = #{root_id} AND #{Issue.table_name}.lft > #{lft} AND #{Issue.table_name}.rgt < #{rgt}"
                   else
                     "1=0"
                   end
                 when "!*"
                   "#{Issue.table_name}.parent_id IS NULL"
                 when "*"
                   "#{Issue.table_name}.parent_id IS NOT NULL"
                 end
               end
               def sql_for_child_id_field(field, operator, value)
                 case operator
                 when "="
                   parent_id = Issue.where(:id => value.first.to_i).pluck(:parent_id).first
                   if parent_id
                     "#{Issue.table_name}.id = #{parent_id}"
                   else
                     "1=0"
                   end
                 when "~"
                   root_id, lft, rgt = Issue.where(:id => value.first.to_i).pluck(:root_id, :lft, :rgt).first
                   if root_id && lft && rgt
                     "#{Issue.table_name}.root_id = #{root_id} AND #{Issue.table_name}.lft < #{lft} AND #{Issue.table_name}.rgt > #{rgt}"
                   else
                     "1=0"
                   end
                 when "!*"
                   "#{Issue.table_name}.rgt - #{Issue.table_name}.lft = 1"
                 when "*"
                   "#{Issue.table_name}.rgt - #{Issue.table_name}.lft > 1"
                 end
               end
               def sql_for_issue_id_field(field, operator, value)
                 if operator == "="
                   # accepts a comma separated list of ids
                   ids = value.first.to_s.scan(/\d+/).map(&:to_i)
                   if ids.present?
                     "#{Issue.table_name}.id IN (#{ids.join(",")})"
                   else
                     "1=0"
                   end
                 else
                   sql_for_field("id", operator, value, Issue.table_name, "id")
                 end
               end
               def sql_for_relations(field, operator, value, options={})
                 relation_options = IssueRelation::TYPES[field]
                 return relation_options unless relation_options
                 relation_type = field
                 join_column, target_join_column = "issue_from_id", "issue_to_id"
                 if relation_options[:reverse] || options[:reverse]
                   relation_type = relation_options[:reverse] || relation_type
                   join_column, target_join_column = target_join_column, join_column
                 end
                 sql = case operator
                   when "*", "!*"
                     op = (operator == "*" ? 'IN' : 'NOT IN')
                     "#{Issue.table_name}.id #{op} (SELECT DISTINCT #{IssueRelation.table_name}.#{join_column} FROM #{IssueRelation.table_name} WHERE #{IssueRelation.table_name}.relation_type = '#{self.class.connection.quote_string(relation_type)}')"
                   when "=", "!"
                     op = (operator == "=" ? 'IN' : 'NOT IN')
                     "#{Issue.table_name}.id #{op} (SELECT DISTINCT #{IssueRelation.table_name}.#{join_column} FROM #{IssueRelation.table_name} WHERE #{IssueRelation.table_name}.relation_type = '#{self.class.connection.quote_string(relation_type)}' AND #{IssueRelation.table_name}.#{target_join_column} = #{value.first.to_i})"
                   when "=p", "=!p", "!p"
                     op = (operator == "!p" ? 'NOT IN' : 'IN')
                     comp = (operator == "=!p" ? '<>' : '=')
                     "#{Issue.table_name}.id #{op} (SELECT DISTINCT #{IssueRelation.table_name}.#{join_column} FROM #{IssueRelation.table_name}, #{Issue.table_name} relissues WHERE #{IssueRelation.table_name}.relation_type = '#{self.class.connection.quote_string(relation_type)}' AND #{IssueRelation.table_name}.#{target_join_column} = relissues.id AND relissues.project_id #{comp} #{value.first.to_i})"
                   when "*o", "!o"
                     op = (operator == "!o" ? 'NOT IN' : 'IN')
                     "#{Issue.table_name}.id #{op} (SELECT DISTINCT #{IssueRelation.table_name}.#{join_column} FROM #{IssueRelation.table_name}, #{Issue.table_name} relissues WHERE #{IssueRelation.table_name}.relation_type = '#{self.class.connection.quote_string(relation_type)}' AND #{IssueRelation.table_name}.#{target_join_column} = relissues.id AND relissues.status_id IN (SELECT id FROM #{IssueStatus.table_name} WHERE is_closed=#{self.class.connection.quoted_false}))"
                   end
                 if relation_options[:sym] == field && !options[:reverse]
                   sqls = [sql, sql_for_relations(field, operator, value, :reverse => true)]
                   sql = sqls.join(["!", "!*", "!p"].include?(operator) ? " AND " : " OR ")
                 end
                 "(#{sql})"
               end
               def find_assigned_to_id_filter_values(values)
                 Principal.visible.where(:id => values).map {|p| [p.name, p.id.to_s]}
               end
               alias :find_author_id_filter_values :find_assigned_to_id_filter_values
               IssueRelation::TYPES.keys.each do |relation_type|
                 alias_method "sql_for_#{relation_type}_field".to_sym, :sql_for_relations
               end
               def joins_for_order_statement(order_options)
                 joins = [super]
                 if order_options
                   if order_options.include?('authors')
                     joins << "LEFT OUTER JOIN #{User.table_name} authors ON authors.id = #{queried_table_name}.author_id"
                   end
+                  if order_options.include?('users')
+                    joins << "LEFT OUTER JOIN #{User.table_name} ON #{User.table_name}.id = #{queried_table_name}.assigned_to_id"
+                  end
+                  if order_options.include?('fixed_version')
+                    joins << "LEFT OUTER JOIN #{Version.table_name} ON #{Version.table_name}.id = #{queried_table_name}.fixed_version_id"
+                  end
+                  if order_options.include?('category')
+                    joins << "LEFT OUTER JOIN #{IssueCategory.table_name} ON #{IssueCategory.table_name}.id = #{queried_table_name}.category_id"
+                  end
+                  if order_options.include?('tracker')
+                    joins << "LEFT OUTER JOIN #{Tracker.table_name} ON #{Tracker.table_name}.id = #{queried_table_name}.tracker_id"
+                  end
+                  if order_options.include?('enumeration')
+                    joins << "LEFT OUTER JOIN #{IssuePriority.table_name} ON #{IssuePriority.table_name}.id = #{queried_table_name}.priority_id"
+                  end
                 end
                 joins.any? ? joins.join(' ') : nil
               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