jro_apps/redmine Commit - r4307:77c6188ec272

Fixed: gantt displays issues by date of creation....

Jean-Philippe Lang -

r4307:77c6188ec272

parent child

Context file:

r4307:77c6188ec272

Collapse all files

app/models/issue.rb +1 -2

              # redMine - project management software
              # Copyright (C) 2006-2007  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 Issue < ActiveRecord::Base
                belongs_to :project
                belongs_to :tracker
                belongs_to :status, :class_name => 'IssueStatus', :foreign_key => 'status_id'
                belongs_to :author, :class_name => 'User', :foreign_key => 'author_id'
                belongs_to :assigned_to, :class_name => 'User', :foreign_key => 'assigned_to_id'
                belongs_to :fixed_version, :class_name => 'Version', :foreign_key => 'fixed_version_id'
                belongs_to :priority, :class_name => 'IssuePriority', :foreign_key => 'priority_id'
                belongs_to :category, :class_name => 'IssueCategory', :foreign_key => 'category_id'
                has_many :journals, :as => :journalized, :dependent => :destroy
                has_many :time_entries, :dependent => :delete_all
                has_and_belongs_to_many :changesets, :order => "#{Changeset.table_name}.committed_on ASC, #{Changeset.table_name}.id ASC"
                has_many :relations_from, :class_name => 'IssueRelation', :foreign_key => 'issue_from_id', :dependent => :delete_all
                has_many :relations_to, :class_name => 'IssueRelation', :foreign_key => 'issue_to_id', :dependent => :delete_all
                acts_as_nested_set :scope => 'root_id'
                acts_as_attachable :after_remove => :attachment_removed
                acts_as_customizable
                acts_as_watchable
                acts_as_searchable :columns => ['subject', "#{table_name}.description", "#{Journal.table_name}.notes"],
                                   :include => [:project, :journals],
                                   # sort by id so that limited eager loading doesn't break with postgresql
                                   :order_column => "#{table_name}.id"
                acts_as_event :title => Proc.new {|o| "#{o.tracker.name} ##{o.id} (#{o.status}): #{o.subject}"},
                              :url => Proc.new {|o| {:controller => 'issues', :action => 'show', :id => o.id}},
                              :type => Proc.new {|o| 'issue' + (o.closed? ? ' closed' : '') }
                acts_as_activity_provider :find_options => {:include => [:project, :author, :tracker]},
                                          :author_key => :author_id
                DONE_RATIO_OPTIONS = %w(issue_field issue_status)
                attr_reader :current_journal
                validates_presence_of :subject, :priority, :project, :tracker, :author, :status
                validates_length_of :subject, :maximum => 255
                validates_inclusion_of :done_ratio, :in => 0..100
                validates_numericality_of :estimated_hours, :allow_nil => true
                named_scope :visible, lambda {|*args| { :include => :project,
                                                        :conditions => Project.allowed_to_condition(args.first || User.current, :view_issues) } }
                named_scope :open, :conditions => ["#{IssueStatus.table_name}.is_closed = ?", false], :include => :status
                named_scope :recently_updated, :order => "#{Issue.table_name}.updated_on DESC"
                named_scope :with_limit, lambda { |limit| { :limit => limit} }
                named_scope :on_active_project, :include => [:status, :project, :tracker],
                                                :conditions => ["#{Project.table_name}.status=#{Project::STATUS_ACTIVE}"]
                named_scope :for_gantt, lambda {
                  {
-                   :include => [:tracker, :status, :assigned_to, :priority, :project, :fixed_version],
-                   :order => "#{Issue.table_name}.due_date ASC, #{Issue.table_name}.start_date ASC, #{Issue.table_name}.id ASC"
+                   :include => [:tracker, :status, :assigned_to, :priority, :project, :fixed_version]
                  }
                }
                named_scope :without_version, lambda {
                  {
                    :conditions => { :fixed_version_id => nil}
                  }
                }
                named_scope :with_query, lambda {|query|
                  {
                    :conditions => Query.merge_conditions(query.statement)
                  }
                }
                before_create :default_assign
                before_save :close_duplicates, :update_done_ratio_from_issue_status
                after_save :reschedule_following_issues, :update_nested_set_attributes, :update_parent_attributes, :create_journal
                after_destroy :destroy_children
                after_destroy :update_parent_attributes
                # Returns true if usr or current user is allowed to view the issue
                def visible?(usr=nil)
                  (usr || User.current).allowed_to?(:view_issues, self.project)
                end
                def after_initialize
                  if new_record?
                    # set default values for new records only
                    self.status ||= IssueStatus.default
                    self.priority ||= IssuePriority.default
                  end
                end
                # Overrides Redmine::Acts::Customizable::InstanceMethods#available_custom_fields
                def available_custom_fields
                  (project && tracker) ? project.all_issue_custom_fields.select {|c| tracker.custom_fields.include? c } : []
                end
                def copy_from(arg)
                  issue = arg.is_a?(Issue) ? arg : Issue.visible.find(arg)
                  self.attributes = issue.attributes.dup.except("id", "root_id", "parent_id", "lft", "rgt", "created_on", "updated_on")
                  self.custom_field_values = issue.custom_field_values.inject({}) {|h,v| h[v.custom_field_id] = v.value; h}
                  self.status = issue.status
                  self
                end
                # Moves/copies an issue to a new project and tracker
                # Returns the moved/copied issue on success, false on failure
                def move_to_project(*args)
                  ret = Issue.transaction do
                    move_to_project_without_transaction(*args) || raise(ActiveRecord::Rollback)
                  end || false
                end
                def move_to_project_without_transaction(new_project, new_tracker = nil, options = {})
                  options ||= {}
                  issue = options[:copy] ? self.class.new.copy_from(self) : self
                  if new_project && issue.project_id != new_project.id
                    # delete issue relations
                    unless Setting.cross_project_issue_relations?
                      issue.relations_from.clear
                      issue.relations_to.clear
                    end
                    # issue is moved to another project
                    # reassign to the category with same name if any
                    new_category = issue.category.nil? ? nil : new_project.issue_categories.find_by_name(issue.category.name)
                    issue.category = new_category
                    # Keep the fixed_version if it's still valid in the new_project
                    unless new_project.shared_versions.include?(issue.fixed_version)
                      issue.fixed_version = nil
                    end
                    issue.project = new_project
                    if issue.parent && issue.parent.project_id != issue.project_id
                      issue.parent_issue_id = nil
                    end
                  end
                  if new_tracker
                    issue.tracker = new_tracker
                    issue.reset_custom_values!
                  end
                  if options[:copy]
                    issue.custom_field_values = self.custom_field_values.inject({}) {|h,v| h[v.custom_field_id] = v.value; h}
                    issue.status = if options[:attributes] && options[:attributes][:status_id]
                                     IssueStatus.find_by_id(options[:attributes][:status_id])
                                   else
                                     self.status
                                   end
                  end
                  # Allow bulk setting of attributes on the issue
                  if options[:attributes]
                    issue.attributes = options[:attributes]
                  end
                  if issue.save
                    unless options[:copy]
                      # Manually update project_id on related time entries
                      TimeEntry.update_all("project_id = #{new_project.id}", {:issue_id => id})
                      issue.children.each do |child|
                        unless child.move_to_project_without_transaction(new_project)
                          # Move failed and transaction was rollback'd
                          return false
                        end
                      end
                    end
                  else
                    return false
                  end
                  issue
                end
                def status_id=(sid)
                  self.status = nil
                  write_attribute(:status_id, sid)
                end
                def priority_id=(pid)
                  self.priority = nil
                  write_attribute(:priority_id, pid)
                end
                def tracker_id=(tid)
                  self.tracker = nil
                  result = write_attribute(:tracker_id, tid)
                  @custom_field_values = nil
                  result
                end
                # Overrides attributes= so that tracker_id gets assigned first
                def attributes_with_tracker_first=(new_attributes, *args)
                  return if new_attributes.nil?
                  new_tracker_id = new_attributes['tracker_id'] || new_attributes[:tracker_id]
                  if new_tracker_id
                    self.tracker_id = new_tracker_id
                  end
                  send :attributes_without_tracker_first=, new_attributes, *args
                end
                # Do not redefine alias chain on reload (see #4838)
                alias_method_chain(:attributes=, :tracker_first) unless method_defined?(:attributes_without_tracker_first=)
                def estimated_hours=(h)
                  write_attribute :estimated_hours, (h.is_a?(String) ? h.to_hours : h)
                end
                SAFE_ATTRIBUTES = %w(
                  tracker_id
                  status_id
                  parent_issue_id
                  category_id
                  assigned_to_id
                  priority_id
                  fixed_version_id
                  subject
                  description
                  start_date
                  due_date
                  done_ratio
                  estimated_hours
                  custom_field_values
                  lock_version
                ) unless const_defined?(:SAFE_ATTRIBUTES)
                SAFE_ATTRIBUTES_ON_TRANSITION = %w(
                  status_id
                  assigned_to_id
                  fixed_version_id
                  done_ratio
                ) unless const_defined?(:SAFE_ATTRIBUTES_ON_TRANSITION)
                # Safely sets attributes
                # Should be called from controllers instead of #attributes=
                # attr_accessible is too rough because we still want things like
                # Issue.new(:project => foo) to work
                # TODO: move workflow/permission checks from controllers to here
                def safe_attributes=(attrs, user=User.current)
                  return unless attrs.is_a?(Hash)
                  # User can change issue attributes only if he has :edit permission or if a workflow transition is allowed
                  if new_record? || user.allowed_to?(:edit_issues, project)
                    attrs = attrs.reject {|k,v| !SAFE_ATTRIBUTES.include?(k)}
                  elsif new_statuses_allowed_to(user).any?
                    attrs = attrs.reject {|k,v| !SAFE_ATTRIBUTES_ON_TRANSITION.include?(k)}
                  else
                    return
                  end
                  # Tracker must be set before since new_statuses_allowed_to depends on it.
                  if t = attrs.delete('tracker_id')
                    self.tracker_id = t
                  end
                  if attrs['status_id']
                    unless new_statuses_allowed_to(user).collect(&:id).include?(attrs['status_id'].to_i)
                      attrs.delete('status_id')
                    end
                  end
                  unless leaf?
                    attrs.reject! {|k,v| %w(priority_id done_ratio start_date due_date estimated_hours).include?(k)}
                  end
                  if attrs.has_key?('parent_issue_id')
                    if !user.allowed_to?(:manage_subtasks, project)
                      attrs.delete('parent_issue_id')
                    elsif !attrs['parent_issue_id'].blank?
                      attrs.delete('parent_issue_id') unless Issue.visible(user).exists?(attrs['parent_issue_id'].to_i)
                    end
                  end
                  self.attributes = attrs
                end
                def done_ratio
                  if Issue.use_status_for_done_ratio? && status && status.default_done_ratio
                    status.default_done_ratio
                  else
                    read_attribute(:done_ratio)
                  end
                end
                def self.use_status_for_done_ratio?
                  Setting.issue_done_ratio == 'issue_status'
                end
                def self.use_field_for_done_ratio?
                  Setting.issue_done_ratio == 'issue_field'
                end
                def validate
                  if self.due_date.nil? && @attributes['due_date'] && !@attributes['due_date'].empty?
                    errors.add :due_date, :not_a_date
                  end
                  if self.due_date and self.start_date and self.due_date < self.start_date
                    errors.add :due_date, :greater_than_start_date
                  end
                  if start_date && soonest_start && start_date < soonest_start
                    errors.add :start_date, :invalid
                  end
                  if fixed_version
                    if !assignable_versions.include?(fixed_version)
                      errors.add :fixed_version_id, :inclusion
                    elsif reopened? && fixed_version.closed?
                      errors.add_to_base I18n.t(:error_can_not_reopen_issue_on_closed_version)
                    end
                  end
                  # Checks that the issue can not be added/moved to a disabled tracker
                  if project && (tracker_id_changed? || project_id_changed?)
                    unless project.trackers.include?(tracker)
                      errors.add :tracker_id, :inclusion
                    end
                  end
                  # Checks parent issue assignment
                  if @parent_issue
                    if @parent_issue.project_id != project_id
                      errors.add :parent_issue_id, :not_same_project
                    elsif !new_record?
                      # moving an existing issue
                      if @parent_issue.root_id != root_id
                        # we can always move to another tree
                      elsif move_possible?(@parent_issue)
                        # move accepted inside tree
                      else
                        errors.add :parent_issue_id, :not_a_valid_parent
                      end
                    end
                  end
                end
                # Set the done_ratio using the status if that setting is set.  This will keep the done_ratios
                # even if the user turns off the setting later
                def update_done_ratio_from_issue_status
                  if Issue.use_status_for_done_ratio? && status && status.default_done_ratio
                    self.done_ratio = status.default_done_ratio
                  end
                end
                def init_journal(user, notes = "")
                  @current_journal ||= Journal.new(:journalized => self, :user => user, :notes => notes)
                  @issue_before_change = self.clone
                  @issue_before_change.status = self.status
                  @custom_values_before_change = {}
                  self.custom_values.each {|c| @custom_values_before_change.store c.custom_field_id, c.value }
                  # Make sure updated_on is updated when adding a note.
                  updated_on_will_change!
                  @current_journal
                end
                # Return true if the issue is closed, otherwise false
                def closed?
                  self.status.is_closed?
                end
                # Return true if the issue is being reopened
                def reopened?
                  if !new_record? && status_id_changed?
                    status_was = IssueStatus.find_by_id(status_id_was)
                    status_new = IssueStatus.find_by_id(status_id)
                    if status_was && status_new && status_was.is_closed? && !status_new.is_closed?
                      return true
                    end
                  end
                  false
                end
                # Return true if the issue is being closed
                def closing?
                  if !new_record? && status_id_changed?
                    status_was = IssueStatus.find_by_id(status_id_was)
                    status_new = IssueStatus.find_by_id(status_id)
                    if status_was && status_new && !status_was.is_closed? && status_new.is_closed?
                      return true
                    end
                  end
                  false
                end
                # Returns true if the issue is overdue
                def overdue?
                  !due_date.nil? && (due_date < Date.today) && !status.is_closed?
                end
                # Is the amount of work done less than it should for the due date
                def behind_schedule?
                  return false if start_date.nil? || due_date.nil?
                  done_date = start_date + ((due_date - start_date+1)* done_ratio/100).floor
                  return done_date <= Date.today
                end
                # Does this issue have children?
                def children?
                  !leaf?
                end
                # Users the issue can be assigned to
                def assignable_users
                  users = project.assignable_users
                  users << author if author
                  users.uniq.sort
                end
                # Versions that the issue can be assigned to
                def assignable_versions
                  @assignable_versions ||= (project.shared_versions.open + [Version.find_by_id(fixed_version_id_was)]).compact.uniq.sort
                end
                # Returns true if this issue is blocked by another issue that is still open
                def blocked?
                  !relations_to.detect {|ir| ir.relation_type == 'blocks' && !ir.issue_from.closed?}.nil?
                end
                # Returns an array of status that user is able to apply
                def new_statuses_allowed_to(user, include_default=false)
                  statuses = status.find_new_statuses_allowed_to(user.roles_for_project(project), tracker)
                  statuses << status unless statuses.empty?
                  statuses << IssueStatus.default if include_default
                  statuses = statuses.uniq.sort
                  blocked? ? statuses.reject {|s| s.is_closed?} : statuses
                end
                # Returns the mail adresses of users that should be notified
                def recipients
                  notified = project.notified_users
                  # Author and assignee are always notified unless they have been
                  # locked or don't want to be notified
                  notified << author if author && author.active? && author.notify_about?(self)
                  notified << assigned_to if assigned_to && assigned_to.active? && assigned_to.notify_about?(self)
                  notified.uniq!
                  # Remove users that can not view the issue
                  notified.reject! {|user| !visible?(user)}
                  notified.collect(&:mail)
                end
                # Returns the total number of hours spent on this issue and its descendants
                #
                # Example:
                #   spent_hours => 0.0
                #   spent_hours => 50.2
                def spent_hours
                  @spent_hours ||= self_and_descendants.sum("#{TimeEntry.table_name}.hours", :include => :time_entries).to_f || 0.0
                end
                def relations
                  (relations_from + relations_to).sort
                end
                def all_dependent_issues
                  dependencies = []
                  relations_from.each do |relation|
                    dependencies << relation.issue_to
                    dependencies += relation.issue_to.all_dependent_issues
                  end
                  dependencies
                end
                # Returns an array of issues that duplicate this one
                def duplicates
                  relations_to.select {|r| r.relation_type == IssueRelation::TYPE_DUPLICATES}.collect {|r| r.issue_from}
                end
                # Returns the due date or the target due date if any
                # Used on gantt chart
                def due_before
                  due_date || (fixed_version ? fixed_version.effective_date : nil)
                end
                # Returns the time scheduled for this issue.
                #
                # Example:
                #   Start Date: 2/26/09, End Date: 3/04/09
                #   duration => 6
                def duration
                  (start_date && due_date) ? due_date - start_date : 0
                end
                def soonest_start
                  @soonest_start ||= (
                      relations_to.collect{|relation| relation.successor_soonest_start} +
                      ancestors.collect(&:soonest_start)
                    ).compact.max
                end
                def reschedule_after(date)
                  return if date.nil?
                  if leaf?
                    if start_date.nil? || start_date < date
                      self.start_date, self.due_date = date, date + duration
                      save
                    end
                  else
                    leaves.each do |leaf|
                      leaf.reschedule_after(date)
                    end
                  end
                end
                def <=>(issue)
                  if issue.nil?
                    -1
                  elsif root_id != issue.root_id
                    (root_id || 0) <=> (issue.root_id || 0)
                  else
                    (lft || 0) <=> (issue.lft || 0)
                  end
                end
                def to_s
                  "#{tracker} ##{id}: #{subject}"
                end
                # Returns a string of css classes that apply to the issue
                def css_classes
                  s = "issue status-#{status.position} priority-#{priority.position}"
                  s << ' closed' if closed?
                  s << ' overdue' if overdue?
                  s << ' created-by-me' if User.current.logged? && author_id == User.current.id
                  s << ' assigned-to-me' if User.current.logged? && assigned_to_id == User.current.id
                  s
                end
                # Saves an issue, time_entry, attachments, and a journal from the parameters
                # Returns false if save fails
                def save_issue_with_child_records(params, existing_time_entry=nil)
                  Issue.transaction do
                    if params[:time_entry] && params[:time_entry][:hours].present? && User.current.allowed_to?(:log_time, project)
                      @time_entry = existing_time_entry || TimeEntry.new
                      @time_entry.project = project
                      @time_entry.issue = self
                      @time_entry.user = User.current
                      @time_entry.spent_on = Date.today
                      @time_entry.attributes = params[:time_entry]
                      self.time_entries << @time_entry
                    end
                    if valid?
                      attachments = Attachment.attach_files(self, params[:attachments])
                      attachments[:files].each {|a| @current_journal.details << JournalDetail.new(:property => 'attachment', :prop_key => a.id, :value => a.filename)}
                      # TODO: Rename hook
                      Redmine::Hook.call_hook(:controller_issues_edit_before_save, { :params => params, :issue => self, :time_entry => @time_entry, :journal => @current_journal})
                      begin
                        if save
                          # TODO: Rename hook
                          Redmine::Hook.call_hook(:controller_issues_edit_after_save, { :params => params, :issue => self, :time_entry => @time_entry, :journal => @current_journal})
                        else
                          raise ActiveRecord::Rollback
                        end
                      rescue ActiveRecord::StaleObjectError
                        attachments[:files].each(&:destroy)
                        errors.add_to_base l(:notice_locking_conflict)
                        raise ActiveRecord::Rollback
                      end
                    end
                  end
                end
                # Unassigns issues from +version+ if it's no longer shared with issue's project
                def self.update_versions_from_sharing_change(version)
                  # Update issues assigned to the version
                  update_versions(["#{Issue.table_name}.fixed_version_id = ?", version.id])
                end
                # Unassigns issues from versions that are no longer shared
                # after +project+ was moved
                def self.update_versions_from_hierarchy_change(project)
                  moved_project_ids = project.self_and_descendants.reload.collect(&:id)
                  # Update issues of the moved projects and issues assigned to a version of a moved project
                  Issue.update_versions(["#{Version.table_name}.project_id IN (?) OR #{Issue.table_name}.project_id IN (?)", moved_project_ids, moved_project_ids])
                end
                def parent_issue_id=(arg)
                  parent_issue_id = arg.blank? ? nil : arg.to_i
                  if parent_issue_id && @parent_issue = Issue.find_by_id(parent_issue_id)
                    @parent_issue.id
                  else
                    @parent_issue = nil
                    nil
                  end
                end
                def parent_issue_id
                  if instance_variable_defined? :@parent_issue
                    @parent_issue.nil? ? nil : @parent_issue.id
                  else
                    parent_id
                  end
                end
                # Extracted from the ReportsController.
                def self.by_tracker(project)
                  count_and_group_by(:project => project,
                                     :field => 'tracker_id',
                                     :joins => Tracker.table_name)
                end
                def self.by_version(project)
                  count_and_group_by(:project => project,
                                     :field => 'fixed_version_id',
                                     :joins => Version.table_name)
                end
                def self.by_priority(project)
                  count_and_group_by(:project => project,
                                     :field => 'priority_id',
                                     :joins => IssuePriority.table_name)
                end
                def self.by_category(project)
                  count_and_group_by(:project => project,
                                     :field => 'category_id',
                                     :joins => IssueCategory.table_name)
                end
                def self.by_assigned_to(project)
                  count_and_group_by(:project => project,
                                     :field => 'assigned_to_id',
                                     :joins => User.table_name)
                end
                def self.by_author(project)
                  count_and_group_by(:project => project,
                                     :field => 'author_id',
                                     :joins => User.table_name)
                end
                def self.by_subproject(project)
                  ActiveRecord::Base.connection.select_all("select    s.id as status_id,
                                                              s.is_closed as closed,
                                                              i.project_id as project_id,
                                                              count(i.id) as total
                                                            from
                                                              #{Issue.table_name} i, #{IssueStatus.table_name} s
                                                            where
                                                              i.status_id=s.id
                                                              and i.project_id IN (#{project.descendants.active.collect{|p| p.id}.join(',')})
                                                            group by s.id, s.is_closed, i.project_id") if project.descendants.active.any?
                end
                # End ReportsController extraction
                # Returns an array of projects that current user can move issues to
                def self.allowed_target_projects_on_move
                  projects = []
                  if User.current.admin?
                    # admin is allowed to move issues to any active (visible) project
                    projects = Project.visible.all
                  elsif User.current.logged?
                    if Role.non_member.allowed_to?(:move_issues)
                      projects = Project.visible.all
                    else
                      User.current.memberships.each {|m| projects << m.project if m.roles.detect {|r| r.allowed_to?(:move_issues)}}
                    end
                  end
                  projects
                end
                private
                def update_nested_set_attributes
                  if root_id.nil?
                    # issue was just created
                    self.root_id = (@parent_issue.nil? ? id : @parent_issue.root_id)
                    set_default_left_and_right
                    Issue.update_all("root_id = #{root_id}, lft = #{lft}, rgt = #{rgt}", ["id = ?", id])
                    if @parent_issue
                      move_to_child_of(@parent_issue)
                    end
                    reload
                  elsif parent_issue_id != parent_id
                    former_parent_id = parent_id
                    # moving an existing issue
                    if @parent_issue && @parent_issue.root_id == root_id
                      # inside the same tree
                      move_to_child_of(@parent_issue)
                    else
                      # to another tree
                      unless root?
                        move_to_right_of(root)
                        reload
                      end
                      old_root_id = root_id
                      self.root_id = (@parent_issue.nil? ? id : @parent_issue.root_id )
                      target_maxright = nested_set_scope.maximum(right_column_name) || 0
                      offset = target_maxright + 1 - lft
                      Issue.update_all("root_id = #{root_id}, lft = lft + #{offset}, rgt = rgt + #{offset}",
                                        ["root_id = ? AND lft >= ? AND rgt <= ? ", old_root_id, lft, rgt])
                      self[left_column_name] = lft + offset
                      self[right_column_name] = rgt + offset
                      if @parent_issue
                        move_to_child_of(@parent_issue)
                      end
                    end
                    reload
                    # delete invalid relations of all descendants
                    self_and_descendants.each do |issue|
                      issue.relations.each do |relation|
                        relation.destroy unless relation.valid?
                      end
                    end
                    # update former parent
                    recalculate_attributes_for(former_parent_id) if former_parent_id
                  end
                  remove_instance_variable(:@parent_issue) if instance_variable_defined?(:@parent_issue)
                end
                def update_parent_attributes
                  recalculate_attributes_for(parent_id) if parent_id
                end
                def recalculate_attributes_for(issue_id)
                  if issue_id && p = Issue.find_by_id(issue_id)
                    # priority = highest priority of children
                    if priority_position = p.children.maximum("#{IssuePriority.table_name}.position", :include => :priority)
                      p.priority = IssuePriority.find_by_position(priority_position)
                    end
                    # start/due dates = lowest/highest dates of children
                    p.start_date = p.children.minimum(:start_date)
                    p.due_date = p.children.maximum(:due_date)
                    if p.start_date && p.due_date && p.due_date < p.start_date
                      p.start_date, p.due_date = p.due_date, p.start_date
                    end
                    # done ratio = weighted average ratio of leaves
                    unless Issue.use_status_for_done_ratio? && p.status && p.status.default_done_ratio
                      leaves_count = p.leaves.count
                      if leaves_count > 0
                        average = p.leaves.average(:estimated_hours).to_f
                        if average == 0
                          average = 1
                        end
                        done = p.leaves.sum("COALESCE(estimated_hours, #{average}) * (CASE WHEN is_closed = #{connection.quoted_true} THEN 100 ELSE COALESCE(done_ratio, 0) END)", :include => :status).to_f
                        progress = done / (average * leaves_count)
                        p.done_ratio = progress.round
                      end
                    end
                    # estimate = sum of leaves estimates
                    p.estimated_hours = p.leaves.sum(:estimated_hours).to_f
                    p.estimated_hours = nil if p.estimated_hours == 0.0
                    # ancestors will be recursively updated
                    p.save(false)
                  end
                end
                def destroy_children
                  unless leaf?
                    children.each do |child|
                      child.destroy
                    end
                  end
                end
                # Update issues so their versions are not pointing to a
                # fixed_version that is not shared with the issue's project
                def self.update_versions(conditions=nil)
                  # Only need to update issues with a fixed_version from
                  # a different project and that is not systemwide shared
                  Issue.all(:conditions => merge_conditions("#{Issue.table_name}.fixed_version_id IS NOT NULL" +
                                                              " AND #{Issue.table_name}.project_id <> #{Version.table_name}.project_id" +
                                                              " AND #{Version.table_name}.sharing <> 'system'",
                                                              conditions),
                            :include => [:project, :fixed_version]
                            ).each do |issue|
                    next if issue.project.nil? || issue.fixed_version.nil?
                    unless issue.project.shared_versions.include?(issue.fixed_version)
                      issue.init_journal(User.current)
                      issue.fixed_version = nil
                      issue.save
                    end
                  end
                end
                # Callback on attachment deletion
                def attachment_removed(obj)
                  journal = init_journal(User.current)
                  journal.details << JournalDetail.new(:property => 'attachment',
                                                       :prop_key => obj.id,
                                                       :old_value => obj.filename)
                  journal.save
                end
                # Default assignment based on category
                def default_assign
                  if assigned_to.nil? && category && category.assigned_to
                    self.assigned_to = category.assigned_to
                  end
                end
                # Updates start/due dates of following issues
                def reschedule_following_issues
                  if start_date_changed? || due_date_changed?
                    relations_from.each do |relation|
                      relation.set_issue_to_dates
                    end
                  end
                end
                # Closes duplicates if the issue is being closed
                def close_duplicates
                  if closing?
                    duplicates.each do |duplicate|
                      # Reload is need in case the duplicate was updated by a previous duplicate
                      duplicate.reload
                      # Don't re-close it if it's already closed
                      next if duplicate.closed?
                      # Same user and notes
                      if @current_journal
                        duplicate.init_journal(@current_journal.user, @current_journal.notes)
                      end
                      duplicate.update_attribute :status, self.status
                    end
                  end
                end
                # Saves the changes in a Journal
                # Called after_save
                def create_journal
                  if @current_journal
                    # attributes changes
                    (Issue.column_names - %w(id description root_id lft rgt lock_version created_on updated_on)).each {|c|
                      @current_journal.details << JournalDetail.new(:property => 'attr',
                                                                    :prop_key => c,
                                                                    :old_value => @issue_before_change.send(c),
                                                                    :value => send(c)) unless send(c)==@issue_before_change.send(c)
                    }
                    # custom fields changes
                    custom_values.each {|c|
                      next if (@custom_values_before_change[c.custom_field_id]==c.value ||
                                (@custom_values_before_change[c.custom_field_id].blank? && c.value.blank?))
                      @current_journal.details << JournalDetail.new(:property => 'cf',
                                                                    :prop_key => c.custom_field_id,
                                                                    :old_value => @custom_values_before_change[c.custom_field_id],
                                                                    :value => c.value)
                    }
                    @current_journal.save
                    # reset current journal
                    init_journal @current_journal.user, @current_journal.notes
                  end
                end
                # Query generator for selecting groups of issue counts for a project
                # based on specific criteria
                #
                # Options
                # * project - Project to search in.
                # * field - String. Issue field to key off of in the grouping.
                # * joins - String. The table name to join against.
                def self.count_and_group_by(options)
                  project = options.delete(:project)
                  select_field = options.delete(:field)
                  joins = options.delete(:joins)
                  where = "i.#{select_field}=j.id"
                  ActiveRecord::Base.connection.select_all("select    s.id as status_id,
                                                              s.is_closed as closed,
                                                              j.id as #{select_field},
                                                              count(i.id) as total
                                                            from
                                                                #{Issue.table_name} i, #{IssueStatus.table_name} s, #{joins} j
                                                            where
                                                              i.status_id=s.id
                                                              and #{where}
                                                              and i.project_id=#{project.id}
                                                            group by s.id, s.is_closed, j.id")
                end
              end

lib/redmine/helpers/gantt.rb +13 0

              # Redmine - project management software
              # Copyright (C) 2006-2008  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
                    # :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
                    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
                    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
                          ### Extracted from the HTML view/helpers
                    # Returns the number of rows that will be rendered on the Gantt chart
                    def number_of_rows
                      if @project
                        return number_of_rows_on_project(@project)
                      else
                        Project.roots.inject(0) do |total, project|
                          total += number_of_rows_on_project(project)
                        end
                      end
                    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)
                      # Remove the project requirement for Versions because it will
                      # restrict issues to only be on the current project.  This
                      # ends up missing issues which are assigned to shared versions.
                      @query.project = nil if @query.project
                      # One Root project
                      count = 1
                      # Issues without a Version
                      count += project.issues.for_gantt.without_version.with_query(@query).count
                      # Versions
                      count += project.versions.count
                      # Issues on the Versions
                      project.versions.each do |version|
                        count += version.fixed_issues.for_gantt.with_query(@query).count
                      end
                      # Subprojects
                      project.children.each do |subproject|
                        count += number_of_rows_on_project(subproject)
                      end
                      count
                    end
                    # Renders the subjects of the Gantt chart, the left side.
                    def subjects(options={})
                      options = {:indent => 4, :render => :subject, :format => :html}.merge(options)
                      output = ''
                      if @project
                        output << render_project(@project, options)
                      else
                        Project.roots.each do |project|
                          output << render_project(project, options)
                        end
                      end
                      output
                    end
                    # Renders the lines of the Gantt chart, the right side
                    def lines(options={})
                      options = {:indent => 4, :render => :line, :format => :html}.merge(options)
                      output = ''
                      if @project
                        output << render_project(@project, options)
                      else
                        Project.roots.each do |project|
                          output << render_project(project, options)
                        end
                      end
                      output
                    end
                    def render_project(project, options={})
                      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
                      output = ''
                      # Project Header
                      project_header = if options[:render] == :subject
                                         subject_for_project(project, options)
                                       else
                                         # :line
                                         line_for_project(project, options)
                                       end
                      output << project_header if options[:format] == :html
                      options[:top] += options[:top_increment]
                      options[:indent] += options[:indent_increment]
                      # Second, Issues without a version
                      issues = project.issues.for_gantt.without_version.with_query(@query)
+                     sort_issues!(issues)
                      if issues
                        issue_rendering = render_issues(issues, options)
                        output << issue_rendering if options[:format] == :html
                      end
                      # Third, Versions
                      project.versions.sort.each do |version|
                        version_rendering = render_version(version, options)
                        output << version_rendering if options[:format] == :html
                      end
                      # Fourth, subprojects
                      project.children.each do |project|
                        subproject_rendering = render_project(project, options)
                        output << subproject_rendering if options[:format] == :html
                      end
                      # Remove indent to hit the next sibling
                      options[:indent] -= options[:indent_increment]
                      output
                    end
                    def render_issues(issues, options={})
                      output = ''
                      issues.each do |i|
                        issue_rendering = if options[:render] == :subject
                                            subject_for_issue(i, options)
                                          else
                                            # :line
                                            line_for_issue(i, options)
                                          end
                        output << issue_rendering if options[:format] == :html
                        options[:top] += options[:top_increment]
                      end
                      output
                    end
                    def render_version(version, options={})
                      output = ''
                      # Version header
                      version_rendering = if options[:render] == :subject
                                            subject_for_version(version, options)
                                          else
                                            # :line
                                            line_for_version(version, options)
                                          end
                      output << version_rendering if options[:format] == :html
                      options[:top] += options[:top_increment]
                      # Remove the project requirement for Versions because it will
                      # restrict issues to only be on the current project.  This
                      # ends up missing issues which are assigned to shared versions.
                      @query.project = nil if @query.project
                      issues = version.fixed_issues.for_gantt.with_query(@query)
                      if issues
+                       sort_issues!(issues)
                        # Indent issues
                        options[:indent] += options[:indent_increment]
                        output << render_issues(issues, options)
                        options[:indent] -= options[:indent_increment]
                      end
                      output
                    end
                    def subject_for_project(project, options)
                      case options[:format]
                      when :html
                        output = ''
                        output << "<div class='project-name' style='position: absolute;line-height:1.2em;height:16px;top:#{options[:top]}px;left:#{options[:indent]}px;overflow:hidden;'><small>    "
                        if project.is_a? Project
                          output << "<span class='icon icon-projects #{project.overdue? ? 'project-overdue' : ''}'>"
                          output << view.link_to_project(project)
                          output << '</span>'
                        else
                          ActiveRecord::Base.logger.debug "Gantt#subject_for_project was not given a project"
                          ''
                        end
                        output << "</small></div>"
                        output
                      when :image
                        options[:image].fill('black')
                        options[:image].stroke('transparent')
                        options[:image].stroke_width(1)
                        options[:image].text(options[:indent], options[:top] + 2, project.name)
                      when :pdf
                        options[:pdf].SetY(options[:top])
                        options[:pdf].SetX(15)
                        char_limit = PDF::MaxCharactorsForSubject - options[:indent]
                        options[:pdf].Cell(options[:subject_width]-15, 5, (" " * options[:indent]) +"#{project.name}".sub(/^(.{#{char_limit}}[^\s]*\s).*$/, '\1 (...)'), "LR")
                        options[:pdf].SetY(options[:top])
                        options[:pdf].SetX(options[:subject_width])
                        options[:pdf].Cell(options[:g_width], 5, "", "LR")
                      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]
                        case options[:format]
                        when :html
                          output = ''
                          i_left = ((project.start_date - self.date_from)*options[:zoom]).floor
                          start_date = project.start_date
                          start_date ||= self.date_from
                          start_left = ((start_date - self.date_from)*options[:zoom]).floor
                          i_end_date = ((project.due_date <= self.date_to) ? project.due_date : self.date_to )
                          i_done_date = start_date + ((project.due_date - start_date+1)* project.completed_percent(:include_subprojects => true)/100).floor
                          i_done_date = (i_done_date <= self.date_from ? self.date_from : i_done_date )
                          i_done_date = (i_done_date >= self.date_to ? self.date_to : i_done_date )
                          i_late_date = [i_end_date, Date.today].min if start_date < Date.today
                          i_end = ((i_end_date - self.date_from) * options[:zoom]).floor
                          i_width = (i_end - i_left + 1).floor - 2                  # total width of the issue (- 2 for left and right borders)
                          d_width = ((i_done_date - start_date)*options[:zoom]).floor - 2                     # done width
                          l_width = i_late_date ? ((i_late_date - start_date+1)*options[:zoom]).floor - 2 : 0 # delay width
                          # Bar graphic
                          # Make sure that negative i_left and i_width don't
                          # overflow the subject
                          if i_end > 0 && i_left <= options[:g_width]
                            output << "<div style='top:#{ options[:top] }px;left:#{ start_left }px;width:#{ i_width }px;' class='task project_todo'>&nbsp;</div>"
                          end
                          if l_width > 0 && i_left <= options[:g_width]
                            output << "<div style='top:#{ options[:top] }px;left:#{ start_left }px;width:#{ l_width }px;' class='task project_late'>&nbsp;</div>"
                          end
                          if d_width > 0 && i_left <= options[:g_width]
                            output<< "<div style='top:#{ options[:top] }px;left:#{ start_left }px;width:#{ d_width }px;' class='task project_done'>&nbsp;</div>"
                          end
                          # Starting diamond
                          if start_left <= options[:g_width] && start_left > 0
                            output << "<div style='top:#{ options[:top] }px;left:#{ start_left }px;width:15px;' class='task project-line starting'>&nbsp;</div>"
                            output << "<div style='top:#{ options[:top] }px;left:#{ start_left + 12 }px;' class='task label'>"
                            output << "</div>"
                          end
                          # Ending diamond
                          # Don't show items too far ahead
                          if i_end <= options[:g_width] && i_end > 0
                            output << "<div style='top:#{ options[:top] }px;left:#{ i_end }px;width:15px;' class='task project-line ending'>&nbsp;</div>"
                          end
                          # DIsplay the Project name and %
                          if i_end <= options[:g_width]
                            # Display the status even if it's floated off to the left
                            status_px = i_end + 12 # 12px for the diamond
                            status_px = 0 if status_px <= 0
                            output << "<div style='top:#{ options[:top] }px;left:#{ status_px }px;' class='task label project-name'>"
                            output << "<strong>#{h project } #{h project.completed_percent(:include_subprojects => true).to_i.to_s}%</strong>"
                            output << "</div>"
                          end
                          output
                        when :image
                          options[:image].stroke('transparent')
                          i_left = options[:subject_width] + ((project.due_date - self.date_from)*options[:zoom]).floor
                          # Make sure negative i_left doesn't overflow the subject
                          if i_left > options[:subject_width]
                            options[:image].fill('blue')
                            options[:image].rectangle(i_left, options[:top], i_left + 6, options[:top] - 6)
                            options[:image].fill('black')
                            options[:image].text(i_left + 11, options[:top] + 1, project.name)
                          end
                        when :pdf
                          options[:pdf].SetY(options[:top]+1.5)
                          i_left = ((project.due_date - @date_from)*options[:zoom])
                          # Make sure negative i_left doesn't overflow the subject
                          if i_left > 0
                            options[:pdf].SetX(options[:subject_width] + i_left)
                            options[:pdf].SetFillColor(50,50,200)
                            options[:pdf].Cell(2, 2, "", 0, 0, "", 1)
                            options[:pdf].SetY(options[:top]+1.5)
                            options[:pdf].SetX(options[:subject_width] + i_left + 3)
                            options[:pdf].Cell(30, 2, "#{project.name}")
                          end
                        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
                        output = ''
                        output << "<div class='version-name' style='position: absolute;line-height:1.2em;height:16px;top:#{options[:top]}px;left:#{options[:indent]}px;overflow:hidden;'><small>    "
                        if version.is_a? Version
                          output << "<span class='icon icon-package #{version.behind_schedule? ? 'version-behind-schedule' : ''} #{version.overdue? ? 'version-overdue' : ''}'>"
                          output << view.link_to_version(version)
                          output << '</span>'
                        else
                          ActiveRecord::Base.logger.debug "Gantt#subject_for_version was not given a version"
                          ''
                        end
                        output << "</small></div>"
                        output
                      when :image
                        options[:image].fill('black')
                        options[:image].stroke('transparent')
                        options[:image].stroke_width(1)
                        options[:image].text(options[:indent], options[:top] + 2, version.to_s_with_project)
                      when :pdf
                        options[:pdf].SetY(options[:top])
                        options[:pdf].SetX(15)
                        char_limit = PDF::MaxCharactorsForSubject - options[:indent]
                        options[:pdf].Cell(options[:subject_width]-15, 5, (" " * options[:indent]) +"#{version.to_s_with_project}".sub(/^(.{#{char_limit}}[^\s]*\s).*$/, '\1 (...)'), "LR")
                        options[:pdf].SetY(options[:top])
                        options[:pdf].SetX(options[:subject_width])
                        options[:pdf].Cell(options[:g_width], 5, "", "LR")
                      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]
                        case options[:format]
                        when :html
                          output = ''
                          i_left = ((version.start_date - self.date_from)*options[:zoom]).floor
                          # TODO: or version.fixed_issues.collect(&:start_date).min
                          start_date = version.fixed_issues.minimum('start_date') if version.fixed_issues.present?
                          start_date ||= self.date_from
                          start_left = ((start_date - self.date_from)*options[:zoom]).floor
                          i_end_date = ((version.due_date <= self.date_to) ? version.due_date : self.date_to )
                          i_done_date = start_date + ((version.due_date - start_date+1)* version.completed_pourcent/100).floor
                          i_done_date = (i_done_date <= self.date_from ? self.date_from : i_done_date )
                          i_done_date = (i_done_date >= self.date_to ? self.date_to : i_done_date )
                          i_late_date = [i_end_date, Date.today].min if start_date < Date.today
                          i_width = (i_left - start_left + 1).floor - 2                  # total width of the issue (- 2 for left and right borders)
                          d_width = ((i_done_date - start_date)*options[:zoom]).floor - 2                     # done width
                          l_width = i_late_date ? ((i_late_date - start_date+1)*options[:zoom]).floor - 2 : 0 # delay width
                          i_end = ((i_end_date - self.date_from) * options[:zoom]).floor # Ending pixel
                          # Bar graphic
                          # Make sure that negative i_left and i_width don't
                          # overflow the subject
                          if i_width > 0 && i_left <= options[:g_width]
                            output << "<div style='top:#{ options[:top] }px;left:#{ start_left }px;width:#{ i_width }px;' class='task milestone_todo'>&nbsp;</div>"
                          end
                          if l_width > 0 && i_left <= options[:g_width]
                            output << "<div style='top:#{ options[:top] }px;left:#{ start_left }px;width:#{ l_width }px;' class='task milestone_late'>&nbsp;</div>"
                          end
                          if d_width > 0 && i_left <= options[:g_width]
                            output<< "<div style='top:#{ options[:top] }px;left:#{ start_left }px;width:#{ d_width }px;' class='task milestone_done'>&nbsp;</div>"
                          end
                          # Starting diamond
                          if start_left <= options[:g_width] && start_left > 0
                            output << "<div style='top:#{ options[:top] }px;left:#{ start_left }px;width:15px;' class='task milestone starting'>&nbsp;</div>"
                            output << "<div style='top:#{ options[:top] }px;left:#{ start_left + 12 }px;background:#fff;' class='task'>"
                            output << "</div>"
                          end
                          # Ending diamond
                          # Don't show items too far ahead
                          if i_left <= options[:g_width] && i_end > 0
                            output << "<div style='top:#{ options[:top] }px;left:#{ i_end }px;width:15px;' class='task milestone ending'>&nbsp;</div>"
                          end
                          # Display the Version name and %
                          if i_end <= options[:g_width]
                            # Display the status even if it's floated off to the left
                            status_px = i_end + 12 # 12px for the diamond
                            status_px = 0 if status_px <= 0
                            output << "<div style='top:#{ options[:top] }px;left:#{ status_px }px;' class='task label version-name'>"
                            output << h("#{version.project} -") unless @project && @project == version.project
                            output << "<strong>#{h version } #{h version.completed_pourcent.to_i.to_s}%</strong>"
                            output << "</div>"
                          end
                          output
                        when :image
                          options[:image].stroke('transparent')
                          i_left = options[:subject_width] + ((version.start_date - @date_from)*options[:zoom]).floor
                          # Make sure negative i_left doesn't overflow the subject
                          if i_left > options[:subject_width]
                            options[:image].fill('green')
                            options[:image].rectangle(i_left, options[:top], i_left + 6, options[:top] - 6)
                            options[:image].fill('black')
                            options[:image].text(i_left + 11, options[:top] + 1, version.name)
                          end
                        when :pdf
                          options[:pdf].SetY(options[:top]+1.5)
                          i_left = ((version.start_date - @date_from)*options[:zoom])
                          # Make sure negative i_left doesn't overflow the subject
                          if i_left > 0
                            options[:pdf].SetX(options[:subject_width] + i_left)
                            options[:pdf].SetFillColor(50,200,50)
                            options[:pdf].Cell(2, 2, "", 0, 0, "", 1)
                            options[:pdf].SetY(options[:top]+1.5)
                            options[:pdf].SetX(options[:subject_width] + i_left + 3)
                            options[:pdf].Cell(30, 2, "#{version.name}")
                          end
                        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)
                      case options[:format]
                      when :html
                        output = ''
                        output << "<div class='tooltip'>"
                        output << "<div class='issue-subject' style='position: absolute;line-height:1.2em;height:16px;top:#{options[:top]}px;left:#{options[:indent]}px;overflow:hidden;'><small>    "
                        if issue.is_a? Issue
                          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
                          if issue.assigned_to.present?
                            assigned_string = l(:field_assigned_to) + ": " + issue.assigned_to.name
                            output << view.avatar(issue.assigned_to, :class => 'gravatar icon-gravatar', :size => 10, :title => assigned_string)
                          end
                          output << "<span class='#{css_classes.join(' ')}'>"
                          output << view.link_to_issue(issue)
                          output << '</span>'
                        else
                          ActiveRecord::Base.logger.debug "Gantt#subject_for_issue was not given an issue"
                          ''
                        end
                        output << "</small></div>"
                        # Tooltip
                        if issue.is_a? Issue
                          output << "<span class='tip' style='position: absolute;top:#{ options[:top].to_i + 16 }px;left:#{ options[:indent].to_i + 20 }px;'>"
                          output << view.render_issue_tooltip(issue)
                          output << "</span>"
                        end
                        output << "</div>"
                        output
                      when :image
                        options[:image].fill('black')
                        options[:image].stroke('transparent')
                        options[:image].stroke_width(1)
                        options[:image].text(options[:indent], options[:top] + 2, issue.subject)
                      when :pdf
                        options[:pdf].SetY(options[:top])
                        options[:pdf].SetX(15)
                        char_limit = PDF::MaxCharactorsForSubject - options[:indent]
                        options[:pdf].Cell(options[:subject_width]-15, 5, (" " * options[:indent]) +"#{issue.tracker} #{issue.id}: #{issue.subject}".sub(/^(.{#{char_limit}}[^\s]*\s).*$/, '\1 (...)'), "LR")
                        options[:pdf].SetY(options[:top])
                        options[:pdf].SetX(options[:subject_width])
                        options[:pdf].Cell(options[:g_width], 5, "", "LR")
                      end
                    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
                        case options[:format]
                        when :html
                          output = ''
                          # Handle nil start_dates, rare but can happen.
                          i_start_date =  if issue.start_date && issue.start_date >= self.date_from
                                            issue.start_date
                                          else
                                            self.date_from
                                          end
                          i_end_date = ((issue.due_before && issue.due_before <= self.date_to) ? issue.due_before : self.date_to )
                          i_done_date = i_start_date + ((issue.due_before - i_start_date+1)*issue.done_ratio/100).floor
                          i_done_date = (i_done_date <= self.date_from ? self.date_from : i_done_date )
                          i_done_date = (i_done_date >= self.date_to ? self.date_to : i_done_date )
                          i_late_date = [i_end_date, Date.today].min if i_start_date < Date.today
                          i_left = ((i_start_date - self.date_from)*options[:zoom]).floor
                          i_width = ((i_end_date - i_start_date + 1)*options[:zoom]).floor - 2                  # total width of the issue (- 2 for left and right borders)
                          d_width = ((i_done_date - i_start_date)*options[:zoom]).floor - 2                     # done width
                          l_width = i_late_date ? ((i_late_date - i_start_date+1)*options[:zoom]).floor - 2 : 0 # delay width
                          css = "task " + (issue.leaf? ? 'leaf' : 'parent')
                          # Make sure that negative i_left and i_width don't
                          # overflow the subject
                          if i_width > 0
                            output << "<div style='top:#{ options[:top] }px;left:#{ i_left }px;width:#{ i_width }px;' class='#{css} task_todo'>&nbsp;</div>"
                          end
                          if l_width > 0
                            output << "<div style='top:#{ options[:top] }px;left:#{ i_left }px;width:#{ l_width }px;' class='#{css} task_late'>&nbsp;</div>"
                          end
                          if d_width > 0
                            output<< "<div style='top:#{ options[:top] }px;left:#{ i_left }px;width:#{ d_width }px;' class='#{css} task_done'>&nbsp;</div>"
                          end
                          # Display the status even if it's floated off to the left
                          status_px = i_left + i_width + 5
                          status_px = 5 if status_px <= 0
                          output << "<div style='top:#{ options[:top] }px;left:#{ status_px }px;' class='#{css} label issue-name'>"
                          output << issue.status.name
                          output << ' '
                          output << (issue.done_ratio).to_i.to_s
                          output << "%"
                          output << "</div>"
                          output << "<div class='tooltip' style='position: absolute;top:#{ options[:top] }px;left:#{ i_left }px;width:#{ i_width }px;height:12px;'>"
                          output << '<span class="tip">'
                          output << view.render_issue_tooltip(issue)
                          output << "</span></div>"
                          output
                        when :image
                          # Handle nil start_dates, rare but can happen.
                          i_start_date =  if issue.start_date && issue.start_date >= @date_from
                                            issue.start_date
                                          else
                                            @date_from
                                          end
                          i_end_date = (issue.due_before <= date_to ? issue.due_before : date_to )
                          i_done_date = i_start_date + ((issue.due_before - i_start_date+1)*issue.done_ratio/100).floor
                          i_done_date = (i_done_date <= @date_from ? @date_from : i_done_date )
                          i_done_date = (i_done_date >= date_to ? date_to : i_done_date )
                          i_late_date = [i_end_date, Date.today].min if i_start_date < Date.today
                          i_left = options[:subject_width] + ((i_start_date - @date_from)*options[:zoom]).floor
                          i_width = ((i_end_date - i_start_date + 1)*options[:zoom]).floor                  # total width of the issue
                          d_width = ((i_done_date - i_start_date)*options[:zoom]).floor                     # done width
                          l_width = i_late_date ? ((i_late_date - i_start_date+1)*options[:zoom]).floor : 0 # delay width
                          # Make sure that negative i_left and i_width don't
                          # overflow the subject
                          if i_width > 0
                            options[:image].fill('grey')
                            options[:image].rectangle(i_left, options[:top], i_left + i_width, options[:top] - 6)
                            options[:image].fill('red')
                            options[:image].rectangle(i_left, options[:top], i_left + l_width, options[:top] - 6) if l_width > 0
                            options[:image].fill('blue')
                            options[:image].rectangle(i_left, options[:top], i_left + d_width, options[:top] - 6) if d_width > 0
                          end
                          # Show the status and % done next to the subject if it overflows
                          options[:image].fill('black')
                          if i_width > 0
                            options[:image].text(i_left + i_width + 5,options[:top] + 1, "#{issue.status.name} #{issue.done_ratio}%")
                          else
                            options[:image].text(options[:subject_width] + 5,options[:top] + 1, "#{issue.status.name} #{issue.done_ratio}%")
                          end
                        when :pdf
                          options[:pdf].SetY(options[:top]+1.5)
                          # Handle nil start_dates, rare but can happen.
                          i_start_date =  if issue.start_date && issue.start_date >= @date_from
                                        issue.start_date
                                      else
                                        @date_from
                                      end
                          i_end_date = (issue.due_before <= @date_to ? issue.due_before : @date_to )
                          i_done_date = i_start_date + ((issue.due_before - i_start_date+1)*issue.done_ratio/100).floor
                          i_done_date = (i_done_date <= @date_from ? @date_from : i_done_date )
                          i_done_date = (i_done_date >= @date_to ? @date_to : i_done_date )
                          i_late_date = [i_end_date, Date.today].min if i_start_date < Date.today
                          i_left = ((i_start_date - @date_from)*options[:zoom])
                          i_width = ((i_end_date - i_start_date + 1)*options[:zoom])
                          d_width = ((i_done_date - i_start_date)*options[:zoom])
                          l_width = ((i_late_date - i_start_date+1)*options[:zoom]) if i_late_date
                          l_width ||= 0
                          # Make sure that negative i_left and i_width don't
                          # overflow the subject
                          if i_width > 0
                            options[:pdf].SetX(options[:subject_width] + i_left)
                            options[:pdf].SetFillColor(200,200,200)
                            options[:pdf].Cell(i_width, 2, "", 0, 0, "", 1)
                          end
                          if l_width > 0
                            options[:pdf].SetY(options[:top]+1.5)
                            options[:pdf].SetX(options[:subject_width] + i_left)
                            options[:pdf].SetFillColor(255,100,100)
                            options[:pdf].Cell(l_width, 2, "", 0, 0, "", 1)
                          end
                          if d_width > 0
                            options[:pdf].SetY(options[:top]+1.5)
                            options[:pdf].SetX(options[:subject_width] + i_left)
                            options[:pdf].SetFillColor(100,100,255)
                            options[:pdf].Cell(d_width, 2, "", 0, 0, "", 1)
                          end
                          options[:pdf].SetY(options[:top]+1.5)
                          # Make sure that negative i_left and i_width don't
                          # overflow the subject
                          if (i_left + i_width) >= 0
                            options[:pdf].SetX(options[:subject_width] + i_left + i_width)
                          else
                            options[:pdf].SetX(options[:subject_width])
                          end
                          options[:pdf].Cell(30, 2, "#{issue.status} #{issue.done_ratio}%")
                        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_heigth = 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_heigth = (show_weeks ? 2*header_heigth : header_heigth)
                      height = g_height + headers_heigth
                      imgl = Magick::ImageList.new
                      imgl.new_image(subject_width+g_width+1, height)
                      gc = Magick::Draw.new
                      # Subjects
                      subjects(:image => gc, :top => (headers_heigth + 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_heigth
                      	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_heigth, left + width, 2*header_heigth + 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_heigth, left.round + width, 2*header_heigth + g_height-1)
                              gc.fill('black')
                              gc.stroke('transparent')
                              gc.stroke_width(1)
                              gc.text(left.round + 2, header_heigth + 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_heigth - 1
                      	wday = @date_from.cwday
                      	(date_to - @date_from + 1).to_i.times do
                            width =  zoom
                            gc.fill(wday == 6 || wday == 7 ? '#eee' : 'white')
                            gc.stroke('grey')
                            gc.stroke_width(1)
                            gc.rectangle(left, 2*header_heigth, left + width, 2*header_heigth + 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_heigth)
                      gc.stroke('black')
                      gc.rectangle(0, 0, subject_width+g_width, g_height+ headers_heigth-1)
                      # content
                      top = headers_heigth + 20
                      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_heigth, x, headers_heigth + 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::IFPDF.new(current_language)
                      pdf.SetTitle("#{l(:label_gantt)} #{project}")
                      pdf.AliasNbPages
                      pdf.footer_date = format_date(Date.today)
                      pdf.AddPage("L")
                      pdf.SetFontStyle('B',12)
                      pdf.SetX(15)
                      pdf.Cell(PDF::LeftPaneWidth, 20, project.to_s)
                      pdf.Ln
                      pdf.SetFontStyle('B',9)
                      subject_width = PDF::LeftPaneWidth
                      header_heigth = 5
                      headers_heigth = header_heigth
                      show_weeks = false
                      show_days = false
                      if self.months < 7
                        show_weeks = true
                        headers_heigth = 2*header_heigth
                        if self.months < 3
                          show_days = true
                          headers_heigth = 3*header_heigth
                        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_heigth
                      y_start = pdf.GetY
                      # Months headers
                      month_f = self.date_from
                      left = subject_width
                      height = header_heigth
                      self.months.times do
                        width = ((month_f >> 1) - month_f) * zoom
                        pdf.SetY(y_start)
                        pdf.SetX(left)
                        pdf.Cell(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_heigth
                        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_heigth)
                          pdf.SetX(left)
                          pdf.Cell(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_heigth)
                          pdf.SetX(left)
                          pdf.Cell(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_heigth
                        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_heigth)
                          pdf.SetX(left)
                          pdf.Cell(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.Cell(subject_width+g_width-15, headers_heigth, "", 1)
                      # Tasks
                      top = headers_heigth + y_start
                      pdf_subjects_and_lines(pdf, {
                                               :top => top,
                                               :zoom => zoom,
                                               :subject_width => subject_width,
                                               :g_width => g_width
                                             })
                      pdf.Line(15, top, subject_width+g_width, top)
                      pdf.Output
                    end
                    private
+                   # Sorts a collection of issues by start_date, due_date, id for gantt rendering
+                   def sort_issues!(issues)
+                     issues.sort! do |a, b|
+                       cmp = 0
+                       cmp = (a.start_date <=> b.start_date) if a.start_date? && b.start_date?
+                       cmp = (a.due_date <=> b.due_date) if cmp == 0 && a.due_date? && b.due_date?
+                       cmp = (a.id <=> b.id) if cmp == 0
+                       cmp
+                     end
+                   end
                    # Renders both the subjects and lines of the Gantt chart for the
                    # PDF format
                    def pdf_subjects_and_lines(pdf, options = {})
                      subject_options = {:indent => 0, :indent_increment => 5, :top_increment => 3, :render => :subject, :format => :pdf, :pdf => pdf}.merge(options)
                      line_options = {:indent => 0, :indent_increment => 5, :top_increment => 3, :render => :line, :format => :pdf, :pdf => pdf}.merge(options)
                      if @project
                        render_project(@project, subject_options)
                        render_project(@project, line_options)
                      else
                        Project.roots.each do |project|
                          render_project(project, subject_options)
                          render_project(project, line_options)
                        end
                      end
                    end
                  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