Redmine

    <td class="label"><%= l(:field_estimated_hours) %></td>

    <td class="total-hours"><%= html_hours(lwr(:label_f_hour, @version.estimated_hours)) %></td>

    <td class="label"><%= l(:label_spent_time) %></td>

    <td class="total-hours"><%= html_hours(lwr(:label_f_hour, @version.spent_hours)) %></td>

<tr>

    <td class="label"><%= l(:label_remaining_time) %></td>

    <td class="total-hours"><%= html_hours(lwr(:label_f_hour, @version.remaining_hours)) %></td>

</tr>

<tr>

    <% title = "#{l(:label_spent_time)} + #{l(:label_remaining_time)}" %>

    <td class="label" title="<%= title %>"><%= l(:label_current_total_time) %></td>

    <td class="total-hours" title="<%= title %>"><%= html_hours(lwr(:label_f_hour, @version.total_hours)) %></td>

</tr>

<% if grouped_metrics.empty? %>

    <table class="category_metrics">

    <% grouped_metrics.each do |metrics_group| 

      category, metrics = *metrics_group

    %>

    <% color_class = cycle('odd', 'even')%>

        <tr class="header <%= color_class %>">

            <td colspan="5">

                <%= criteria_operator = category ? "=" : "!*" 

                link_to category || "[#{l(:text_not_assigned)}]", 

                                            {:controller => 'issues', 

                                            :action => 'index',

                                            :project_id => version.project,

                                            :set_filter => 1,

                                            :fields => ["#{criteria}_id", "fixed_version_id", "status_id"],

                                            :values => {"#{criteria}_id" => [category], "fixed_version_id" => [version], "status_id" => [1]},

                                            :operators => {"#{criteria}_id" => criteria_operator, "fixed_version_id" => "=", "status_id" => "*"}

                                            }

                                          %>

            </td>

        </tr>

        <tr class="<%= color_class %>">

            <td><%= l(:label_issues_count) %> </td>

            <% if spent_time_allowed %>

            <td><%= l(:label_time) %></td>

            <% end %>

            <td class="metric_comment">

                <span title="<%= l(:field_estimated_hours) %>">

                    <%= l(:label_estimated_time_short) %> 

                </span>

            </td>

            <% if spent_time_allowed %>

            <td class="metric_comment">

                <span title="<%= l(:label_spent_time) %>">

                    <%= l(:label_spent_time_short) %> 

                </span>

            </td>

            <td class="metric_comment">

                <span title="<%= l(:label_remaining_time) %>">

                    <%= l(:label_remaining_time_short) %> 

                </span>

            </td>

            <% max_progress_width = 70 %>

            <% else

                max_progress_width = 150

            end %>

        </tr>

        <tr class="<%= color_class %>">

            <td class="progress count">

                <%= count = metrics[:count]; progress_bar((count[:closed].to_f / count[:total])*100, 

                      :legend => 

                        "<span title=\"#{l(:label_closed_issues_plural)}\">" + 

                        "#{count[:closed]}</span>/" + 

                        "<span title=\"#{l(:label_total).chars.downcase}\">" + 

                        "#{count[:total]}</span>",                          

                      :width => "#{(count[:total].to_f / max[:count] * max_progress_width).floor}px;") %>

            </td>

            <% 

              time = metrics[:time]

              if spent_time_allowed %>

            <td class="progress time">

                <%= progress_bar(time_progress(time)*100, 

                      :legend => 

                        "<span title=\"#{l(:label_spent_time)}\">" + 

                        "#{time[:spent].ceil}</span>/" + 

                        "<span title=\"#{l(:label_current_total_time)}\">" + 

                        "#{time[:total].ceil}</span>",                          

                      :width => "#{(time[:total] / max[:time] * max_progress_width).floor}px;") %>

            </td>

            <% end %>

            <% hours = l(:text_hours_short) %>

            <td class="metric_comment">

                <span title="<%= l(:field_estimated_hours) %>">

                    <%= "#{time[:estimated].ceil}#{hours}" %>

                </span>                

            </td>

            <% if spent_time_allowed %>

            <td class="metric_comment">

                <span title="<%= l(:label_spent_time) %>">

                    <%= "#{time[:spent].ceil}#{hours}" %>

                </span>                                

            </td>

            <td class="metric_comment">

                <span title="<%= l(:label_remaining_time) %>">

                    <%= "#{time[:remaining].ceil}#{hours}" %>

                </span>                                                

            </td>

            <% end %>

        </tr>

    #sort them alphabetically by category name

    metrics = version.get_grouped_metrics(criteria).to_a.sort {|x, y| x[0].to_s <=> y[0].to_s} 

    max = {}

    [{:count => :total}, {:time => :total}].each do |metric_info| 

      metrics_group, total_metric = metric_info.to_a.flatten

      max[metrics_group] = metrics.map{|item| item[1]}.map {|item| item[metrics_group]}.map {|item| item[total_metric]}.max

      max[metrics_group] = 1 if max[metrics_group] == 0

    render :partial => 'issue_counts', :locals => {:version => version, 

      :criteria => criteria, :grouped_metrics => metrics, :max => max, 

      :spent_time_allowed => User.current.allowed_to?(:view_time_entries, @project), 

      }

  def time_progress(time_info)  

    logger.debug "time_info[:spent] = #{time_info[:spent].inspect}"

    logger.debug "time_info[:total] = #{time_info[:total].inspect}"

    if (time_info[:total] != 0)

      time_progress = time_info[:spent].to_f / time_info[:total]

    else

      time_progress = 0 #no total also means there's no spent time

    end    

    time_progress

  end

  def calc_remaining_and_total_time

    @remaining_hours = 0

    @total_hours = 0

    get_grouped_metrics(:category).to_a.map{|item| item[1]}.map {|item| item[:time]}.each do |times| 

      @remaining_hours += times[:remaining]

      @total_hours += times[:total]

    end

  end

  def remaining_hours

    return @remaining_hours if @remaining_hours

    calc_remaining_and_total_time

    @remaining_hours    

  end

  def total_hours

    return @total_hours if @total_hours

    calc_remaining_and_total_time

    @total_hours

  end

  def get_grouped_metrics(criteria)

    condition = issues_version_condition

    issues = Issue.find(:all, :include => [:status, criteria], 

      :conditions => condition)

    spent_times = {}

    TimeEntry.sum(:hours, :group => :issue_id, :include => :issue,

        :conditions => condition).each do |issue_id, hours| 

      spent_times[issue_id] = hours

    end

    categories_metrics = {}

    issues.each do |issue|

      category = issue.send(criteria)

      categories_metrics[category] ||= {}

      categories_metrics[category][:time] ||= {:estimated => 0, 

        :spent => 0, :remaining => 0, :total => 0}

      metrics = categories_metrics[category][:time]

      estimated = issue.estimated_hours || 0

      metrics[:estimated] += estimated

      spent = spent_times[issue.id] || 0

      metrics[:spent] += spent

      remaining = issue.closed? ? 0 : estimated - spent

      remaining = 0 if remaining < 0

      metrics[:remaining] += remaining

      metrics[:total] += (remaining + spent)

      categories_metrics[category][:count] ||= {:open => 0, :closed => 0, :total => 0}

      metrics = categories_metrics[category][:count]

      metrics[:total] += 1

      if issue.closed?

        metrics[:closed] += 1 

      else

        metrics[:open] += 1 

      end

    end

    categories_metrics

  end

  def issues_version_condition

    ["#{Issue.table_name}.fixed_version_id = ?", id]

  end

  private

div.category_metrics {

  padding: 0.5em 0 0.5em 0;

}

table.category_metrics {

    border-collapse: collapse;    

}

.category_metrics .header {

  font-weight:bold;

}

.category_metrics th {

  text-align: left;

  font-weight:normal;    

}

.category_metrics td.progress {

  text-align: left;

  white-space: nowrap;

}

.category_metrics td.progress.count {

  width: 30%;

}

.category_metrics td.progress.time {

  width: 30%;

}

th.metric_comment, td.metric_comment {

  font-weight:normal;    

  font-size:90%;

  width: 5%;

}

#version-summary td.label {

    text-align:right;

    width: 40%;    

}

#version-summary td.total-hours {

    text-align:right;

}

#version-summary table {

    width:100%;

}

# 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.

require File.dirname(__FILE__) + '/../test_helper'

class VersionTest < Test::Unit::TestCase

  fixtures :all

  def verify_counts(count_metrics, open, closed)

    assert_equal open + closed, count_metrics[:total]

    assert_equal open, count_metrics[:open]

    assert_equal closed, count_metrics[:closed]    

  end

  def test_get_grouped_metrics_count

    version = versions(:versions_002)

    grouped_metrics = version.get_grouped_metrics(:tracker)

    verify_counts(grouped_metrics[trackers(:trackers_001)][:count], 2, 1)

    verify_counts(grouped_metrics[trackers(:trackers_002)][:count], 1, 0)

  end

  def test_get_grouped_metrics_time

    version = versions(:versions_002)

    grouped_metrics = version.get_grouped_metrics(:tracker)

    time_metrics = grouped_metrics[trackers(:trackers_001)][:time]

    estimated = [:issues_001, :issues_003, :issues_007].inject(0) do |prev, current| 

      issues(current).estimated_hours + prev

    end

    assert_equal estimated, time_metrics[:estimated]

    spent = [:issues_001, :issues_003].inject(0) do |prev, current| 

      issues(current).spent_hours + prev

    end    

    assert_equal spent, time_metrics[:spent]

    i3 = issues(:issues_003)    

    #issue 1 is not counted because it spent more than estimated; 

    #  issue 7 not counted because because it's closed

    remaining = i3.estimated_hours - i3.spent_hours 

    assert_equal remaining, time_metrics[:remaining]

    assert_equal spent + remaining, time_metrics[:total]

  end

end

# 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.

require File.dirname(__FILE__) + '/../test_helper'

class VersionTest < Test::Unit::TestCase

  fixtures :all

  def verify_counts(count_metrics, open, closed)

    assert_equal open + closed, count_metrics[:total]

    assert_equal open, count_metrics[:open]

    assert_equal closed, count_metrics[:closed]    

  end

  def test_get_grouped_metrics_count

    version = versions(:versions_002)

    grouped_metrics = version.get_grouped_metrics(:tracker)

    verify_counts(grouped_metrics[trackers(:trackers_001)][:count], 2, 1)

    verify_counts(grouped_metrics[trackers(:trackers_002)][:count], 1, 0)

  end

  def test_get_grouped_metrics_time

    version = versions(:versions_002)

    grouped_metrics = version.get_grouped_metrics(:tracker)

    time_metrics = grouped_metrics[trackers(:trackers_001)][:time]

    estimated = [:issues_001, :issues_003, :issues_007].inject(0) do |prev, current| 

      issues(current).estimated_hours + prev

    end

    assert_equal estimated, time_metrics[:estimated]

    spent = [:issues_001, :issues_003].inject(0) do |prev, current| 

      issues(current).spent_hours + prev

    end    

    assert_equal spent, time_metrics[:spent]

    i3 = issues(:issues_003)    

    #issue 1 is not counted because it spent more than estimated; 

    #  issue 7 not counted because because it's closed

    remaining = i3.estimated_hours - i3.spent_hours 

    assert_equal remaining, time_metrics[:remaining]

    assert_equal spent + remaining, time_metrics[:total]

  end

end

# 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.

require File.dirname(__FILE__) + '/../test_helper'

class VersionTest < Test::Unit::TestCase

  fixtures :all

  def verify_counts(count_metrics, open, closed)

    assert_equal open + closed, count_metrics[:total]

    assert_equal open, count_metrics[:open]

    assert_equal closed, count_metrics[:closed]    

  end

  def test_get_grouped_metrics_count

    version = versions(:versions_002)

    grouped_metrics = version.get_grouped_metrics(:tracker)

    verify_counts(grouped_metrics[trackers(:trackers_001)][:count], 2, 1)

    verify_counts(grouped_metrics[trackers(:trackers_002)][:count], 1, 0)

  end

  def test_get_grouped_metrics_time

    version = versions(:versions_002)

    grouped_metrics = version.get_grouped_metrics(:tracker)

    time_metrics = grouped_metrics[trackers(:trackers_001)][:time]

    estimated = [:issues_001, :issues_003, :issues_007].inject(0) do |prev, current| 

      issues(current).estimated_hours + prev

    end

    assert_equal estimated, time_metrics[:estimated]

    spent = [:issues_001, :issues_003].inject(0) do |prev, current| 

      issues(current).spent_hours + prev

    end    

    assert_equal spent, time_metrics[:spent]

    i3 = issues(:issues_003)    

    #issue 1 is not counted because it spent more than estimated; 

    #  issue 7 not counted because because it's closed

    remaining = i3.estimated_hours - i3.spent_hours 

    assert_equal remaining, time_metrics[:remaining]

    assert_equal spent + remaining, time_metrics[:total]

  end

end

# 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.

require File.dirname(__FILE__) + '/../test_helper'

class VersionTest < Test::Unit::TestCase

  fixtures :all

  def verify_counts(count_metrics, open, closed)

    assert_equal open + closed, count_metrics[:total]

    assert_equal open, count_metrics[:open]

    assert_equal closed, count_metrics[:closed]    

  end

  def test_get_grouped_metrics_count

    version = versions(:versions_002)

    grouped_metrics = version.get_grouped_metrics(:tracker)

    verify_counts(grouped_metrics[trackers(:trackers_001)][:count], 2, 1)

    verify_counts(grouped_metrics[trackers(:trackers_002)][:count], 1, 0)

  end

  def test_get_grouped_metrics_time

    version = versions(:versions_002)

    grouped_metrics = version.get_grouped_metrics(:tracker)

    time_metrics = grouped_metrics[trackers(:trackers_001)][:time]

    estimated = [:issues_001, :issues_003, :issues_007].inject(0) do |prev, current| 

      issues(current).estimated_hours + prev

    end

    assert_equal estimated, time_metrics[:estimated]

    spent = [:issues_001, :issues_003].inject(0) do |prev, current| 

      issues(current).spent_hours + prev

    end    

    assert_equal spent, time_metrics[:spent]

    i3 = issues(:issues_003)    

    #issue 1 is not counted because it spent more than estimated; 

    #  issue 7 not counted because because it's closed

    remaining = i3.estimated_hours - i3.spent_hours 

    assert_equal remaining, time_metrics[:remaining]

    assert_equal spent + remaining, time_metrics[:total]

  end

end

    assert_equal 7, Enumeration.find(4).objects_count

    assert_equal 7, Enumeration.find(6).objects_count

    assert !@dlopper.role_for_project(Project.find(3)).member?

  fixtures :projects, :versions, :issues, :users, :roles, :members, :enabled_modules, :issue_statuses, :trackers

  {:view_time_entries_allowed => {:version_id => 2},

      :view_time_entries_not_allowed => {:user_id => 3, :version_id => 4}

  }.each do |case_key, case_info|

    define_method "test_show_when_#{case_key}" do

      @request.session[:user_id] = case_info[:user_id] if case_info[:user_id]

      if case_info[:verify]

        case_info[:verify].call()

      end

      get :show, :id => case_info[:version_id]

      assert_response :success

      assert_template 'show'

      assert_not_nil assigns(:version)

      assert_tag :tag => 'h2', :content => Version.find(case_info[:version_id]).name

    end

    define_method "test_issue_status_by_when_#{case_key}" do

      @request.session[:user_id] = case_info[:user_id] if case_info[:user_id]

      xhr :get, :status_by, :id => case_info[:version_id]

      assert_response :success

      assert_template '_issue_counts'

    end

  end

  #specific bug was reproduced when there were no time records and all the issues were closed

  def test_issue_status_by_no_division_by_zero

    version = versions(:versions_003)

    user = users(:users_002)

    @request.session[:user_id] = user.id

    assert version.fixed_issues.size > 0, "version should have issues"

    project = version.project

    assert user.allowed_to?(:view_time_entries, project), "user should have :view_time_entries permission to project #{project.id}"

    version.fixed_issues.all? do |i| 

      assert_equal 0, i.spent_hours 

      assert !i.estimated_hours || i.estimated_hours == 0

      assert i.closed?

    end

    xhr :get, :status_by, :id => version.id

    assert_template '_issue_counts'

    version = versions(:versions_001)

    assert version.fixed_issues.empty?, "version should have no issues"

    post :destroy, :id => version.id

    assert_nil Version.find_by_id(version.id)

roles_006: 

  name: NoTimeEntries

  id: 6

  builtin: 0

  permissions: |

    --- 

    - :add_issue_notes

    - :view_gantt

    - :view_calendar

    - :view_documents

    - :view_wiki_pages

    - :view_files

    - :browse_repository

    - :view_changesets

  position: 6

  fixed_version_id: 2

  estimated_hours: 100

  fixed_version_id: 2