jro_apps/redmine Commit - r10888:601148c5b11d

Show precedes/follows and blocks/blocked relations on the Gantt diagram (#3436)....

Jean-Philippe Lang -

r10888:601148c5b11d

parent child

Context file:

r10888:601148c5b11d

Collapse all files

public/javascripts/gantt.js created 644 +114 0

@@ -0,0 +1,114
	1	var draw_gantt = null;
	2	var draw_top;
	3	var draw_right;
	4	var draw_left;
	5
	6	var rels_stroke_width = 2;
	7
	8	function setDrawArea() {
	9	draw_top = $("#gantt_draw_area").position().top;
	10	draw_right = $("#gantt_draw_area").width();
	11	draw_left = $("#gantt_area").scrollLeft();
	12	}
	13
	14	function getRelationsArray() {
	15	var arr = new Array();
	16	$.each($('div.task_todo'), function(index_div, element) {
	17	var element_id = $(element).attr("id");
	18	if (element_id != null) {
	19	var issue_id = element_id.replace("task-todo-issue-", "");
	20	var data_rels = $(element).data("rels");
	21	if (data_rels != null) {
	22	for (rel_type_key in issue_relation_type) {
	23	if (rel_type_key in data_rels) {
	24	var issue_arr = data_rels[rel_type_key].toString().split(",");
	25	$.each(issue_arr, function(index_issue, element_issue) {
	26	arr.push({issue_from: issue_id, issue_to: element_issue,
	27	rel_type: rel_type_key});
	28	});
	29	}
	30	}
	31	}
	32	}
	33	});
	34	return arr;
	35	}
	36
	37	function drawRelations() {
	38	var arr = getRelationsArray();
	39	$.each(arr, function(index_issue, element_issue) {
	40	var issue_from = $("#task-todo-issue-" + element_issue["issue_from"]);
	41	var issue_to = $("#task-todo-issue-" + element_issue["issue_to"]);
	42	if (issue_from.size() == 0 \|\| issue_to.size() == 0) {
	43	return;
	44	}
	45	var issue_height = issue_from.height();
	46	var issue_from_top = issue_from.position().top + (issue_height / 2) - draw_top;
	47	var issue_from_right = issue_from.position().left + issue_from.width();
	48	var issue_to_top = issue_to.position().top + (issue_height / 2) - draw_top;
	49	var issue_to_left = issue_to.position().left;
	50	var color = issue_relation_type[element_issue["rel_type"]]["color"];
	51	var landscape_margin = issue_relation_type[element_issue["rel_type"]]["landscape_margin"];
	52	var issue_from_right_rel = issue_from_right + landscape_margin;
	53	var issue_to_left_rel = issue_to_left - landscape_margin;
	54	draw_gantt.path(["M", issue_from_right + draw_left, issue_from_top,
	55	"L", issue_from_right_rel + draw_left, issue_from_top])
	56	.attr({stroke: color,
	57	"stroke-width": rels_stroke_width
	58	});
	59	if (issue_from_right_rel < issue_to_left_rel) {
	60	draw_gantt.path(["M", issue_from_right_rel + draw_left, issue_from_top,
	61	"L", issue_from_right_rel + draw_left, issue_to_top])
	62	.attr({stroke: color,
	63	"stroke-width": rels_stroke_width
	64	});
	65	draw_gantt.path(["M", issue_from_right_rel + draw_left, issue_to_top,
	66	"L", issue_to_left + draw_left, issue_to_top])
	67	.attr({stroke: color,
	68	"stroke-width": rels_stroke_width
	69	});
	70	} else {
	71	var issue_middle_top = issue_to_top +
	72	(issue_height *
	73	((issue_from_top > issue_to_top) ? 1 : -1));
	74	draw_gantt.path(["M", issue_from_right_rel + draw_left, issue_from_top,
	75	"L", issue_from_right_rel + draw_left, issue_middle_top])
	76	.attr({stroke: color,
	77	"stroke-width": rels_stroke_width
	78	});
	79	draw_gantt.path(["M", issue_from_right_rel + draw_left, issue_middle_top,
	80	"L", issue_to_left_rel + draw_left, issue_middle_top])
	81	.attr({stroke: color,
	82	"stroke-width": rels_stroke_width
	83	});
	84	draw_gantt.path(["M", issue_to_left_rel + draw_left, issue_middle_top,
	85	"L", issue_to_left_rel + draw_left, issue_to_top])
	86	.attr({stroke: color,
	87	"stroke-width": rels_stroke_width
	88	});
	89	draw_gantt.path(["M", issue_to_left_rel + draw_left, issue_to_top,
	90	"L", issue_to_left + draw_left, issue_to_top])
	91	.attr({stroke: color,
	92	"stroke-width": rels_stroke_width
	93	});
	94	}
	95	draw_gantt.path(["M", issue_to_left + draw_left, issue_to_top,
	96	"l", -4 * rels_stroke_width, -2 * rels_stroke_width,
	97	"l", 0, 4 * rels_stroke_width, "z"])
	98	.attr({stroke: "none",
	99	fill: color,
	100	"stroke-linecap": "butt",
	101	"stroke-linejoin": "miter",
	102	});
	103	});
	104	}
	105
	106	function drawGanttHandler() {
	107	var folder = document.getElementById('gantt_draw_area');
	108	if(draw_gantt != null)
	109	draw_gantt.clear();
	110	else
	111	draw_gantt = Raphael(folder);
	112	setDrawArea();
	113	drawRelations();
	114	}

app/views/gantts/show.html.erb +21 -2

             <% @gantt.view = self %>
             <h2><%= @query.new_record? ? l(:label_gantt) : h(@query.name) %></h2>
             <%= form_tag({:controller => 'gantts', :action => 'show',
                          :project_id => @project, :month => params[:month],
                          :year => params[:year], :months => params[:months]},
                          :method => :get, :id => 'query_form') do %>
             <%= hidden_field_tag 'set_filter', '1' %>
             <fieldset id="filters" class="collapsible <%= @query.new_record? ? "" : "collapsed" %>">
               <legend onclick="toggleFieldset(this);"><%= l(:label_filter_plural) %></legend>
               <div style="<%= @query.new_record? ? "" : "display: none;" %>">
                 <%= render :partial => 'queries/filters', :locals => {:query => @query} %>
               </div>
             </fieldset>
             <p class="contextual">
               <%= gantt_zoom_link(@gantt, :in) %>
               <%= gantt_zoom_link(@gantt, :out) %>
             </p>
             <p class="buttons">
             <%= text_field_tag 'months', @gantt.months, :size => 2 %>
             <%= l(:label_months_from) %>
             <%= select_month(@gantt.month_from, :prefix => "month", :discard_type => true) %>
             <%= select_year(@gantt.year_from, :prefix => "year", :discard_type => true) %>
             <%= hidden_field_tag 'zoom', @gantt.zoom %>
             <%= link_to_function l(:button_apply), '$("#query_form").submit()',
                                  :class => 'icon icon-checked' %>
             <%= link_to l(:button_clear), { :project_id => @project, :set_filter => 1 },
                         :class => 'icon icon-reload' %>
             </p>
             <% end %>
             <%= error_messages_for 'query' %>
             <% if @query.valid? %>
             <%
               zoom = 1
               @gantt.zoom.times { zoom = zoom * 2 }
               subject_width = 330
               header_heigth = 18
               headers_height = header_heigth
               show_weeks = false
               show_days  = false
               if @gantt.zoom > 1
                 show_weeks = true
                 headers_height = 2 * header_heigth
                 if @gantt.zoom > 2
                     show_days = true
                     headers_height = 3 * header_heigth
                 end
               end
               # Width of the entire chart
               g_width = ((@gantt.date_to - @gantt.date_from + 1) * zoom).to_i
               @gantt.render(:top => headers_height + 8,
                             :zoom => zoom,
                             :g_width => g_width,
                             :subject_width => subject_width)
               g_height = [(20 * (@gantt.number_of_rows + 6)) + 150, 206].max
               t_height = g_height + headers_height
             %>
             <% if @gantt.truncated %>
               <p class="warning"><%= l(:notice_gantt_chart_truncated, :max => @gantt.max_rows) %></p>
             <% end %>
             <table style="width:100%; border:0; border-collapse: collapse;">
             <tr>
             <td style="width:<%= subject_width %>px; padding:0px;">
               <%
                 style  = ""
                 style += "position:relative;"
                 style += "height: #{t_height + 24}px;"
                 style += "width: #{subject_width + 1}px;"
               %>
               <%= content_tag(:div, :style => style) do %>
                 <%
                   style  = ""
                   style += "right:-2px;"
                   style += "width: #{subject_width}px;"
                   style += "height: #{headers_height}px;"
                   style += 'background: #eee;'
                 %>
                 <%= content_tag(:div, "", :style => style, :class => "gantt_hdr") %>
                 <%
                   style  = ""
                   style += "right:-2px;"
                   style += "width: #{subject_width}px;"
                   style += "height: #{t_height}px;"
                   style += 'border-left: 1px solid #c0c0c0;'
                   style += 'overflow: hidden;'
                 %>
                 <%= content_tag(:div, "", :style => style, :class => "gantt_hdr") %>
                 <%= content_tag(:div, :class => "gantt_subjects") do %>
                   <%= @gantt.subjects.html_safe %>
                 <% end %>
               <% end %>
             </td>
             <td>
-            <div style="position:relative;height:<%= t_height + 24 %>px;overflow:auto;">
+            <div style="position:relative;height:<%= t_height + 24 %>px;overflow:auto;" id="gantt_area">
             <%
               style  = ""
               style += "width: #{g_width - 1}px;"
               style += "height: #{headers_height}px;"
               style += 'background: #eee;'
             %>
             <%= content_tag(:div, '&nbsp;'.html_safe, :style => style, :class => "gantt_hdr") %>
             <% ###### Months headers ###### %>
             <%
               month_f = @gantt.date_from
               left = 0
               height = (show_weeks ? header_heigth : header_heigth + g_height)
             %>
             <% @gantt.months.times do %>
               <%
                 width = (((month_f >> 1) - month_f) * zoom - 1).to_i
                 style  = ""
                 style += "left: #{left}px;"
                 style += "width: #{width}px;"
                 style += "height: #{height}px;"
               %>
               <%= content_tag(:div, :style => style, :class => "gantt_hdr") do %>
                 <%= link_to h("#{month_f.year}-#{month_f.month}"),
                             @gantt.params.merge(:year => month_f.year, :month => month_f.month),
                             :title => "#{month_name(month_f.month)} #{month_f.year}" %>
               <% end %>
               <%
                 left = left + width + 1
                 month_f = month_f >> 1
               %>
             <% end %>
             <% ###### Weeks headers ###### %>
             <% if show_weeks %>
               <%
                 left = 0
                 height = (show_days ? header_heigth - 1 : header_heigth - 1 + g_height)
               %>
               <% if @gantt.date_from.cwday == 1 %>
                 <%
                   # @date_from is monday
                   week_f = @gantt.date_from
                 %>
               <% else %>
                 <%
                   # find next monday after @date_from
                   week_f = @gantt.date_from + (7 - @gantt.date_from.cwday + 1)
                   width = (7 - @gantt.date_from.cwday + 1) * zoom - 1
                   style  = ""
                   style += "left: #{left}px;"
                   style += "top: 19px;"
                   style += "width: #{width}px;"
                   style += "height: #{height}px;"
                 %>
                 <%= content_tag(:div, '&nbsp;'.html_safe,
                                 :style => style, :class => "gantt_hdr") %>
                 <% left = left + width + 1 %>
               <% end %>
               <% while week_f <= @gantt.date_to %>
                 <%
                   width = ((week_f + 6 <= @gantt.date_to) ?
 * zoom - 1 :
                               (@gantt.date_to - week_f + 1) * zoom - 1).to_i
                   style  = ""
                   style += "left: #{left}px;"
                   style += "top: 19px;"
                   style += "width: #{width}px;"
                   style += "height: #{height}px;"
                 %>
                 <%= content_tag(:div, :style => style, :class => "gantt_hdr") do %>
                   <%= content_tag(:small) do %>
                     <%= week_f.cweek if width >= 16 %>
                   <% end %>
                 <% end %>
                 <%
                   left = left + width + 1
                   week_f = week_f + 7
                 %>
               <% end %>
             <% end %>
             <% ###### Days headers ####### %>
             <% if show_days %>
               <%
                 left = 0
                 height = g_height + header_heigth - 1
                 wday = @gantt.date_from.cwday
               %>
               <% (@gantt.date_to - @gantt.date_from + 1).to_i.times do %>
                 <%
                   width =  zoom - 1
                   style  = ""
                   style += "left: #{left}px;"
                   style += "top:37px;"
                   style += "width: #{width}px;"
                   style += "height: #{height}px;"
                   style += "font-size:0.7em;"
                   clss = "gantt_hdr"
                   clss << " nwday" if @gantt.non_working_week_days.include?(wday)
                 %>
                 <%= content_tag(:div, :style => style, :class => clss) do %>
                   <%= day_letter(wday) %>
                 <% end %>
                 <%
                   left = left + width + 1
                   wday = wday + 1
                   wday = 1 if wday > 7
                 %>
               <% end %>
             <% end %>
             <%= @gantt.lines.html_safe %>
             <% ###### Today red line (excluded from cache) ###### %>
             <% if Date.today >= @gantt.date_from and Date.today <= @gantt.date_to %>
               <%
                 today_left = (((Date.today - @gantt.date_from + 1) * zoom).floor() - 1).to_i
                 style  = ""
                 style += "position: absolute;"
                 style += "height: #{g_height}px;"
                 style += "top: #{headers_height + 1}px;"
                 style += "left: #{today_left}px;"
                 style += "width:10px;"
                 style += "border-left: 1px dashed red;"
               %>
               <%= content_tag(:div, '&nbsp;'.html_safe, :style => style) %>
             <% end %>
+            <%
+              style  = ""
+              style += "position: absolute;"
+              style += "height: #{g_height}px;"
+              style += "top: #{headers_height + 1}px;"
+              style += "left: 0px;"
+              style += "width: #{g_width - 1}px;"
+            %>
+            <%= content_tag(:div, '', :style => style, :id => "gantt_draw_area") %>
             </div>
             </td>
             </tr>
             </table>
             <table style="width:100%">
             <tr>
               <td align="left">
                 <%= link_to_content_update("\xc2\xab " + l(:label_previous),
                                            params.merge(@gantt.params_previous)) %>
               </td>
               <td align="right">
                 <%= link_to_content_update(l(:label_next) + " \xc2\xbb",
                                            params.merge(@gantt.params_next)) %>
               </td>
             </tr>
             </table>
             <% other_formats_links do |f| %>
               <%= f.link_to 'PDF', :url => params.merge(@gantt.params) %>
               <%= f.link_to('PNG', :url => params.merge(@gantt.params)) if @gantt.respond_to?('to_image') %>
             <% end %>
             <% end # query.valid? %>
             <% content_for :sidebar do %>
               <%= render :partial => 'issues/sidebar' %>
             <% end %>
             <% html_title(l(:label_gantt)) -%>
+            <% content_for :header_tags do %>
+              <%= javascript_include_tag 'raphael' %>
+              <%= javascript_include_tag 'gantt' %>
+            <% end %>
+            <%= javascript_tag do %>
+              var issue_relation_type = <%= raw Redmine::Helpers::Gantt::DRAW_TYPES.to_json %>;
+              $(document).ready(drawGanttHandler);
+              $(window).resize(drawGanttHandler);
+            <% end %>

lib/redmine/helpers/gantt.rb +42 -3

             # 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 Redmine
               module Helpers
                 # Simple class to handle gantt chart data
                 class Gantt
                   include ERB::Util
                   include Redmine::I18n
                   include Redmine::Utils::DateCalculation
+                  # Relation types that are rendered
+                  DRAW_TYPES = {
+                    IssueRelation::TYPE_BLOCKS   => { :landscape_margin => 16, :color => '#F34F4F' },
+                    IssueRelation::TYPE_PRECEDES => { :landscape_margin => 20, :color => '#628FEA' }
+                  }.freeze
                   # :nodoc:
                   # Some utility methods for the PDF export
                   class PDF
                     MaxCharactorsForSubject = 45
                     TotalWidth = 280
                     LeftPaneWidth = 100
                     def self.right_pane_width
                       TotalWidth - LeftPaneWidth
                     end
                   end
                   attr_reader :year_from, :month_from, :date_from, :date_to, :zoom, :months, :truncated, :max_rows
                   attr_accessor :query
                   attr_accessor :project
                   attr_accessor :view
                   def initialize(options={})
                     options = options.dup
                     if options[:year] && options[:year].to_i >0
                       @year_from = options[:year].to_i
                       if options[:month] && options[:month].to_i >=1 && options[:month].to_i <= 12
                         @month_from = options[:month].to_i
                       else
                         @month_from = 1
                       end
                     else
                       @month_from ||= Date.today.month
                       @year_from ||= Date.today.year
                     end
                     zoom = (options[:zoom] || User.current.pref[:gantt_zoom]).to_i
                     @zoom = (zoom > 0 && zoom < 5) ? zoom : 2
                     months = (options[:months] || User.current.pref[:gantt_months]).to_i
                     @months = (months > 0 && months < 25) ? months : 6
                     # Save gantt parameters as user preference (zoom and months count)
                     if (User.current.logged? && (@zoom != User.current.pref[:gantt_zoom] ||
                           @months != User.current.pref[:gantt_months]))
                       User.current.pref[:gantt_zoom], User.current.pref[:gantt_months] = @zoom, @months
                       User.current.preference.save
                     end
                     @date_from = Date.civil(@year_from, @month_from, 1)
                     @date_to = (@date_from >> @months) - 1
                     @subjects = ''
                     @lines = ''
                     @number_of_rows = nil
                     @issue_ancestors = []
                     @truncated = false
                     if options.has_key?(:max_rows)
                       @max_rows = options[:max_rows]
                     else
                       @max_rows = Setting.gantt_items_limit.blank? ? nil : Setting.gantt_items_limit.to_i
                     end
                   end
                   def common_params
                     { :controller => 'gantts', :action => 'show', :project_id => @project }
                   end
                   def params
                     common_params.merge({:zoom => zoom, :year => year_from,
                                          :month => month_from, :months => months})
                   end
                   def params_previous
                     common_params.merge({:year => (date_from << months).year,
                                          :month => (date_from << months).month,
                                          :zoom => zoom, :months => months})
                   end
                   def params_next
                     common_params.merge({:year => (date_from >> months).year,
                                          :month => (date_from >> months).month,
                                          :zoom => zoom, :months => months})
                   end
                   # Returns the number of rows that will be rendered on the Gantt chart
                   def number_of_rows
                     return @number_of_rows if @number_of_rows
                     rows = projects.inject(0) {|total, p| total += number_of_rows_on_project(p)}
                     rows > @max_rows ? @max_rows : rows
                   end
                   # Returns the number of rows that will be used to list a project on
                   # the Gantt chart.  This will recurse for each subproject.
                   def number_of_rows_on_project(project)
                     return 0 unless projects.include?(project)
                     count = 1
                     count += project_issues(project).size
                     count += project_versions(project).size
                     count
                   end
                   # Renders the subjects of the Gantt chart, the left side.
                   def subjects(options={})
                     render(options.merge(:only => :subjects)) unless @subjects_rendered
                     @subjects
                   end
                   # Renders the lines of the Gantt chart, the right side
                   def lines(options={})
                     render(options.merge(:only => :lines)) unless @lines_rendered
                     @lines
                   end
                   # Returns issues that will be rendered
                   def issues
                     @issues ||= @query.issues(
                       :include => [:assigned_to, :tracker, :priority, :category, :fixed_version],
                       :order => "#{Project.table_name}.lft ASC, #{Issue.table_name}.id ASC",
                       :limit => @max_rows
                     )
                   end
+                  # Returns a hash of the relations between the issues that are present on the gantt
+                  # and that should be displayed, grouped by issue ids.
+                  def relations
+                    return @relations if @relations
+                    if issues.any?
+                      issue_ids = issues.map(&:id)
+                      @relations = IssueRelation.
+                        where(:issue_from_id => issue_ids, :issue_to_id => issue_ids, :relation_type => DRAW_TYPES.keys).
+                        group_by(&:issue_from_id)
+                    else
+                      @relations = {}
+                    end
+                  end
                   # Return all the project nodes that will be displayed
                   def projects
                     return @projects if @projects
                     ids = issues.collect(&:project).uniq.collect(&:id)
                     if ids.any?
                       # All issues projects and their visible ancestors
                       @projects = Project.visible.all(
                         :joins => "LEFT JOIN #{Project.table_name} child ON #{Project.table_name}.lft <= child.lft AND #{Project.table_name}.rgt >= child.rgt",
                         :conditions => ["child.id IN (?)", ids],
                         :order => "#{Project.table_name}.lft ASC"
                       ).uniq
                     else
                       @projects = []
                     end
                   end
                   # Returns the issues that belong to +project+
                   def project_issues(project)
                     @issues_by_project ||= issues.group_by(&:project)
                     @issues_by_project[project] || []
                   end
                   # Returns the distinct versions of the issues that belong to +project+
                   def project_versions(project)
                     project_issues(project).collect(&:fixed_version).compact.uniq
                   end
                   # Returns the issues that belong to +project+ and are assigned to +version+
                   def version_issues(project, version)
                     project_issues(project).select {|issue| issue.fixed_version == version}
                   end
                   def render(options={})
                     options = {:top => 0, :top_increment => 20,
                                :indent_increment => 20, :render => :subject,
                                :format => :html}.merge(options)
                     indent = options[:indent] || 4
                     @subjects = '' unless options[:only] == :lines
                     @lines = '' unless options[:only] == :subjects
                     @number_of_rows = 0
                     Project.project_tree(projects) do |project, level|
                       options[:indent] = indent + level * options[:indent_increment]
                       render_project(project, options)
                       break if abort?
                     end
                     @subjects_rendered = true unless options[:only] == :lines
                     @lines_rendered = true unless options[:only] == :subjects
                     render_end(options)
                   end
                   def render_project(project, options={})
                     subject_for_project(project, options) unless options[:only] == :lines
                     line_for_project(project, options) unless options[:only] == :subjects
                     options[:top] += options[:top_increment]
                     options[:indent] += options[:indent_increment]
                     @number_of_rows += 1
                     return if abort?
                     issues = project_issues(project).select {|i| i.fixed_version.nil?}
                     sort_issues!(issues)
                     if issues
                       render_issues(issues, options)
                       return if abort?
                     end
                     versions = project_versions(project)
                     versions.each do |version|
                       render_version(project, version, options)
                     end
                     # Remove indent to hit the next sibling
                     options[:indent] -= options[:indent_increment]
                   end
                   def render_issues(issues, options={})
                     @issue_ancestors = []
                     issues.each do |i|
                       subject_for_issue(i, options) unless options[:only] == :lines
                       line_for_issue(i, options) unless options[:only] == :subjects
                       options[:top] += options[:top_increment]
                       @number_of_rows += 1
                       break if abort?
                     end
                     options[:indent] -= (options[:indent_increment] * @issue_ancestors.size)
                   end
                   def render_version(project, version, options={})
                     # Version header
                     subject_for_version(version, options) unless options[:only] == :lines
                     line_for_version(version, options) unless options[:only] == :subjects
                     options[:top] += options[:top_increment]
                     @number_of_rows += 1
                     return if abort?
                     issues = version_issues(project, version)
                     if issues
                       sort_issues!(issues)
                       # Indent issues
                       options[:indent] += options[:indent_increment]
                       render_issues(issues, options)
                       options[:indent] -= options[:indent_increment]
                     end
                   end
                   def render_end(options={})
                     case options[:format]
                     when :pdf
                       options[:pdf].Line(15, options[:top], PDF::TotalWidth, options[:top])
                     end
                   end
                   def subject_for_project(project, options)
                     case options[:format]
                     when :html
                       html_class = ""
                       html_class << 'icon icon-projects '
                       html_class << (project.overdue? ? 'project-overdue' : '')
                       s = view.link_to_project(project).html_safe
                       subject = view.content_tag(:span, s,
                                                  :class => html_class).html_safe
                       html_subject(options, subject, :css => "project-name")
                     when :image
                       image_subject(options, project.name)
                     when :pdf
                       pdf_new_page?(options)
                       pdf_subject(options, project.name)
                     end
                   end
                   def line_for_project(project, options)
                     # Skip versions that don't have a start_date or due date
                     if project.is_a?(Project) && project.start_date && project.due_date
                       options[:zoom] ||= 1
                       options[:g_width] ||= (self.date_to - self.date_from + 1) * options[:zoom]
                       coords = coordinates(project.start_date, project.due_date, nil, options[:zoom])
                       label = h(project)
                       case options[:format]
                       when :html
                         html_task(options, coords, :css => "project task", :label => label, :markers => true)
                       when :image
                         image_task(options, coords, :label => label, :markers => true, :height => 3)
                       when :pdf
                         pdf_task(options, coords, :label => label, :markers => true, :height => 0.8)
                       end
                     else
                       ActiveRecord::Base.logger.debug "Gantt#line_for_project was not given a project with a start_date"
                       ''
                     end
                   end
                   def subject_for_version(version, options)
                     case options[:format]
                     when :html
                       html_class = ""
                       html_class << 'icon icon-package '
                       html_class << (version.behind_schedule? ? 'version-behind-schedule' : '') << " "
                       html_class << (version.overdue? ? 'version-overdue' : '')
                       s = view.link_to_version(version).html_safe
                       subject = view.content_tag(:span, s,
                                                  :class => html_class).html_safe
                       html_subject(options, subject, :css => "version-name")
                     when :image
                       image_subject(options, version.to_s_with_project)
                     when :pdf
                       pdf_new_page?(options)
                       pdf_subject(options, version.to_s_with_project)
                     end
                   end
                   def line_for_version(version, options)
                     # Skip versions that don't have a start_date
                     if version.is_a?(Version) && version.start_date && version.due_date
                       options[:zoom] ||= 1
                       options[:g_width] ||= (self.date_to - self.date_from + 1) * options[:zoom]
                       coords = coordinates(version.start_date,
                                            version.due_date, version.completed_percent,
                                            options[:zoom])
                       label = "#{h version} #{h version.completed_percent.to_i.to_s}%"
                       label = h("#{version.project} -") + label unless @project && @project == version.project
                       case options[:format]
                       when :html
                         html_task(options, coords, :css => "version task", :label => label, :markers => true)
                       when :image
                         image_task(options, coords, :label => label, :markers => true, :height => 3)
                       when :pdf
                         pdf_task(options, coords, :label => label, :markers => true, :height => 0.8)
                       end
                     else
                       ActiveRecord::Base.logger.debug "Gantt#line_for_version was not given a version with a start_date"
                       ''
                     end
                   end
                   def subject_for_issue(issue, options)
                     while @issue_ancestors.any? && !issue.is_descendant_of?(@issue_ancestors.last)
                       @issue_ancestors.pop
                       options[:indent] -= options[:indent_increment]
                     end
                     output = case options[:format]
                     when :html
                       css_classes = ''
                       css_classes << ' issue-overdue' if issue.overdue?
                       css_classes << ' issue-behind-schedule' if issue.behind_schedule?
                       css_classes << ' icon icon-issue' unless Setting.gravatar_enabled? && issue.assigned_to
                       s = "".html_safe
                       if issue.assigned_to.present?
                         assigned_string = l(:field_assigned_to) + ": " + issue.assigned_to.name
                         s << view.avatar(issue.assigned_to,
                                          :class => 'gravatar icon-gravatar',
                                          :size => 10,
                                          :title => assigned_string).to_s.html_safe
                       end
                       s << view.link_to_issue(issue).html_safe
                       subject = view.content_tag(:span, s, :class => css_classes).html_safe
                       html_subject(options, subject, :css => "issue-subject",
                                    :title => issue.subject) + "\n"
                     when :image
                       image_subject(options, issue.subject)
                     when :pdf
                       pdf_new_page?(options)
                       pdf_subject(options, issue.subject)
                     end
                     unless issue.leaf?
                       @issue_ancestors << issue
                       options[:indent] += options[:indent_increment]
                     end
                     output
                   end
                   def line_for_issue(issue, options)
                     # Skip issues that don't have a due_before (due_date or version's due_date)
                     if issue.is_a?(Issue) && issue.due_before
                       coords = coordinates(issue.start_date, issue.due_before, issue.done_ratio, options[:zoom])
                       label = "#{issue.status.name} #{issue.done_ratio}%"
                       case options[:format]
                       when :html
                         html_task(options, coords,
                                   :css => "task " + (issue.leaf? ? 'leaf' : 'parent'),
                                   :label => label, :issue => issue,
                                   :markers => !issue.leaf?)
                       when :image
                         image_task(options, coords, :label => label)
                       when :pdf
                         pdf_task(options, coords, :label => label)
                     end
                     else
                       ActiveRecord::Base.logger.debug "GanttHelper#line_for_issue was not given an issue with a due_before"
                       ''
                     end
                   end
                   # Generates a gantt image
                   # Only defined if RMagick is avalaible
                   def to_image(format='PNG')
                     date_to = (@date_from >> @months) - 1
                     show_weeks = @zoom > 1
                     show_days = @zoom > 2
                     subject_width = 400
                     header_height = 18
                     # width of one day in pixels
                     zoom = @zoom * 2
                     g_width = (@date_to - @date_from + 1) * zoom
                     g_height = 20 * number_of_rows + 30
                     headers_height = (show_weeks ? 2 * header_height : header_height)
                     height = g_height + headers_height
                     imgl = Magick::ImageList.new
                     imgl.new_image(subject_width + g_width + 1, height)
                     gc = Magick::Draw.new
                     gc.font = Redmine::Configuration['rmagick_font_path'] || ""
                     # Subjects
                     gc.stroke('transparent')
                     subjects(:image => gc, :top => (headers_height + 20), :indent => 4, :format => :image)
                     # Months headers
                     month_f = @date_from
                     left = subject_width
                     @months.times do
                       width = ((month_f >> 1) - month_f) * zoom
                       gc.fill('white')
                       gc.stroke('grey')
                       gc.stroke_width(1)
                       gc.rectangle(left, 0, left + width, height)
                       gc.fill('black')
                       gc.stroke('transparent')
                       gc.stroke_width(1)
                       gc.text(left.round + 8, 14, "#{month_f.year}-#{month_f.month}")
                       left = left + width
                       month_f = month_f >> 1
                     end
                     # Weeks headers
                     if show_weeks
                       left = subject_width
                       height = header_height
                       if @date_from.cwday == 1
                         # date_from is monday
                         week_f = date_from
                       else
                         # find next monday after date_from
                         week_f = @date_from + (7 - @date_from.cwday + 1)
                         width = (7 - @date_from.cwday + 1) * zoom
                         gc.fill('white')
                         gc.stroke('grey')
                         gc.stroke_width(1)
                         gc.rectangle(left, header_height, left + width, 2 * header_height + g_height - 1)
                         left = left + width
                       end
                       while week_f <= date_to
                         width = (week_f + 6 <= date_to) ? 7 * zoom : (date_to - week_f + 1) * zoom
                         gc.fill('white')
                         gc.stroke('grey')
                         gc.stroke_width(1)
                         gc.rectangle(left.round, header_height, left.round + width, 2 * header_height + g_height - 1)
                         gc.fill('black')
                         gc.stroke('transparent')
                         gc.stroke_width(1)
                         gc.text(left.round + 2, header_height + 14, week_f.cweek.to_s)
                         left = left + width
                         week_f = week_f + 7
                       end
                     end
                     # Days details (week-end in grey)
                     if show_days
                       left = subject_width
                       height = g_height + header_height - 1
                       wday = @date_from.cwday
                       (date_to - @date_from + 1).to_i.times do
                         width =  zoom
                         gc.fill(non_working_week_days.include?(wday) ? '#eee' : 'white')
                         gc.stroke('#ddd')
                         gc.stroke_width(1)
                         gc.rectangle(left, 2 * header_height, left + width, 2 * header_height + g_height - 1)
                         left = left + width
                         wday = wday + 1
                         wday = 1 if wday > 7
                       end
                     end
                     # border
                     gc.fill('transparent')
                     gc.stroke('grey')
                     gc.stroke_width(1)
                     gc.rectangle(0, 0, subject_width + g_width, headers_height)
                     gc.stroke('black')
                     gc.rectangle(0, 0, subject_width + g_width, g_height + headers_height - 1)
                     # content
                     top = headers_height + 20
                     gc.stroke('transparent')
                     lines(:image => gc, :top => top, :zoom => zoom,
                           :subject_width => subject_width, :format => :image)
                     # today red line
                     if Date.today >= @date_from and Date.today <= date_to
                       gc.stroke('red')
                       x = (Date.today - @date_from + 1) * zoom + subject_width
                       gc.line(x, headers_height, x, headers_height + g_height - 1)
                     end
                     gc.draw(imgl)
                     imgl.format = format
                     imgl.to_blob
                   end if Object.const_defined?(:Magick)
                   def to_pdf
                     pdf = ::Redmine::Export::PDF::ITCPDF.new(current_language)
                     pdf.SetTitle("#{l(:label_gantt)} #{project}")
                     pdf.alias_nb_pages
                     pdf.footer_date = format_date(Date.today)
                     pdf.AddPage("L")
                     pdf.SetFontStyle('B', 12)
                     pdf.SetX(15)
                     pdf.RDMCell(PDF::LeftPaneWidth, 20, project.to_s)
                     pdf.Ln
                     pdf.SetFontStyle('B', 9)
                     subject_width = PDF::LeftPaneWidth
                     header_height = 5
                     headers_height = header_height
                     show_weeks = false
                     show_days = false
                     if self.months < 7
                       show_weeks = true
                       headers_height = 2 * header_height
                       if self.months < 3
                         show_days = true
                         headers_height = 3 * header_height
                       end
                     end
                     g_width = PDF.right_pane_width
                     zoom = (g_width) / (self.date_to - self.date_from + 1)
                     g_height = 120
                     t_height = g_height + headers_height
                     y_start = pdf.GetY
                     # Months headers
                     month_f = self.date_from
                     left = subject_width
                     height = header_height
                     self.months.times do
                       width = ((month_f >> 1) - month_f) * zoom
                       pdf.SetY(y_start)
                       pdf.SetX(left)
                       pdf.RDMCell(width, height, "#{month_f.year}-#{month_f.month}", "LTR", 0, "C")
                       left = left + width
                       month_f = month_f >> 1
                     end
                     # Weeks headers
                     if show_weeks
                       left = subject_width
                       height = header_height
                       if self.date_from.cwday == 1
                         # self.date_from is monday
                         week_f = self.date_from
                       else
                         # find next monday after self.date_from
                         week_f = self.date_from + (7 - self.date_from.cwday + 1)
                         width = (7 - self.date_from.cwday + 1) * zoom-1
                         pdf.SetY(y_start + header_height)
                         pdf.SetX(left)
                         pdf.RDMCell(width + 1, height, "", "LTR")
                         left = left + width + 1
                       end
                       while week_f <= self.date_to
                         width = (week_f + 6 <= self.date_to) ? 7 * zoom : (self.date_to - week_f + 1) * zoom
                         pdf.SetY(y_start + header_height)
                         pdf.SetX(left)
                         pdf.RDMCell(width, height, (width >= 5 ? week_f.cweek.to_s : ""), "LTR", 0, "C")
                         left = left + width
                         week_f = week_f + 7
                       end
                     end
                     # Days headers
                     if show_days
                       left = subject_width
                       height = header_height
                       wday = self.date_from.cwday
                       pdf.SetFontStyle('B', 7)
                       (self.date_to - self.date_from + 1).to_i.times do
                         width = zoom
                         pdf.SetY(y_start + 2 * header_height)
                         pdf.SetX(left)
                         pdf.RDMCell(width, height, day_name(wday).first, "LTR", 0, "C")
                         left = left + width
                         wday = wday + 1
                         wday = 1 if wday > 7
                       end
                     end
                     pdf.SetY(y_start)
                     pdf.SetX(15)
                     pdf.RDMCell(subject_width + g_width - 15, headers_height, "", 1)
                     # Tasks
                     top = headers_height + y_start
                     options = {
                       :top => top,
                       :zoom => zoom,
                       :subject_width => subject_width,
                       :g_width => g_width,
                       :indent => 0,
                       :indent_increment => 5,
                       :top_increment => 5,
                       :format => :pdf,
                       :pdf => pdf
                     }
                     render(options)
                     pdf.Output
                   end
                   private
                   def coordinates(start_date, end_date, progress, zoom=nil)
                     zoom ||= @zoom
                     coords = {}
                     if start_date && end_date && start_date < self.date_to && end_date > self.date_from
                       if start_date > self.date_from
                         coords[:start] = start_date - self.date_from
                         coords[:bar_start] = start_date - self.date_from
                       else
                         coords[:bar_start] = 0
                       end
                       if end_date < self.date_to
                         coords[:end] = end_date - self.date_from
                         coords[:bar_end] = end_date - self.date_from + 1
                       else
                         coords[:bar_end] = self.date_to - self.date_from + 1
                       end
                       if progress
                         progress_date = start_date + (end_date - start_date + 1) * (progress / 100.0)
                         if progress_date > self.date_from && progress_date > start_date
                           if progress_date < self.date_to
                             coords[:bar_progress_end] = progress_date - self.date_from
                           else
                             coords[:bar_progress_end] = self.date_to - self.date_from + 1
                           end
                         end
                         if progress_date < Date.today
                           late_date = [Date.today, end_date].min
                           if late_date > self.date_from && late_date > start_date
                             if late_date < self.date_to
                               coords[:bar_late_end] = late_date - self.date_from + 1
                             else
                               coords[:bar_late_end] = self.date_to - self.date_from + 1
                             end
                           end
                         end
                       end
                     end
                     # Transforms dates into pixels witdh
                     coords.keys.each do |key|
                       coords[key] = (coords[key] * zoom).floor
                     end
                     coords
                   end
                   # Sorts a collection of issues by start_date, due_date, id for gantt rendering
                   def sort_issues!(issues)
                     issues.sort! { |a, b| gantt_issue_compare(a, b) }
                   end
                   # TODO: top level issues should be sorted by start date
                   def gantt_issue_compare(x, y)
                     if x.root_id == y.root_id
                       x.lft <=> y.lft
                     else
                       x.root_id <=> y.root_id
                     end
                   end
                   def current_limit
                     if @max_rows
                       @max_rows - @number_of_rows
                     else
                       nil
                     end
                   end
                   def abort?
                     if @max_rows && @number_of_rows >= @max_rows
                       @truncated = true
                     end
                   end
                   def pdf_new_page?(options)
                     if options[:top] > 180
                       options[:pdf].Line(15, options[:top], PDF::TotalWidth, options[:top])
                       options[:pdf].AddPage("L")
                       options[:top] = 15
                       options[:pdf].Line(15, options[:top] - 0.1, PDF::TotalWidth, options[:top] - 0.1)
                     end
                   end
                   def html_subject(params, subject, options={})
                     style = "position: absolute;top:#{params[:top]}px;left:#{params[:indent]}px;"
                     style << "width:#{params[:subject_width] - params[:indent]}px;" if params[:subject_width]
                     output = view.content_tag('div', subject,
                                               :class => options[:css], :style => style,
                                               :title => options[:title])
                     @subjects << output
                     output
                   end
                   def pdf_subject(params, subject, options={})
                     params[:pdf].SetY(params[:top])
                     params[:pdf].SetX(15)
                     char_limit = PDF::MaxCharactorsForSubject - params[:indent]
                     params[:pdf].RDMCell(params[:subject_width] - 15, 5,
                                          (" " * params[:indent]) +
                                            subject.to_s.sub(/^(.{#{char_limit}}[^\s]*\s).*$/, '\1 (...)'),
                                           "LR")
                     params[:pdf].SetY(params[:top])
                     params[:pdf].SetX(params[:subject_width])
                     params[:pdf].RDMCell(params[:g_width], 5, "", "LR")
                   end
                   def image_subject(params, subject, options={})
                     params[:image].fill('black')
                     params[:image].stroke('transparent')
                     params[:image].stroke_width(1)
                     params[:image].text(params[:indent], params[:top] + 2, subject)
                   end
+                  def issue_relations(issue)
+                    rels = {}
+                    if relations[issue.id]
+                      relations[issue.id].each do |relation|
+                        (rels[relation.relation_type] ||= []) << relation.issue_to_id
+                      end
+                    end
+                    rels
+                  end
                   def html_task(params, coords, options={})
                     output = ''
                     # Renders the task bar, with progress and late
                     if coords[:bar_start] && coords[:bar_end]
                       width = coords[:bar_end] - coords[:bar_start] - 2
                       style = ""
                       style << "top:#{params[:top]}px;"
                       style << "left:#{coords[:bar_start]}px;"
                       style << "width:#{width}px;"
-                      output << view.content_tag(:div, '&nbsp;'.html_safe,
+                      html_id = "task-todo-issue-#{options[:issue].id}" if options[:issue]
-                                                 :style => style,
+                      content_opt = {:style => style,
-                                                 :class => "#{options[:css]} task_todo")
+                                     :class => "#{options[:css]} task_todo",
+                                     :id => html_id}
+                      if options[:issue]
+                        rels_hash = {}
+                        issue_relations(options[:issue]).each do |k, v|
+                          rels_hash[k] = v.join(',')
+                        end
+                        content_opt[:data] = {"rels" => rels_hash}
+                      end
+                      output << view.content_tag(:div, '&nbsp;'.html_safe, content_opt)
                       if coords[:bar_late_end]
                         width = coords[:bar_late_end] - coords[:bar_start] - 2
                         style = ""
                         style << "top:#{params[:top]}px;"
                         style << "left:#{coords[:bar_start]}px;"
                         style << "width:#{width}px;"
                         output << view.content_tag(:div, '&nbsp;'.html_safe,
                                                    :style => style,
                                                    :class => "#{options[:css]} task_late")
                       end
                       if coords[:bar_progress_end]
                         width = coords[:bar_progress_end] - coords[:bar_start] - 2
                         style = ""
                         style << "top:#{params[:top]}px;"
                         style << "left:#{coords[:bar_start]}px;"
                         style << "width:#{width}px;"
                         output << view.content_tag(:div, '&nbsp;'.html_safe,
                                                    :style => style,
                                                    :class => "#{options[:css]} task_done")
                       end
                     end
                     # Renders the markers
                     if options[:markers]
                       if coords[:start]
                         style = ""
                         style << "top:#{params[:top]}px;"
                         style << "left:#{coords[:start]}px;"
                         style << "width:15px;"
                         output << view.content_tag(:div, '&nbsp;'.html_safe,
                                                    :style => style,
                                                    :class => "#{options[:css]} marker starting")
                       end
                       if coords[:end]
                         style = ""
                         style << "top:#{params[:top]}px;"
                         style << "left:#{coords[:end] + params[:zoom]}px;"
                         style << "width:15px;"
                         output << view.content_tag(:div, '&nbsp;'.html_safe,
                                                    :style => style,
                                                    :class => "#{options[:css]} marker ending")
                       end
                     end
                     # Renders the label on the right
                     if options[:label]
                       style = ""
                       style << "top:#{params[:top]}px;"
                       style << "left:#{(coords[:bar_end] || 0) + 8}px;"
                       style << "width:15px;"
                       output << view.content_tag(:div, options[:label],
                                                  :style => style,
                                                  :class => "#{options[:css]} label")
                     end
                     # Renders the tooltip
                     if options[:issue] && coords[:bar_start] && coords[:bar_end]
                       s = view.content_tag(:span,
                                            view.render_issue_tooltip(options[:issue]).html_safe,
                                            :class => "tip")
                       style = ""
                       style << "position: absolute;"
                       style << "top:#{params[:top]}px;"
                       style << "left:#{coords[:bar_start]}px;"
                       style << "width:#{coords[:bar_end] - coords[:bar_start]}px;"
                       style << "height:12px;"
                       output << view.content_tag(:div, s.html_safe,
                                                  :style => style,
                                                  :class => "tooltip")
                     end
                     @lines << output
                     output
                   end
                   def pdf_task(params, coords, options={})
                     height = options[:height] || 2
                     # Renders the task bar, with progress and late
                     if coords[:bar_start] && coords[:bar_end]
                       params[:pdf].SetY(params[:top] + 1.5)
                       params[:pdf].SetX(params[:subject_width] + coords[:bar_start])
                       params[:pdf].SetFillColor(200, 200, 200)
                       params[:pdf].RDMCell(coords[:bar_end] - coords[:bar_start], height, "", 0, 0, "", 1)
                       if coords[:bar_late_end]
                         params[:pdf].SetY(params[:top] + 1.5)
                         params[:pdf].SetX(params[:subject_width] + coords[:bar_start])
                         params[:pdf].SetFillColor(255, 100, 100)
                         params[:pdf].RDMCell(coords[:bar_late_end] - coords[:bar_start], height, "", 0, 0, "", 1)
                       end
                       if coords[:bar_progress_end]
                         params[:pdf].SetY(params[:top] + 1.5)
                         params[:pdf].SetX(params[:subject_width] + coords[:bar_start])
                         params[:pdf].SetFillColor(90, 200, 90)
                         params[:pdf].RDMCell(coords[:bar_progress_end] - coords[:bar_start], height, "", 0, 0, "", 1)
                       end
                     end
                     # Renders the markers
                     if options[:markers]
                       if coords[:start]
                         params[:pdf].SetY(params[:top] + 1)
                         params[:pdf].SetX(params[:subject_width] + coords[:start] - 1)
                         params[:pdf].SetFillColor(50, 50, 200)
                         params[:pdf].RDMCell(2, 2, "", 0, 0, "", 1)
                       end
                       if coords[:end]
                         params[:pdf].SetY(params[:top] + 1)
                         params[:pdf].SetX(params[:subject_width] + coords[:end] - 1)
                         params[:pdf].SetFillColor(50, 50, 200)
                         params[:pdf].RDMCell(2, 2, "", 0, 0, "", 1)
                       end
                     end
                     # Renders the label on the right
                     if options[:label]
                       params[:pdf].SetX(params[:subject_width] + (coords[:bar_end] || 0) + 5)
                       params[:pdf].RDMCell(30, 2, options[:label])
                     end
                   end
                   def image_task(params, coords, options={})
                     height = options[:height] || 6
                     # Renders the task bar, with progress and late
                     if coords[:bar_start] && coords[:bar_end]
                       params[:image].fill('#aaa')
                       params[:image].rectangle(params[:subject_width] + coords[:bar_start],
                                                params[:top],
                                                params[:subject_width] + coords[:bar_end],
                                                params[:top] - height)
                       if coords[:bar_late_end]
                         params[:image].fill('#f66')
                         params[:image].rectangle(params[:subject_width] + coords[:bar_start],
                                                  params[:top],
                                                  params[:subject_width] + coords[:bar_late_end],
                                                  params[:top] - height)
                       end
                       if coords[:bar_progress_end]
                         params[:image].fill('#00c600')
                         params[:image].rectangle(params[:subject_width] + coords[:bar_start],
                                                  params[:top],
                                                  params[:subject_width] + coords[:bar_progress_end],
                                                  params[:top] - height)
                       end
                     end
                     # Renders the markers
                     if options[:markers]
                       if coords[:start]
                         x = params[:subject_width] + coords[:start]
                         y = params[:top] - height / 2
                         params[:image].fill('blue')
                         params[:image].polygon(x - 4, y, x, y - 4, x + 4, y, x, y + 4)
                       end
                       if coords[:end]
                         x = params[:subject_width] + coords[:end] + params[:zoom]
                         y = params[:top] - height / 2
                         params[:image].fill('blue')
                         params[:image].polygon(x - 4, y, x, y - 4, x + 4, y, x, y + 4)
                       end
                     end
                     # Renders the label on the right
                     if options[:label]
                       params[:image].fill('black')
                       params[:image].text(params[:subject_width] + (coords[:bar_end] || 0) + 5,
                                           params[:top] + 1,
                                           options[:label])
                     end
                   end
                 end
               end
             end

test/functional/gantts_controller_test.rb +16 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.
             require File.expand_path('../../test_helper', __FILE__)
             class GanttsControllerTest < ActionController::TestCase
               fixtures :projects, :trackers, :issue_statuses, :issues,
                        :enumerations, :users, :issue_categories,
                        :projects_trackers,
                        :roles,
                        :member_roles,
                        :members,
                        :enabled_modules,
                        :workflows,
                        :versions
               def test_gantt_should_work
                 i2 = Issue.find(2)
                 i2.update_attribute(:due_date, 1.month.from_now)
                 get :show, :project_id => 1
                 assert_response :success
                 assert_template 'gantts/show'
                 assert_not_nil assigns(:gantt)
                 # Issue with start and due dates
                 i = Issue.find(1)
                 assert_not_nil i.due_date
                 assert_select "div a.issue", /##{i.id}/
                 # Issue with on a targeted version should not be in the events but loaded in the html
                 i = Issue.find(2)
                 assert_select "div a.issue", /##{i.id}/
               end
               def test_gantt_should_work_without_issue_due_dates
                 Issue.update_all("due_date = NULL")
                 get :show, :project_id => 1
                 assert_response :success
                 assert_template 'gantts/show'
                 assert_not_nil assigns(:gantt)
               end
               def test_gantt_should_work_without_issue_and_version_due_dates
                 Issue.update_all("due_date = NULL")
                 Version.update_all("effective_date = NULL")
                 get :show, :project_id => 1
                 assert_response :success
                 assert_template 'gantts/show'
                 assert_not_nil assigns(:gantt)
               end
               def test_gantt_should_work_cross_project
                 get :show
                 assert_response :success
                 assert_template 'gantts/show'
                 assert_not_nil assigns(:gantt)
                 assert_not_nil assigns(:gantt).query
                 assert_nil assigns(:gantt).project
               end
               def test_gantt_should_not_disclose_private_projects
                 get :show
                 assert_response :success
                 assert_template 'gantts/show'
                 assert_tag 'a', :content => /eCookbook/
                 # Root private project
                 assert_no_tag 'a', {:content => /OnlineStore/}
                 # Private children of a public project
                 assert_no_tag 'a', :content => /Private child of eCookbook/
               end
+              def test_gantt_should_display_relations
+                IssueRelation.delete_all
+                issue1 = Issue.generate!(:start_date => 1.day.from_now, :due_date => 3.day.from_now)
+                issue2 = Issue.generate!(:start_date => 1.day.from_now, :due_date => 3.day.from_now)
+                IssueRelation.create!(:issue_from => issue1, :issue_to => issue2, :relation_type => 'precedes')
+                get :show
+                assert_response :success
+                relations = assigns(:gantt).relations
+                assert_kind_of Hash, relations
+                assert relations.present?
+                assert_select 'div.task_todo[id=?][data-rels*=?]', "task-todo-issue-#{issue1.id}", issue2.id.to_s
+                assert_select 'div.task_todo[id=?][data-rels=?]', "task-todo-issue-#{issue2.id}", '{}'
+              end
               def test_gantt_should_export_to_pdf
                 get :show, :project_id => 1, :format => 'pdf'
                 assert_response :success
                 assert_equal 'application/pdf', @response.content_type
                 assert @response.body.starts_with?('%PDF')
                 assert_not_nil assigns(:gantt)
               end
               def test_gantt_should_export_to_pdf_cross_project
                 get :show, :format => 'pdf'
                 assert_response :success
                 assert_equal 'application/pdf', @response.content_type
                 assert @response.body.starts_with?('%PDF')
                 assert_not_nil assigns(:gantt)
               end
               if Object.const_defined?(:Magick)
                 def test_gantt_should_export_to_png
                   get :show, :project_id => 1, :format => 'png'
                   assert_response :success
                   assert_equal 'image/png', @response.content_type
                 end
               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