version.rb 9.17 KB
Newer Older
1
# Redmine - project management software
jplang's avatar
jplang committed
2
# Copyright (C) 2006-2016  Jean-Philippe Lang
3 4 5 6 7
#
# 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.
8
#
9 10 11 12
# 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.
13
#
14 15 16 17 18
# 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 Version < ActiveRecord::Base
19
  include Redmine::SafeAttributes
20

21
  after_update :update_issues_from_sharing_change
22 23
  before_destroy :nullify_projects_default_version

24
  belongs_to :project
25
  has_many :fixed_issues, :class_name => 'Issue', :foreign_key => 'fixed_version_id', :dependent => :nullify
26
  acts_as_customizable
27
  acts_as_attachable :view_permission => :view_files,
28
                     :edit_permission => :manage_files,
29
                     :delete_permission => :manage_files
30

31
  VERSION_STATUSES = %w(open locked closed)
32
  VERSION_SHARINGS = %w(none descendants hierarchy tree system)
33

34 35
  validates_presence_of :name
  validates_uniqueness_of :name, :scope => [:project_id]
36
  validates_length_of :name, :maximum => 60
37
  validates_length_of :description, :maximum => 255
38
  validates :effective_date, :date => true
39
  validates_inclusion_of :status, :in => VERSION_STATUSES
40
  validates_inclusion_of :sharing, :in => VERSION_SHARINGS
jplang's avatar
jplang committed
41
  attr_protected :id
42

jplang's avatar
jplang committed
43
  scope :named, lambda {|arg| where("LOWER(#{table_name}.name) = LOWER(?)", arg.to_s.strip)}
44
  scope :open, lambda { where(:status => 'open') }
jplang's avatar
jplang committed
45
  scope :visible, lambda {|*args|
jplang's avatar
jplang committed
46 47
    joins(:project).
    where(Project.allowed_to_condition(args.first || User.current, :view_issues))
jplang's avatar
jplang committed
48
  }
49

50
  safe_attributes 'name',
51 52 53 54 55 56
    'description',
    'effective_date',
    'due_date',
    'wiki_page_title',
    'status',
    'sharing',
57 58
    'custom_field_values',
    'custom_fields'
59 60 61 62 63

  # Returns true if +user+ or current user is allowed to view the version
  def visible?(user=User.current)
    user.allowed_to?(:view_issues, self.project)
  end
64

65 66 67 68 69
  # Version files have same visibility as project files
  def attachments_visible?(*args)
    project.present? && project.attachments_visible?(*args)
  end

70 71 72 73
  def attachments_deletable?(usr=User.current)
    project.present? && project.attachments_deletable?(usr)
  end

74
  def start_date
75
    @start_date ||= fixed_issues.minimum('start_date')
76
  end
77

78 79 80
  def due_date
    effective_date
  end
81

82 83 84 85
  def due_date=(arg)
    self.effective_date=(arg)
  end

jplang's avatar
jplang committed
86
  # Returns the total estimated time for this version
87
  # (sum of leaves estimated_hours)
jplang's avatar
jplang committed
88
  def estimated_hours
89
    @estimated_hours ||= fixed_issues.sum(:estimated_hours).to_f
jplang's avatar
jplang committed
90
  end
91

jplang's avatar
jplang committed
92 93
  # Returns the total reported time for this version
  def spent_hours
jplang's avatar
jplang committed
94
    @spent_hours ||= TimeEntry.joins(:issue).where("#{Issue.table_name}.fixed_version_id = ?", id).sum(:hours).to_f
jplang's avatar
jplang committed
95
  end
96

97 98 99
  def closed?
    status == 'closed'
  end
100 101 102 103

  def open?
    status == 'open'
  end
104

105
  # Returns true if the version is completed: closed or due date reached and no open issues
106
  def completed?
107
    closed? || (effective_date && (effective_date < User.current.today) && (open_issues_count == 0))
108
  end
edavis10's avatar
edavis10 committed
109 110

  def behind_schedule?
111
    if completed_percent == 100
edavis10's avatar
edavis10 committed
112
      return false
113
    elsif due_date && start_date
114
      done_date = start_date + ((due_date - start_date+1)* completed_percent/100).floor
115
      return done_date <= User.current.today
edavis10's avatar
edavis10 committed
116 117 118 119
    else
      false # No issues so it's not late
    end
  end
120

121 122
  # Returns the completion percentage of this version based on the amount of open/closed issues
  # and the time spent on the open issues.
123
  def completed_percent
124
    if issues_count == 0
125 126 127 128
      0
    elsif open_issues_count == 0
      100
    else
129
      issues_progress(false) + issues_progress(true)
130 131
    end
  end
132

133
  # Returns the percentage of issues that have been marked as 'closed'.
134
  def closed_percent
135
    if issues_count == 0
136 137
      0
    else
138
      issues_progress(false)
139 140
    end
  end
141

142 143
  # Returns true if the version is overdue: due date reached and some open issues
  def overdue?
144
    effective_date && (effective_date < User.current.today) && (open_issues_count > 0)
145
  end
146

147 148
  # Returns assigned issues count
  def issues_count
149 150
    load_issue_counts
    @issue_count
151
  end
152

153
  # Returns the total amount of open issues for this version.
154
  def open_issues_count
155 156
    load_issue_counts
    @open_issues_count
157 158
  end

159
  # Returns the total amount of closed issues for this version.
160
  def closed_issues_count
161 162
    load_issue_counts
    @closed_issues_count
163
  end
164

165 166 167 168 169 170
  def wiki_page
    if project.wiki && !wiki_page_title.blank?
      @wiki_page ||= project.wiki.find_page(wiki_page_title)
    end
    @wiki_page
  end
171

172
  def to_s; name end
173 174 175 176

  def to_s_with_project
    "#{project} - #{name}"
  end
177

jplang's avatar
jplang committed
178 179
  # Versions are sorted by effective_date and name
  # Those with no effective_date are at the end, sorted by name
180 181
  def <=>(version)
    if self.effective_date
182 183
      if version.effective_date
        if self.effective_date == version.effective_date
184
          name == version.name ? id <=> version.id : name <=> version.name
185 186 187 188 189 190
        else
          self.effective_date <=> version.effective_date
        end
      else
        -1
      end
191
    else
192 193 194
      if version.effective_date
        1
      else
195
        name == version.name ? id <=> version.id : name <=> version.name
196
      end
197 198
    end
  end
199

200 201 202 203 204 205 206 207 208 209 210
	# Sort versions by status (open, locked then closed versions)
  def self.sort_by_status(versions)
    versions.sort do |a, b|
      if a.status == b.status
        a <=> b
      else
        b.status <=> a.status
      end
    end
  end

211 212 213 214 215 216 217
  def css_classes
    [
      completed? ? 'version-completed' : 'version-incompleted',
      "version-#{status}"
    ].join(' ')
  end

218 219
  def self.fields_for_order_statement(table=nil)
    table ||= table_name
220
    ["(CASE WHEN #{table}.effective_date IS NULL THEN 1 ELSE 0 END)", "#{table}.effective_date", "#{table}.name", "#{table}.id"]
221 222
  end

223
  scope :sorted, lambda { order(fields_for_order_statement) }
224

225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244
  # Returns the sharings that +user+ can set the version to
  def allowed_sharings(user = User.current)
    VERSION_SHARINGS.select do |s|
      if sharing == s
        true
      else
        case s
        when 'system'
          # Only admin users can set a systemwide sharing
          user.admin?
        when 'hierarchy', 'tree'
          # Only users allowed to manage versions of the root project can
          # set sharing to hierarchy or tree
          project.nil? || user.allowed_to?(:manage_versions, project.root)
        else
          true
        end
      end
    end
  end
245

246 247 248 249 250
  # Returns true if the version is shared, otherwise false
  def shared?
    sharing != 'none'
  end

251 252 253 254
  def deletable?
    fixed_issues.empty? && !referenced_by_a_custom_field?
  end

255
  private
256

257 258 259 260
  def load_issue_counts
    unless @issue_count
      @open_issues_count = 0
      @closed_issues_count = 0
261
      fixed_issues.group(:status).count.each do |status, count|
262 263 264 265 266 267 268 269 270 271
        if status.is_closed?
          @closed_issues_count += count
        else
          @open_issues_count += count
        end
      end
      @issue_count = @open_issues_count + @closed_issues_count
    end
  end

272
  # Update the issue's fixed versions. Used if a version's sharing changes.
273
  def update_issues_from_sharing_change
274
    if sharing_changed?
275 276 277
      if VERSION_SHARINGS.index(sharing_was).nil? ||
          VERSION_SHARINGS.index(sharing).nil? ||
          VERSION_SHARINGS.index(sharing_was) > VERSION_SHARINGS.index(sharing)
278
        Issue.update_versions_from_sharing_change self
279
      end
280 281
    end
  end
282

283 284
  # Returns the average estimated time of assigned issues
  # or 1 if no issue has an estimated time
285
  # Used to weight unestimated issues in progress calculation
286 287 288 289 290 291 292 293 294 295
  def estimated_average
    if @estimated_average.nil?
      average = fixed_issues.average(:estimated_hours).to_f
      if average == 0
        average = 1
      end
      @estimated_average = average
    end
    @estimated_average
  end
296

297 298 299 300 301 302
  # Returns the total progress of open or closed issues.  The returned percentage takes into account
  # the amount of estimated time set for this version.
  #
  # Examples:
  # issues_progress(true)   => returns the progress percentage for open issues.
  # issues_progress(false)  => returns the progress percentage for closed issues.
303 304 305 306 307 308
  def issues_progress(open)
    @issues_progress ||= {}
    @issues_progress[open] ||= begin
      progress = 0
      if issues_count > 0
        ratio = open ? 'done_ratio' : 100
309

jplang's avatar
jplang committed
310
        done = fixed_issues.open(open).sum("COALESCE(estimated_hours, #{estimated_average}) * #{ratio}").to_f
311 312 313 314 315
        progress = done / (estimated_average * issues_count)
      end
      progress
    end
  end
316 317 318 319 320

  def referenced_by_a_custom_field?
    CustomValue.joins(:custom_field).
      where(:value => id.to_s, :custom_fields => {:field_format => 'version'}).any?
  end
321 322 323 324

  def nullify_projects_default_version
    Project.where(:default_version_id => id).update_all(:default_version_id => nil)
  end
jplang's avatar
jplang committed
325
end