jro_apps/redmine Commit - r14260:446f70f58432

Adds options to display totals on the issue list (#1561)....

Jean-Philippe Lang -

r14260:446f70f58432

parent child

Context file:

r14260:446f70f58432

Collapse all files

app/helpers/queries_helper.rb +21 -3

                 tags
               end
+              def available_totalable_columns_tags(query)
+                tags = ''.html_safe
+                query.available_totalable_columns.each do |column|
+                  tags << content_tag('label', check_box_tag('t[]', column.name.to_s, query.totalable_columns.include?(column), :id => nil) + " #{column.caption}", :class => 'inline')
+                end
+                tags
+              end
               def query_available_inline_columns_options(query)
                 (query.available_inline_columns - query.columns).reject(&:frozen?).collect {|column| [column.caption, column.name]}
               end
                 render :partial => 'queries/columns', :locals => {:query => query, :tag_name => tag_name}
               end
+              def render_query_totals(query)
+                return unless query.totalable_columns.present?
+                totals = query.totalable_columns.map do |column|
+                  label = content_tag('span', "#{column.caption}:")
+                  value = content_tag('span', " #{query.total_for(column)}", :class => 'value')
+                  content_tag('span', label + " " + value, :class => "total-for-#{column.name.to_s.dasherize}")
+                end
+                content_tag('p', totals.join(" ").html_safe, :class => "query-totals")
+              end
               def column_header(column)
                 column.sortable ? sort_header_tag(column.name.to_s, :caption => column.caption,
                                                                     :default_order => column.default_order) :
                   @query = IssueQuery.new(:name => "_")
                   @query.project = @project
                   @query.build_from_params(params)
-                  session[:query] = {:project_id => @query.project_id, :filters => @query.filters, :group_by => @query.group_by, :column_names => @query.column_names}
+                  session[:query] = {:project_id => @query.project_id, :filters => @query.filters, :group_by => @query.group_by, :column_names => @query.column_names, :totalable_names => @query.totalable_names}
                 else
                   # retrieve from session
                   @query = nil
                   @query = IssueQuery.find_by_id(session[:query][:id]) if session[:query][:id]
-                  @query ||= IssueQuery.new(:name => "_", :filters => session[:query][:filters], :group_by => session[:query][:group_by], :column_names => session[:query][:column_names])
+                  @query ||= IssueQuery.new(:name => "_", :filters => session[:query][:filters], :group_by => session[:query][:group_by], :column_names => session[:query][:column_names], :totalable_names => session[:query][:totalable_names])
                   @query.project = @project
                 end
               end
                     @query = IssueQuery.find_by_id(session[:query][:id])
                     return unless @query
                   else
-                    @query = IssueQuery.new(:name => "_", :filters => session[:query][:filters], :group_by => session[:query][:group_by], :column_names => session[:query][:column_names])
+                    @query = IssueQuery.new(:name => "_", :filters => session[:query][:filters], :group_by => session[:query][:group_by], :column_names => session[:query][:column_names], :totalable_names => session[:query][:totalable_names])
                   end
                   if session[:query].has_key?(:project_id)
                     @query.project_id = session[:query][:project_id]

app/models/issue_query.rb +35 -3

@@ -34,7 +34,7 class IssueQuery < Query
34	QueryColumn.new(:fixed_version, :sortable => lambda {Version.fields_for_order_statement}, :groupable => true),	34	QueryColumn.new(:fixed_version, :sortable => lambda {Version.fields_for_order_statement}, :groupable => true),
35	QueryColumn.new(:start_date, :sortable => "#{Issue.table_name}.start_date"),	35	QueryColumn.new(:start_date, :sortable => "#{Issue.table_name}.start_date"),
36	QueryColumn.new(:due_date, :sortable => "#{Issue.table_name}.due_date"),	36	QueryColumn.new(:due_date, :sortable => "#{Issue.table_name}.due_date"),
37	QueryColumn.new(:estimated_hours, :sortable => "#{Issue.table_name}.estimated_hours"),	37	QueryColumn.new(:estimated_hours, :sortable => "#{Issue.table_name}.estimated_hours", :totalable => true),
38	QueryColumn.new(:total_estimated_hours,	38	QueryColumn.new(:total_estimated_hours,
39	:sortable => "COALESCE((SELECT SUM(estimated_hours) FROM #{Issue.table_name} subtasks" +	39	:sortable => "COALESCE((SELECT SUM(estimated_hours) FROM #{Issue.table_name} subtasks" +
40	" WHERE subtasks.root_id = #{Issue.table_name}.root_id AND subtasks.lft >= #{Issue.table_name}.lft AND subtasks.rgt <= #{Issue.table_name}.rgt), 0)",	40	" WHERE subtasks.root_id = #{Issue.table_name}.root_id AND subtasks.lft >= #{Issue.table_name}.lft AND subtasks.rgt <= #{Issue.table_name}.rgt), 0)",
@@ -268,7 +268,8 class IssueQuery < Query
268	@available_columns.insert index, QueryColumn.new(:spent_hours,	268	@available_columns.insert index, QueryColumn.new(:spent_hours,
269	:sortable => "COALESCE((SELECT SUM(hours) FROM #{TimeEntry.table_name} WHERE #{TimeEntry.table_name}.issue_id = #{Issue.table_name}.id), 0)",	269	:sortable => "COALESCE((SELECT SUM(hours) FROM #{TimeEntry.table_name} WHERE #{TimeEntry.table_name}.issue_id = #{Issue.table_name}.id), 0)",
270	:default_order => 'desc',	270	:default_order => 'desc',
271	:caption => :label_spent_time	271	:caption => :label_spent_time,
		272	:totalable => true
272	)	273	)
273	@available_columns.insert index+1, QueryColumn.new(:total_spent_hours,	274	@available_columns.insert index+1, QueryColumn.new(:total_spent_hours,
274	:sortable => "COALESCE((SELECT SUM(hours) FROM #{TimeEntry.table_name} JOIN #{Issue.table_name} subtasks ON subtasks.id = #{TimeEntry.table_name}.issue_id" +	275	:sortable => "COALESCE((SELECT SUM(hours) FROM #{TimeEntry.table_name} JOIN #{Issue.table_name} subtasks ON subtasks.id = #{TimeEntry.table_name}.issue_id" +
@@ -299,13 +300,44 class IssueQuery < Query
299	end	300	end
300	end	301	end
301		302
		303	def base_scope
		304	Issue.visible.joins(:status, :project).where(statement)
		305	end
		306	private :base_scope
		307
302	# Returns the issue count	308	# Returns the issue count
303	def issue_count	309	def issue_count
304	Issue.visible.joins(:status, :project).where(statement).count	310	base_scope.count
305	rescue ::ActiveRecord::StatementInvalid => e	311	rescue ::ActiveRecord::StatementInvalid => e
306	raise StatementInvalid.new(e.message)	312	raise StatementInvalid.new(e.message)
307	end	313	end
308		314
		315	# Returns sum of all the issue's estimated_hours
		316	def total_for_estimated_hours
		317	base_scope.sum(:estimated_hours)
		318	end
		319
		320	# Returns sum of all the issue's time entries hours
		321	def total_for_spent_hours
		322	base_scope.joins(:time_entries).sum("#{TimeEntry.table_name}.hours")
		323	end
		324
		325	def total_for_custom_field(custom_field)
		326	base_scope.joins(:custom_values).
		327	where(:custom_values => {:custom_field_id => custom_field.id}).
		328	where.not(:custom_values => {:value => ''}).
		329	sum("CAST(#{CustomValue.table_name}.value AS decimal(30,3))")
		330	end
		331	private :total_for_custom_field
		332
		333	def total_for_float_custom_field(custom_field)
		334	total_for_custom_field(custom_field).to_f
		335	end
		336
		337	def total_for_int_custom_field(custom_field)
		338	total_for_custom_field(custom_field).to_i
		339	end
		340
309	# Returns the issue count by group or nil if query is not grouped	341	# Returns the issue count by group or nil if query is not grouped
310	def issue_count_by_group	342	def issue_count_by_group
311	r = nil	343	r = nil

app/models/query.rb +40 -1

             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class QueryColumn
-              attr_accessor :name, :sortable, :groupable, :default_order
+              attr_accessor :name, :sortable, :groupable, :totalable, :default_order
               include Redmine::I18n
               def initialize(name, options={})
                 if groupable == true
                   self.groupable = name.to_s
                 end
+                self.totalable = options[:totalable] || false
                 self.default_order = options[:default_order]
                 @inline = options.key?(:inline) ? options[:inline] : true
                 @caption_key = options[:caption] || "field_#{name}".to_sym
                 self.name = "cf_#{custom_field.id}".to_sym
                 self.sortable = custom_field.order_statement || false
                 self.groupable = custom_field.group_statement || false
+                self.totalable = ['int', 'float'].include?(custom_field.field_format)
                 @inline = true
                 @cf = custom_field
               end
                 end
                 self.group_by = params[:group_by] || (params[:query] && params[:query][:group_by])
                 self.column_names = params[:c] || (params[:query] && params[:query][:column_names])
+                self.totalable_names = params[:t] || (params[:query] && params[:query][:totalable_names])
                 self
               end
                 available_columns.reject(&:inline?)
               end
+              def available_totalable_columns
+                available_columns.select(&:totalable)
+              end
               def default_columns_names
                 []
               end
                 column_names.nil? || column_names.empty?
               end
+              def totalable_columns
+                names = totalable_names
+                available_totalable_columns.select {|column| names.include?(column.name)}
+              end
+              def totalable_names=(names)
+                if names
+                  names = names.select(&:present?).map {|n| n.is_a?(Symbol) ? n : n.to_sym}
+                end
+                options[:totalable_names] = names
+              end
+              def totalable_names
+                options[:totalable_names] || Setting.issue_list_default_totals.map(&:to_sym) || []
+              end
               def sort_criteria=(arg)
                 c = []
                 if arg.is_a?(Hash)
                 filters_clauses.any? ? filters_clauses.join(' AND ') : nil
               end
+              # Returns the sum of values for the given column
+              def total_for(column)
+                unless column.is_a?(QueryColumn)
+                  column = column.to_sym
+                  column = available_totalable_columns.detect {|c| c.name == column}
+                end
+                if column.is_a?(QueryCustomFieldColumn)
+                  custom_field = column.custom_field
+                  send "total_for_#{custom_field.field_format}_custom_field", custom_field
+                else
+                  send "total_for_#{column.name}"
+                end
+              rescue ::ActiveRecord::StatementInvalid => e
+                raise StatementInvalid.new(e.message)
+              end
               private
               def sql_for_custom_field(field, operator, value, custom_field_id)

app/views/issues/index.html.erb +5 0

                         <td><%= l(:button_show) %></td>
                         <td><%= available_block_columns_tags(@query) %></td>
                       </tr>
+                      <tr>
+                        <td><%= l(:label_total_plural) %></td>
+                        <td><%= available_totalable_columns_tags(@query) %></td>
+                      </tr>
                     </table>
                   </div>
                 </fieldset>
             <% if @issues.empty? %>
             <p class="nodata"><%= l(:label_no_data) %></p>
             <% else %>
+            <%= render_query_totals(@query) %>
             <%= render :partial => 'issues/list', :locals => {:issues => @issues, :query => @query} %>
             <p class="pagination"><%= pagination_links_full @issue_pages, @issue_count %></p>
             <% end %>

app/views/queries/_form.html.erb +3 0

             <p><label><%= l(:button_show) %></label>
             <%= available_block_columns_tags(@query) %></p>
+            <p><label><%= l(:label_total_plural) %></label>
+            <%= available_totalable_columns_tags(@query) %></p>
             </fieldset>
             <% else %>
             <fieldset><legend><%= l(:label_options) %></legend>

app/views/settings/_issues.html.erb +5 0

               <%= render_query_columns_selection(
                     IssueQuery.new(:column_names => Setting.issue_list_default_columns),
                     :name => 'settings[issue_list_default_columns]') %>
+              <p><%= setting_multiselect :issue_list_default_totals,
+                       IssueQuery.new(:totalable_names => Setting.issue_list_default_totals).available_totalable_columns.map {|c| [c.caption, c.name.to_s]},
+                       :inline => true,
+                       :label => :label_total_plural %></p>
             </fieldset>
             <%= submit_tag l(:button_save) %>

config/locales/en.yml +1 0

                 one:   1 issue
                 other: "%{count} issues"
               label_total: Total
+              label_total_plural: Totals
               label_total_time: Total time
               label_permissions: Permissions
               label_current_status: Current status

config/locales/fr.yml +1 0

                 one:   1 demande
                 other: "%{count} demandes"
               label_total: Total
+              label_total_plural: Totaux
               label_total_time: Temps total
               label_permissions: Permissions
               label_current_status: Statut actuel

config/settings.yml +3 0

               - subject
               - assigned_to
               - updated_on
+            issue_list_default_totals:
+              serialized: true
+              default: []
             display_subprojects_issues:
               default: 1
             issue_done_ratio:

public/stylesheets/application.css +3 0

               text-align: center;
             }
             table.query-columns td.buttons input[type=button] {width:35px;}
+            .query-totals {text-align:right; margin-top:-2.3em;}
+            .query-totals>span {margin-left:0.6em;}
+            .query-totals .value {font-weight:bold;}
             td.center {text-align:center;}

test/functional/issues_controller_test.rb +32 0

@@ -945,6 +945,38 class IssuesControllerTest < ActionController::TestCase
945	assert_select 'td.parent a[title=?]', parent.subject	945	assert_select 'td.parent a[title=?]', parent.subject
946	end	946	end
947		947
		948	def test_index_with_estimated_hours_total
		949	Issue.delete_all
		950	Issue.generate!(:estimated_hours => 5.5)
		951	Issue.generate!(:estimated_hours => 1.1)
		952
		953	get :index, :t => %w(estimated_hours)
		954	assert_response :success
		955	assert_select '.query-totals'
		956	assert_select '.total-for-estimated-hours span.value', :text => '6.6'
		957	assert_select 'input[type=checkbox][name=?][value=estimated_hours][checked=checked]', 't[]'
		958	end
		959
		960	def test_index_with_int_custom_field_total
		961	field = IssueCustomField.generate!(:field_format => 'int', :is_for_all => true)
		962	CustomValue.create!(:customized => Issue.find(1), :custom_field => field, :value => '2')
		963	CustomValue.create!(:customized => Issue.find(2), :custom_field => field, :value => '7')
		964
		965	get :index, :t => ["cf_#{field.id}"]
		966	assert_response :success
		967	assert_select '.query-totals'
		968	assert_select ".total-for-cf-#{field.id} span.value", :text => '9'
		969	end
		970
		971	def test_index_totals_should_default_to_settings
		972	with_settings :issue_list_default_totals => ['estimated_hours'] do
		973	get :index
		974	assert_response :success
		975	assert_select '.total-for-estimated-hours span.value'
		976	assert_select '.query-totals>span', 1
		977	end
		978	end
		979
948	def test_index_send_html_if_query_is_invalid	980	def test_index_send_html_if_query_is_invalid
949	get :index, :f => ['start_date'], :op => {:start_date => '='}	981	get :index, :f => ['start_date'], :op => {:start_date => '='}
950	assert_equal 'text/html', @response.content_type	982	assert_equal 'text/html', @response.content_type

test/unit/query_test.rb +76 0

@@ -1136,6 +1136,82 class QueryTest < ActiveSupport::TestCase
1136	assert_equal values.sort, values	1136	assert_equal values.sort, values
1137	end	1137	end
1138		1138
		1139	def test_set_totalable_names
		1140	q = IssueQuery.new
		1141	q.totalable_names = ['estimated_hours', :spent_hours, '']
		1142	assert_equal [:estimated_hours, :spent_hours], q.totalable_columns.map(&:name)
		1143	end
		1144
		1145	def test_totalable_columns_should_default_to_settings
		1146	with_settings :issue_list_default_totals => ['estimated_hours'] do
		1147	q = IssueQuery.new
		1148	assert_equal [:estimated_hours], q.totalable_columns.map(&:name)
		1149	end
		1150	end
		1151
		1152	def test_available_totalable_columns_should_include_estimated_hours
		1153	q = IssueQuery.new
		1154	assert_include :estimated_hours, q.available_totalable_columns.map(&:name)
		1155	end
		1156
		1157	def test_available_totalable_columns_should_include_spent_hours
		1158	User.current = User.find(1)
		1159
		1160	q = IssueQuery.new
		1161	assert_include :spent_hours, q.available_totalable_columns.map(&:name)
		1162	end
		1163
		1164	def test_available_totalable_columns_should_include_int_custom_field
		1165	field = IssueCustomField.generate!(:field_format => 'int', :is_for_all => true)
		1166	q = IssueQuery.new
		1167	assert_include "cf_#{field.id}".to_sym, q.available_totalable_columns.map(&:name)
		1168	end
		1169
		1170	def test_available_totalable_columns_should_include_float_custom_field
		1171	field = IssueCustomField.generate!(:field_format => 'float', :is_for_all => true)
		1172	q = IssueQuery.new
		1173	assert_include "cf_#{field.id}".to_sym, q.available_totalable_columns.map(&:name)
		1174	end
		1175
		1176	def test_total_for_estimated_hours
		1177	Issue.delete_all
		1178	Issue.generate!(:estimated_hours => 5.5)
		1179	Issue.generate!(:estimated_hours => 1.1)
		1180	Issue.generate!
		1181
		1182	q = IssueQuery.new
		1183	assert_equal 6.6, q.total_for(:estimated_hours)
		1184	end
		1185
		1186	def test_total_for_spent_hours
		1187	TimeEntry.delete_all
		1188	TimeEntry.generate!(:hours => 5.5)
		1189	TimeEntry.generate!(:hours => 1.1)
		1190
		1191	q = IssueQuery.new
		1192	assert_equal 6.6, q.total_for(:spent_hours)
		1193	end
		1194
		1195	def test_total_for_int_custom_field
		1196	field = IssueCustomField.generate!(:field_format => 'int', :is_for_all => true)
		1197	CustomValue.create!(:customized => Issue.find(1), :custom_field => field, :value => '2')
		1198	CustomValue.create!(:customized => Issue.find(2), :custom_field => field, :value => '7')
		1199	CustomValue.create!(:customized => Issue.find(3), :custom_field => field, :value => '')
		1200
		1201	q = IssueQuery.new
		1202	assert_equal 9, q.total_for("cf_#{field.id}")
		1203	end
		1204
		1205	def test_total_for_float_custom_field
		1206	field = IssueCustomField.generate!(:field_format => 'float', :is_for_all => true)
		1207	CustomValue.create!(:customized => Issue.find(1), :custom_field => field, :value => '2.3')
		1208	CustomValue.create!(:customized => Issue.find(2), :custom_field => field, :value => '7')
		1209	CustomValue.create!(:customized => Issue.find(3), :custom_field => field, :value => '')
		1210
		1211	q = IssueQuery.new
		1212	assert_equal 9.3, q.total_for("cf_#{field.id}")
		1213	end
		1214
1139	def test_invalid_query_should_raise_query_statement_invalid_error	1215	def test_invalid_query_should_raise_query_statement_invalid_error
1140	q = IssueQuery.new	1216	q = IssueQuery.new
1141	assert_raise Query::StatementInvalid do	1217	assert_raise Query::StatementInvalid do

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