Redmine

  def project_statement(db_table)

    if valid?

      if project

        if !project.descendants.active.empty?

          if has_filter?('subproject_id')

            case operator_for('subproject_id')

            when '='

              # include the selected subprojects

              ids = values_for('subproject_id').each(&:to_i)

            when '!*'

              # main project only

              ids = [project.id]

            else

              # all subprojects

              ids = project.descendants.collect(&:id)

            end

          else

            ids = [project.id]

            ids << project.descendants.collect(&:id) if Setting.display_subprojects_issues?

          end

          project_clauses << "#{Project.table_name}.id IN (%s)" % ids.join(',')

          project_clauses << "#{Project.table_name}.id = %d" % project.id

      elsif has_filter?('project_id')

        # project filter

        db_field = db_table == Project.table_name ? 'id' : 'project_id'

        project_clauses << '(' + sql_for_field('project_id', operator_for('project_id'), values_for('project_id').each(&:to_i), db_table, db_field) + ')'

      next if ['subproject_id', 'project_id'].include?(field)

    (filters_clauses << project_statement(Issue.table_name)).join(' AND ')

                       :conditions => Query.merge_conditions(project_statement(Version.table_name), options[:conditions])

      ### Extracted from the HTML view/helpers

        @number_of_rows

        options[:render_issues_without_version_first] = true unless options.key? :render_issues_without_version_first

        options[:top] = 0 unless options.key? :top

        options[:indent_increment] = 20 unless options.key? :indent_increment

        options[:top_increment] = 20 unless options.key? :top_increment

        options[:gantt_indent] = options[:indent]

        # We sort by project.lft so that projects are listed before their children

        top_projects = Project.find( :all,

          :conditions => @query.project_statement(Project.table_name),

          :order => ["#{Project.table_name}.lft ASC"])

        # Purge descendants to be sure to have only top projects left

        prev_top = nil

        top_projects.delete_if do |top|

          remove_descendant = prev_top && top.is_descendant_of?(prev_top)

          prev_top = top

          remove_descendant

        end

        # Get issues with theirs versions and subprojects as filtered by query criterias

        issues = Issue.find(

          :all,

          :include => [:tracker, :status, :assigned_to, :priority, :project, :fixed_version],

          :conditions => @query.statement,

          :joins => [

            "LEFT OUTER JOIN #{Project.table_name} AS top_project ON top_project.id IN (#{top_projects.collect(&:id).join(', ')}) AND top_project.lft <= #{Project.table_name}.lft AND top_project.rgt >= #{Project.table_name}.rgt " + # Top project

            "LEFT OUTER JOIN #{Project.table_name} AS version_project ON version_project.id = #{Version.table_name}.project_id " + # Project of the fixed version

            "LEFT OUTER JOIN #{Project.table_name} AS version_top_project ON " +

                    "(version_top_project.id = #{Project.table_name}.id AND #{Version.table_name}.sharing = 'none')" +

                " OR (version_top_project.id = top_project.id AND #{Version.table_name}.sharing IN ('hierarchy', 'system', 'tree'))" +

                " OR (version_top_project.id = CASE WHEN top_project.lft < version_project.lft THEN version_project.id ELSE top_project.id END AND #{Version.table_name}.sharing = 'descendants')"], 

          :order => [

            "top_project.lft ASC, top_project.name ASC, " + # Top project

            "COALESCE(version_top_project.lft, #{Project.table_name}.lft) ASC, " + # Version top project or project if none

            "CASE WHEN #{Issue.table_name}.fixed_version_id IS NULL THEN #{ options[:render_issues_without_version_first] ? '0 ELSE 1' : '1 ELSE 0' } END ASC, " + # Issues without version first (or last)

            "CASE WHEN #{Version.table_name}.effective_date IS NULL THEN 0 ELSE 1 END DESC, " + # Version with effective_date first

            "#{Version.table_name}.effective_date ASC, #{Version.table_name}.name ASC, " +

            "#{Project.table_name}.lft ASC"] )

        # TODO : at this point we could have been returned 3 extra Project objects useful for building project path : top_project, version_project and top_version_project

        # There is no way ActiveRecord can map sql query results to more than one model (hibernate does), so we have to compute them again in update_and_render_project_path(), adding a dummy time & cpu overhead to the whole rendering process

        # Idea : use an IssueForGantt class with association to issue, top_project, version_project and top_version_project ?

        prev_issue = nil

        path_issues = []

        # TODO : use a Hash rather than an Array when switching to Ruby 1.9, as Hash is ordered in 1.9

        issue_path = []

        # Render Gantt by looping on issues

        issues.each do |i|

          # Stack issues within the same project path to allow them to be sorted before rendering

          if prev_issue && (

                prev_issue.project != i.project ||

                prev_issue.fixed_version != i.fixed_version)

            render_path_issues(path_issues, options) unless path_issues.empty?

            path_issues.clear

          issue_path = update_and_render_project_path(top_projects, i, prev_issue, issue_path, options)

          break if abort?

          path_issues << i

          prev_issue = i

        render_path_issues(path_issues, options) unless abort?

      # Renders issues in a version/project path

      def render_path_issues(issues, options)

        sort_issues! issues

        base_indent = options[:indent]

        prev_issue = nil

        issue_hierarchy = []

        issues.each do |i|

          # Indent issue hierarchy (issue in the same hierarchy tree should follow thanks to the sorting order)

          ancestor_idx = -1

          (issue_hierarchy.length - 1).downto(0) do |h_i|

            if issue_hierarchy[h_i].is_ancestor_of?(i)

              ancestor_idx = h_i

              break

            end

          end

          issue_hierarchy.slice!((ancestor_idx + 1)..-1)

          issue_hierarchy << i

          options[:indent] = base_indent + (issue_hierarchy.length - 1) * options[:indent_increment]

          # Render issue node

          options[:top] += options[:top_increment]

          prev_issue = i

      def update_and_render_project_path(top_projects, i, prev_issue, issue_path, options)

        prev_version = prev_issue.nil? ? nil : prev_issue.fixed_version

        project_change = prev_issue.nil? || i.project != prev_issue.project

        first_item_to_render_idx = nil

        # Render the project path to the project the issue belongs to

        if project_change

          top_project = issue_path.empty? ? nil : issue_path.first 

          # Remove invalid path queue

          if top_project.nil? || !i.project.is_or_is_descendant_of?(top_project)

            # New branch

            top_project = top_projects.detect { |p| p.is_or_is_ancestor_of?(i.project) }

            top_projects.delete(top_project) # Lighten the top_projects map as a top project should not be rendered twice 

            issue_path = [top_project]

            first_item_to_render_idx = 0

            prev_version = nil

          elsif !prev_issue.nil? && !i.project.is_descendant_of?(prev_issue.project)

            # Truncate actual path (in any way, we keep the top project node)

            # TODO : use index { } with Ruby 1.8.7+

            first_distinct_project_idx = nil

            1.upto(issue_path.length - 1) do |pi_idx|

              if issue_path[pi_idx].is_a?(Project) && !issue_path[pi_idx].is_ancestor_of?(i.project)

                first_distinct_project_idx = pi_idx

                break

              end

            end

            issue_path.slice!(first_distinct_project_idx..-1)

          end

          # TODO : use rindex { } with Ruby 1.9

          last_common_project_idx = nil

          (issue_path.length - 1).downto(0) do |pi_idx|

            if issue_path[pi_idx].is_a?(Project)

              last_common_project_idx = pi_idx

              break

            end

          end

          # Complete path

          rpath_queue = []

          subproject = i.project

          until subproject == issue_path.at(last_common_project_idx)

            rpath_queue << subproject

            subproject = subproject.parent

          end

          unless rpath_queue.empty?

            first_item_to_render_idx = issue_path.length if first_item_to_render_idx.nil?

            issue_path += rpath_queue.reverse 

          end

        end

        version_change = i.fixed_version != prev_version

        if version_change

          # Remove previous Version node from path

          unless prev_version.nil?

            prev_version_idx = issue_path.index(prev_version)

            unless prev_version_idx.nil? # May have been removed with the project path truncation

              issue_path.delete_at(prev_version_idx)

              first_item_to_render_idx = prev_version_idx if prev_version_idx < issue_path.length || (!first_item_to_render_idx.nil? && prev_version_idx < first_item_to_render_idx)

            end

          end

          # Place new Version node within the path

          unless i.fixed_version.nil?

            # TODO : use index { } with Ruby 1.8.7+

            new_version_idx = nil

            0.upto(issue_path.length - 1) do |pi_idx|

              # TODO : p.shared_versions() can slow down rendering, maybe add a has_shared_version?(v) in Project ?

              if issue_path[pi_idx].shared_versions.include?(i.fixed_version)

                new_version_idx = pi_idx + 1

                break

              end

            end

            issue_path.insert(new_version_idx, i.fixed_version)

            first_item_to_render_idx = new_version_idx if first_item_to_render_idx.nil? || new_version_idx < first_item_to_render_idx

          end

        end

        # Render new path part

        unless first_item_to_render_idx.nil?

          options[:indent] = options[:gantt_indent] + first_item_to_render_idx * options[:indent_increment]

          issue_path.slice(first_item_to_render_idx..-1).each do |pi|

            if pi.is_a?(Version)

              # Render version node

              render_version(pi, options)

            else

              # Render project node

              render_subproject(pi, options)

            end

            break if abort?

            options[:indent] += options[:indent_increment]

            options[:top] += options[:top_increment]

          end

        else

          options[:indent] = options[:gantt_indent] + issue_path.length * options[:indent_increment]

        end

        issue_path

      end

      def render_subproject(subproject, options={})

        # Subproject header

        subject_for_project(subproject, options) unless options[:only] == :lines

        line_for_project(subproject, options) unless options[:only] == :subjects

        @number_of_rows += 1

      end

        g_height = 20 * 5 + 30

        width = subject_width+g_width+1

        imgl.new_image(width, height)

        g_height = 20 * number_of_rows + 30

        height = g_height + headers_heigth

        imgl.last.resize!(width, height)

        end

      # Sorts a collection of issues for gantt rendering

        issues.sort! { |a, b| gantt_issue_compare(a, b) }

      # Compare issues for rendering order 

      def gantt_issue_compare(x, y)

        if x.parent_id == y.parent_id

          # Same level in issue hierarchy

          basic_gantt_issue_compare(x, y)

        elsif x.root_id == y.root_id || x.root_id == y.id || y.root_id == x.id

          # Same issue hierarchy

          # Distinct hierarchies

          # TODO : advanced sort between issues when ancestors have been filtered out by query

      def basic_gantt_issue_compare(x, y)

        if x.start_date == y.start_date

          x.id <=> y.id

        elsif x.start_date.nil?

          1 # null date appears at the end

        elsif y.start_date.nil?

          -1

        else

          x.start_date <=> y.start_date

        end

      end