Redmine

# frozen_string_literal: true

# Redmine - project management software

# Copyright (C) 2006-  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

  include Redmine::SafeAttributes

  include Redmine::Utils::DateCalculation

  include Redmine::I18n

  before_save :set_parent_id

  include Redmine::NestedSet::IssueNestedSet

  belongs_to :project

  belongs_to :tracker

  belongs_to :status, :class_name => 'IssueStatus'

  belongs_to :author, :class_name => 'User'

  belongs_to :assigned_to, :class_name => 'Principal'

  belongs_to :fixed_version, :class_name => 'Version'

  belongs_to :priority, :class_name => 'IssuePriority'

  belongs_to :category, :class_name => 'IssueCategory'

  has_many :journals, :as => :journalized, :dependent => :destroy, :inverse_of => :journalized

  has_many :time_entries, :dependent => :destroy

  has_and_belongs_to_many :changesets, lambda {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_attachable :after_add => :attachment_added, :after_remove => :attachment_removed

  acts_as_customizable

  acts_as_watchable

  acts_as_searchable :columns => ['subject', "#{table_name}.description"],

                     :preload => [:project, :status, :tracker],

                     :scope => lambda {|options| options[:open_issues] ? self.open : self.all}

  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 :scope => proc {preload(:project, :author, :tracker, :status)},

                            :author_key => :author_id

  acts_as_mentionable :attributes => ['description']

  DONE_RATIO_OPTIONS = %w(issue_field issue_status)

  attr_reader :transition_warning

  attr_writer :deleted_attachment_ids

  delegate :notes, :notes=, :private_notes, :private_notes=, :to => :current_journal, :allow_nil => true

  validates_presence_of :subject, :project, :tracker

  validates_presence_of :priority, :if => Proc.new {|issue| issue.new_record? || issue.priority_id_changed?}

  validates_presence_of :status, :if => Proc.new {|issue| issue.new_record? || issue.status_id_changed?}

  validates_presence_of :author, :if => Proc.new {|issue| issue.new_record? || issue.author_id_changed?}

  validates_length_of :subject, :maximum => 255

  validates_inclusion_of :done_ratio, :in => 0..100

  validates :estimated_hours, :numericality => {:greater_than_or_equal_to => 0, :allow_nil => true, :message => :invalid}

  validates :start_date, :date => true

  validates :due_date, :date => true

  validate :validate_issue, :validate_required_fields, :validate_permissions

  scope :visible, (lambda do |*args|

    joins(:project).

    where(Issue.visible_condition(args.shift || User.current, *args))

  end)

  scope :open, (lambda do |*args|

    is_closed = !args.empty? ? !args.first : false

    joins(:status).

    where(:issue_statuses => {:is_closed => is_closed})

  end)

  scope :recently_updated, lambda {order(:updated_on => :desc)}

  scope :on_active_project, (lambda do

    joins(:project).

    where(:projects => {:status => Project::STATUS_ACTIVE})

  end)

  scope :fixed_version, (lambda do |versions|

    ids = [versions].flatten.compact.map {|v| v.is_a?(Version) ? v.id : v}

    ids.any? ? where(:fixed_version_id => ids) : none

  end)

  scope :assigned_to, (lambda do |arg|

    arg = Array(arg).uniq

    ids = arg.map {|p| p.is_a?(Principal) ? p.id : p}

    ids += arg.select {|p| p.is_a?(User)}.map(&:group_ids).flatten.uniq

    ids.compact!

    ids.any? ? where(:assigned_to_id => ids) : none

  end)

  scope :like, (lambda do |q|

    if q.present?

      where(*::Query.tokenized_like_conditions("#{table_name}.subject", q))

    end

  end)

  before_validation :default_assign, on: :create

  before_validation :clear_disabled_fields

  before_save :close_duplicates, :update_done_ratio_from_issue_status,

              :force_updated_on_change, :update_closed_on

  after_save do |issue|

    if !issue.saved_change_to_id? && issue.saved_change_to_project_id?

      issue.send :after_project_change

    end

  end

  after_save :reschedule_following_issues, :update_nested_set_attributes,

             :update_parent_attributes, :delete_selected_attachments, :create_journal

  # Should be after_create but would be called before previous after_save callbacks

  after_save :after_create_from_copy

  after_destroy :update_parent_attributes

  # add_auto_watcher needs to run before sending notifications, thus it needs

  # to be added after send_notification (after_ callbacks are run in inverse order)

  # https://api.rubyonrails.org/v5.2.3/classes/ActiveSupport/Callbacks/ClassMethods.html#method-i-set_callback

  after_create_commit :send_notification

  after_create_commit :add_auto_watcher

  after_commit :create_parent_issue_journal

  # Returns a SQL conditions string used to find all issues visible by the specified user

  def self.visible_condition(user, options={})

    Project.allowed_to_condition(user, :view_issues, options) do |role, user|

      sql =

        if user.id && user.logged?

          case role.issues_visibility

          when 'all'

            '1=1'

          when 'default'

            user_ids = [user.id] + user.groups.pluck(:id).compact

            "(#{table_name}.is_private = #{connection.quoted_false} " \

              "OR #{table_name}.author_id = #{user.id} " \

              "OR #{table_name}.assigned_to_id IN (#{user_ids.join(',')}))"

          when 'own'

            user_ids = [user.id] + user.groups.pluck(:id).compact

            "(#{table_name}.author_id = #{user.id} OR " \

              "#{table_name}.assigned_to_id IN (#{user_ids.join(',')}))"

          else

            '1=0'

          end

        else

          "(#{table_name}.is_private = #{connection.quoted_false})"

        end

      unless role.permissions_all_trackers?(:view_issues)

        tracker_ids = role.permissions_tracker_ids(:view_issues)

        if tracker_ids.any?

          sql = "(#{sql} AND #{table_name}.tracker_id IN (#{tracker_ids.join(',')}))"

        else

          sql = '1=0'

        end

      end

      sql

    end

  end

  # 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) do |role, user|

      visible =

        if user.logged?

          case role.issues_visibility

          when 'all'

            true

          when 'default'

            !self.is_private? || (self.author == user || user.is_or_belongs_to?(assigned_to))

          when 'own'

            self.author == user || user.is_or_belongs_to?(assigned_to)

          else

            false

          end

        else

          !self.is_private?

        end

      unless role.permissions_all_trackers?(:view_issues)

        visible &&= role.permissions_tracker_ids?(:view_issues, tracker_id)

      end

      visible

    end

  end

  # Returns true if user or current user is allowed to edit or add notes to the issue

  def editable?(user=User.current)

    attributes_editable?(user) || notes_addable?(user)

  end

  # Returns true if user or current user is allowed to edit the issue

  def attributes_editable?(user=User.current)

    user_tracker_permission?(user, :edit_issues) || (

      user_tracker_permission?(user, :edit_own_issues) && author == user

    )

  end

  def attachments_addable?(user=User.current)

    attributes_editable?(user) || notes_addable?(user)

  end

  # Overrides Redmine::Acts::Attachable::InstanceMethods#attachments_editable?

  def attachments_editable?(user=User.current)

    attributes_editable?(user)

  end

  # Returns true if user or current user is allowed to add notes to the issue

  def notes_addable?(user=User.current)

    user_tracker_permission?(user, :add_issue_notes)

  end

  # Returns true if user or current user is allowed to delete the issue

  def deletable?(user=User.current)

    user_tracker_permission?(user, :delete_issues)

  end

  # Overrides Redmine::Acts::Attachable::InstanceMethods#attachments_deletable?

  def attachments_deletable?(user=User.current)

    attributes_editable?(user)

  end

  def initialize(attributes=nil, *args)

    super

    if new_record?

      # set default values for new records only

      self.priority ||= IssuePriority.default

      self.watcher_user_ids = []

    end

  end

  def create_or_update(*args)

    super()

  ensure

    @status_was = nil

  end

  private :create_or_update

  # AR#Persistence#destroy would raise and RecordNotFound exception

  # if the issue was already deleted or updated (non matching lock_version).

  # This is a problem when bulk deleting issues or deleting a project

  # (because an issue may already be deleted if its parent was deleted

  # first).

  # The issue is reloaded by the nested_set before being deleted so

  # the lock_version condition should not be an issue but we handle it.

  def destroy

    super

  rescue ActiveRecord::StaleObjectError, ActiveRecord::RecordNotFound

    # Stale or already deleted

    begin

      reload

    rescue ActiveRecord::RecordNotFound

      # The issue was actually already deleted

      @destroyed = true

      return freeze

    end

    # The issue was stale, retry to destroy

    super

  end

  alias :base_reload :reload

  def reload(*args)

    @workflow_rule_by_attribute = nil

    @assignable_versions = nil

    @relations = nil

    @spent_hours = nil

    @total_spent_hours = nil

    @total_estimated_hours = nil

    @last_updated_by = nil

    @last_notes = nil

    base_reload(*args)

  end

  # Overrides Redmine::Acts::Customizable::InstanceMethods#available_custom_fields

  def available_custom_fields

    (project && tracker) ? (project.all_issue_custom_fields & tracker.custom_fields) : []

  end

  def visible_custom_field_values(user=nil)

    user_real = user || User.current

    custom_field_values.select do |value|

      value.custom_field.visible_by?(project, user_real)

    end

  end

  # Overrides Redmine::Acts::Customizable::InstanceMethods#set_custom_field_default?

  def set_custom_field_default?(custom_value)

    new_record? || project_id_changed?|| tracker_id_changed?

  end

  # Copies attributes from another issue, arg can be an id or an Issue

  def copy_from(arg, options={})

    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", "status_id", "closed_on"

      )

    self.custom_field_values =

      issue.custom_field_values.inject({}) do |h, v|

        h[v.custom_field_id] = v.value

        h

      end

    if options[:keep_status]

      self.status = issue.status

    end

    self.author = User.current

    unless options[:attachments] == false

      self.attachments = issue.attachments.map do |attachement|

        attachement.copy(:container => self)

      end

    end

    unless options[:watchers] == false

      self.watcher_user_ids =

        issue.watcher_users.select{|u| u.status == User::STATUS_ACTIVE}.map(&:id)

    end

    @copied_from = issue

    @copy_options = options

    self

  end

  # Returns an unsaved copy of the issue

  def copy(attributes=nil, copy_options={})

    copy = self.class.new.copy_from(self, copy_options)

    copy.attributes = attributes if attributes

    copy

  end

  # Returns true if the issue is a copy

  def copy?

    @copied_from.present?

  end

  def status_id=(status_id)

    if status_id.to_s != self.status_id.to_s

      self.status = (status_id.present? ? IssueStatus.find_by_id(status_id) : nil)

    end

    self.status_id

  end

  # Sets the status.

  def status=(status)

    if status != self.status

      @workflow_rule_by_attribute = nil

    end

    association(:status).writer(status)

  end

  def priority_id=(pid)

    self.priority = nil

    write_attribute(:priority_id, pid)

  end

  def category_id=(cid)

    self.category = nil

    write_attribute(:category_id, cid)

  end

  def fixed_version_id=(vid)

    self.fixed_version = nil

    write_attribute(:fixed_version_id, vid)

  end

  def tracker_id=(tracker_id)

    if tracker_id.to_s != self.tracker_id.to_s

      self.tracker = (tracker_id.present? ? Tracker.find_by_id(tracker_id) : nil)

    end

    self.tracker_id

  end

  # Sets the tracker.

  # This will set the status to the default status of the new tracker if:

  # * the status was the default for the previous tracker

  # * or if the status was not part of the new tracker statuses

  # * or the status was nil

  def tracker=(tracker)

    tracker_was = self.tracker

    association(:tracker).writer(tracker)

    if tracker != tracker_was

      if status == tracker_was.try(:default_status)

        self.status = nil

      elsif status && tracker && !tracker.issue_status_ids.include?(status.id)

        self.status = nil

      end

      reassign_custom_field_values

      @workflow_rule_by_attribute = nil

    end

    self.status ||= default_status

    self.tracker

  end

  def project_id=(project_id)

    if project_id.to_s != self.project_id.to_s

      self.project = (project_id.present? ? Project.find_by_id(project_id) : nil)

    end

    self.project_id

  end

  # Sets the project.

  # Unless keep_tracker argument is set to true, this will change the tracker

  # to the first tracker of the new project if the previous tracker is not part

  # of the new project trackers.

  # This will:

  # * clear the fixed_version is it's no longer valid for the new project.

  # * clear the parent issue if it's no longer valid for the new project.

  # * set the category to the category with the same name in the new

  #   project if it exists, or clear it if it doesn't.

  # * for new issue, set the fixed_version to the project default version

  #   if it's a valid fixed_version.

  def project=(project, keep_tracker=false)

    project_was = self.project

    association(:project).writer(project)

    if project != project_was

      @safe_attribute_names = nil

    end

    if project_was && project && project_was != project

      @assignable_versions = nil

      unless keep_tracker || project.trackers.include?(tracker)

        self.tracker = project.trackers.first

      end

      # Reassign to the category with same name if any

      if category

        self.category = project.issue_categories.find_by_name(category.name)

      end

      # Clear the assignee if not available in the new project for new issues (eg. copy)

      # For existing issue, the previous assignee is still valid, so we keep it

      if new_record? && assigned_to && !assignable_users.include?(assigned_to)

        self.assigned_to_id = nil

      end

      # Keep the fixed_version if it's still valid in the new_project

      if fixed_version && fixed_version.project != project && !project.shared_versions.include?(fixed_version)

        self.fixed_version = nil

      end

      # Clear the parent task if it's no longer valid

      unless valid_parent_project?

        self.parent_issue_id = nil

      end

      reassign_custom_field_values

      @workflow_rule_by_attribute = nil

    end

    # Set fixed_version to the project default version if it's valid

    if new_record? && fixed_version.nil? && project && project.default_version_id?

      if project.shared_versions.open.exists?(project.default_version_id)

        self.fixed_version_id = project.default_version_id

      end

    end

    self.project

  end

  def description=(arg)

    if arg.is_a?(String)

      arg = arg.gsub(/(\r\n|\n|\r)/, "\r\n")

    end

    write_attribute(:description, arg)

  end

  def deleted_attachment_ids

    Array(@deleted_attachment_ids).map(&:to_i)

  end

  # Overrides assign_attributes so that project and tracker get assigned first

  def assign_attributes(new_attributes, *args)

    return if new_attributes.nil?

    attrs = new_attributes.dup

    attrs.stringify_keys!

    %w(project project_id tracker tracker_id).each do |attr|

      if attrs.has_key?(attr)

        send "#{attr}=", attrs.delete(attr)

      end

    end

    super attrs, *args

  end

  def attributes=(new_attributes)

    assign_attributes new_attributes

  end

  def estimated_hours=(h)

    write_attribute :estimated_hours, (h.is_a?(String) ? (h.to_hours || h) : h)

  end

  safe_attributes(

    'project_id',

    'tracker_id',

    'status_id',

    'category_id',

    'assigned_to_id',

    'priority_id',

    'fixed_version_id',

    'subject',

    'description',

    'start_date',

    'due_date',

    'done_ratio',

    'estimated_hours',

    'custom_field_values',

    'custom_fields',

    'lock_version',

    :if => lambda {|issue, user| issue.new_record? || issue.attributes_editable?(user)})

  safe_attributes(

    'notes',

    :if => lambda {|issue, user| issue.notes_addable?(user)})

  safe_attributes(

    'private_notes',

    :if => lambda {|issue, user| !issue.new_record? && user.allowed_to?(:set_notes_private, issue.project)})

  safe_attributes(

    'watcher_user_ids',

    :if => lambda {|issue, user| issue.new_record? && user.allowed_to?(:add_issue_watchers, issue.project)})

  safe_attributes(

    'is_private',

    :if => lambda do |issue, user|

      user.allowed_to?(:set_issues_private, issue.project) ||

        (issue.author_id == user.id && user.allowed_to?(:set_own_issues_private, issue.project))

    end)

  safe_attributes(

    'parent_issue_id',

    :if => lambda do |issue, user|

      (issue.new_record? || issue.attributes_editable?(user)) &&

        user.allowed_to?(:manage_subtasks, issue.project)

    end)

  safe_attributes(

    'deleted_attachment_ids',

    :if => lambda {|issue, user| issue.attachments_deletable?(user)})

  def safe_attribute_names(user=nil)

    names = super

    names -= disabled_core_fields

    names -= read_only_attribute_names(user)

    if new_record?

      # Make sure that project_id can always be set for new issues

      names |= %w(project_id)

    end

    if dates_derived?

      names -= %w(start_date due_date)

    end

    if priority_derived?

      names -= %w(priority_id)

    end

    if done_ratio_derived?

      names -= %w(done_ratio)

    end

    names

  end

  # 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

  def safe_attributes=(attrs, user=User.current)

    if attrs.respond_to?(:to_unsafe_hash)

      attrs = attrs.to_unsafe_hash

    end

    @attributes_set_by = user

    return unless attrs.is_a?(Hash)

    attrs = attrs.deep_dup

    # Project and Tracker must be set before since new_statuses_allowed_to depends on it.

    if (p = attrs.delete('project_id')) && safe_attribute?('project_id')

      if p.is_a?(String) && !/^\d*$/.match?(p)

        p_id = Project.find_by_identifier(p).try(:id)

      else

        p_id = p.to_i

      end

      if allowed_target_projects(user).where(:id => p_id).exists?

        self.project_id = p_id

      end

      if project_id_changed? && attrs['category_id'].present? && attrs['category_id'].to_s == category_id_was.to_s

        # Discard submitted category on previous project

        attrs.delete('category_id')

      end

    end

    if (t = attrs.delete('tracker_id')) && safe_attribute?('tracker_id')

      if allowed_target_trackers(user).where(:id => t.to_i).exists?

        self.tracker_id = t

      end

    end

    if project && tracker.nil?

      # Set a default tracker to accept custom field values

      # even if tracker is not specified

      allowed_trackers = allowed_target_trackers(user)

      if attrs['parent_issue_id'].present?

        # If parent_issue_id is present, the first tracker for which this field

        # is not disabled is chosen as default

        self.tracker = allowed_trackers.detect {|t| t.core_fields.include?('parent_issue_id')}

      end

      self.tracker ||= allowed_trackers.first

    end

    statuses_allowed = new_statuses_allowed_to(user)

    if (s = attrs.delete('status_id')) && safe_attribute?('status_id')

      if statuses_allowed.collect(&:id).include?(s.to_i)

        self.status_id = s

      end

    end

    if new_record? && !statuses_allowed.include?(status)

      self.status = statuses_allowed.first || default_status

    end

    if (u = attrs.delete('assigned_to_id')) && safe_attribute?('assigned_to_id')

      self.assigned_to_id = u

    end

    attrs = delete_unsafe_attributes(attrs, user)

    return if attrs.empty?

    if attrs['parent_issue_id'].present?

      s = attrs['parent_issue_id'].to_s

      unless (m = s.match(%r{\A#?(\d+)\z})) && (m[1] == parent_id.to_s || Issue.visible(user).exists?(m[1]))

        @invalid_parent_issue_id = attrs.delete('parent_issue_id')

      end

    end

    if attrs['custom_field_values'].present?

      editable_custom_field_ids = editable_custom_field_values(user).map {|v| v.custom_field_id.to_s}

      attrs['custom_field_values'].select! {|k, v| editable_custom_field_ids.include?(k.to_s)}

    end

    if attrs['custom_fields'].present?

      editable_custom_field_ids = editable_custom_field_values(user).map {|v| v.custom_field_id.to_s}

      attrs['custom_fields'].select! {|c| editable_custom_field_ids.include?(c['id'].to_s)}

    end

    assign_attributes attrs

  end

  def disabled_core_fields

    tracker ? tracker.disabled_core_fields : []

  end

  # Returns the custom_field_values that can be edited by the given user

  def editable_custom_field_values(user=nil)

    read_only = read_only_attribute_names(user)

    visible_custom_field_values(user).reject do |value|

      read_only.include?(value.custom_field_id.to_s)

    end

  end

  # Returns the custom fields that can be edited by the given user

  def editable_custom_fields(user=nil)

    editable_custom_field_values(user).map(&:custom_field).uniq

  end

  # Returns the names of attributes that are read-only for user or the current user

  # For users with multiple roles, the read-only fields are the intersection of

  # read-only fields of each role

  # The result is an array of strings where sustom fields are represented with their ids

  #

  # Examples:

  #   issue.read_only_attribute_names # => ['due_date', '2']

  #   issue.read_only_attribute_names(user) # => []

  def read_only_attribute_names(user=nil)

    workflow_rule_by_attribute(user).reject {|attr, rule| rule != 'readonly'}.keys

  end

  # Returns the names of required attributes for user or the current user

  # For users with multiple roles, the required fields are the intersection of

  # required fields of each role

  # The result is an array of strings where sustom fields are represented with their ids

  #

  # Examples:

  #   issue.required_attribute_names # => ['due_date', '2']

  #   issue.required_attribute_names(user) # => []

  def required_attribute_names(user=nil)

    workflow_rule_by_attribute(user).reject {|attr, rule| rule != 'required'}.keys

  end

  # Returns true if the attribute is required for user

  def required_attribute?(name, user=nil)

    required_attribute_names(user).include?(name.to_s)

  end

  # Returns a hash of the workflow rule by attribute for the given user

  #

  # Examples:

  #   issue.workflow_rule_by_attribute # => {'due_date' => 'required', 'start_date' => 'readonly'}

  def workflow_rule_by_attribute(user=nil)

    return @workflow_rule_by_attribute if @workflow_rule_by_attribute && user.nil?

    roles = roles_for_workflow(user || User.current)

    return {} if roles.empty?

    result = {}

    workflow_permissions =

      WorkflowPermission.where(

        :tracker_id => tracker_id, :old_status_id => status_id,

        :role_id => roles.map(&:id)

      ).to_a

    if workflow_permissions.any?

      workflow_rules = workflow_permissions.inject({}) do |h, wp|

        h[wp.field_name] ||= {}

        h[wp.field_name][wp.role_id] = wp.rule

        h

      end

      fields_with_roles = {}

      IssueCustomField.where(:visible => false).

        joins(:roles).pluck(:id, "role_id").

          each do |field_id, role_id|

        fields_with_roles[field_id] ||= []

        fields_with_roles[field_id] << role_id

      end

      roles.each do |role|

        fields_with_roles.each do |field_id, role_ids|

          unless role_ids.include?(role.id)

            field_name = field_id.to_s

            workflow_rules[field_name] ||= {}

            workflow_rules[field_name][role.id] = 'readonly'

          end

        end

      end

      workflow_rules.each do |attr, rules|

        next if rules.size < roles.size

        uniq_rules = rules.values.uniq

        if uniq_rules.size == 1

          result[attr] = uniq_rules.first

        else

          result[attr] = 'required'

        end

      end

    end

    @workflow_rule_by_attribute = result if user.nil?

    result

  end

  private :workflow_rule_by_attribute

  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_issue

    if due_date && start_date && (start_date_changed? || due_date_changed?) && due_date < start_date

      errors.add :due_date, :greater_than_start_date

    end

    if start_date && start_date_changed? && soonest_start && start_date < soonest_start

      errors.add :start_date, :earlier_than_minimum_start_date, :date => format_date(soonest_start)

    end

    if project && fixed_version_id

      if fixed_version.nil? || assignable_versions.exclude?(fixed_version)

        errors.add :fixed_version_id, :inclusion

      elsif reopening? && fixed_version.closed?

        errors.add :base, I18n.t(:error_can_not_reopen_issue_on_closed_version)

      end

    end

    if project && category_id

      unless project.issue_category_ids.include?(category_id)

        errors.add :category_id, :inclusion

      end

    end

    # Checks that the issue can not be added/moved to a disabled tracker

    if project && (tracker_id_changed? || project_id_changed?)

      if tracker && !project.trackers.include?(tracker)

        errors.add :tracker_id, :inclusion

      end

    end

    if project && assigned_to_id_changed? && assigned_to_id.present?

      unless assignable_users.include?(assigned_to)

        errors.add :assigned_to_id, :invalid

      end

    end

    # Checks parent issue assignment

    if @invalid_parent_issue_id.present?

      errors.add :parent_issue_id, :invalid

    elsif @parent_issue

      if !valid_parent_project?(@parent_issue)

        errors.add :parent_issue_id, :invalid

      elsif (@parent_issue != parent) && (

          self.would_reschedule?(@parent_issue) ||

          @parent_issue.self_and_ancestors.any? do |a|

            a.relations_from.any? do |r|

              r.relation_type == IssueRelation::TYPE_PRECEDES &&

                 r.issue_to.would_reschedule?(self)

            end

          end

        )

        errors.add :parent_issue_id, :invalid

      elsif !closed? && @parent_issue.closed?

        # cannot attach an open issue to a closed parent

        errors.add :base, :open_issue_with_closed_parent

      elsif !new_record?

        # moving an existing issue

        if move_possible?(@parent_issue)

          # move accepted

        else

          errors.add :parent_issue_id, :invalid

        end

      end

    end

  end

  # Validates the issue against additional workflow requirements

  def validate_required_fields

    user = new_record? ? author : current_journal.try(:user)

    required_attribute_names(user).each do |attribute|

      if /^\d+$/.match?(attribute)

        attribute = attribute.to_i

        v = custom_field_values.detect {|v| v.custom_field_id == attribute}

        if v && Array(v.value).detect(&:present?).nil?

          errors.add(v.custom_field.name, l('activerecord.errors.messages.blank'))