jro_apps/redmine Commit - r15511:6501e1451a43

Merged r15890 (#24014)....

Jean-Philippe Lang -

r15511:6501e1451a43

parent child

Context file:

r15511:6501e1451a43

Collapse all files

app/models/time_entry_query.rb +12 -2

             # Redmine - project management software
             # Copyright (C) 2006-2016  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 TimeEntryQuery < Query
               self.queried_class = TimeEntry
               self.available_columns = [
                 QueryColumn.new(:project, :sortable => "#{Project.table_name}.name", :groupable => true),
                 QueryColumn.new(:spent_on, :sortable => ["#{TimeEntry.table_name}.spent_on", "#{TimeEntry.table_name}.created_on"], :default_order => 'desc', :groupable => true),
                 QueryColumn.new(:tweek, :sortable => ["#{TimeEntry.table_name}.spent_on", "#{TimeEntry.table_name}.created_on"], :caption => l(:label_week)),
                 QueryColumn.new(:user, :sortable => lambda {User.fields_for_order_statement}, :groupable => true),
                 QueryColumn.new(:activity, :sortable => "#{TimeEntryActivity.table_name}.position", :groupable => true),
                 QueryColumn.new(:issue, :sortable => "#{Issue.table_name}.id"),
                 QueryColumn.new(:comments),
                 QueryColumn.new(:hours, :sortable => "#{TimeEntry.table_name}.hours"),
               ]
               def initialize(attributes=nil, *args)
                 super attributes
                 self.filters ||= {}
                 add_filter('spent_on', '*') unless filters.present?
               end
               def initialize_available_filters
                 add_available_filter "spent_on", :type => :date_past
                 principals = []
                 if project
                   principals += project.principals.visible.sort
                   unless project.leaf?
                     subprojects = project.descendants.visible.to_a
                     if subprojects.any?
                       add_available_filter "subproject_id",
                         :type => :list_subprojects,
                         :values => subprojects.collect{|s| [s.name, s.id.to_s] }
                       principals += Principal.member_of(subprojects).visible
                     end
                   end
                 else
                   if all_projects.any?
                     # members of visible projects
                     principals += Principal.member_of(all_projects).visible
                     # project filter
                     project_values = []
                     if User.current.logged? && User.current.memberships.any?
                       project_values << ["<< #{l(:label_my_projects).downcase} >>", "mine"]
                     end
                     project_values += all_projects_values
                     add_available_filter("project_id",
                       :type => :list, :values => project_values
                     ) unless project_values.empty?
                   end
                 end
                 principals.uniq!
                 principals.sort!
                 users = principals.select {|p| p.is_a?(User)}
                 users_values = []
                 users_values << ["<< #{l(:label_me)} >>", "me"] if User.current.logged?
                 users_values += users.collect{|s| [s.name, s.id.to_s] }
                 add_available_filter("user_id",
                   :type => :list_optional, :values => users_values
                 ) unless users_values.empty?
                 activities = (project ? project.activities : TimeEntryActivity.shared)
                 add_available_filter("activity_id",
                   :type => :list, :values => activities.map {|a| [a.name, a.id.to_s]}
                 ) unless activities.empty?
                 add_available_filter "comments", :type => :text
                 add_available_filter "hours", :type => :float
                 add_custom_fields_filters(TimeEntryCustomField)
-                add_associations_custom_fields_filters :project, :issue, :user
+                add_associations_custom_fields_filters :project
+                add_custom_fields_filters(issue_custom_fields, :issue)
+                add_associations_custom_fields_filters :user
               end
               def available_columns
                 return @available_columns if @available_columns
                 @available_columns = self.class.available_columns.dup
                 @available_columns += TimeEntryCustomField.visible.
                                         map {|cf| QueryCustomFieldColumn.new(cf) }
-                @available_columns += IssueCustomField.visible.
+                @available_columns += issue_custom_fields.visible.
                                         map {|cf| QueryAssociationCustomFieldColumn.new(:issue, cf) }
                 @available_columns
               end
               def default_columns_names
                 @default_columns_names ||= [:project, :spent_on, :user, :activity, :issue, :comments, :hours]
               end
               def results_scope(options={})
                 order_option = [group_by_sort_order, options[:order]].flatten.reject(&:blank?)
                 TimeEntry.visible.
                   where(statement).
                   order(order_option).
                   joins(joins_for_order_statement(order_option.join(','))).
                   includes(:activity).
                   references(:activity)
               end
               def sql_for_activity_id_field(field, operator, value)
                 condition_on_id = sql_for_field(field, operator, value, Enumeration.table_name, 'id')
                 condition_on_parent_id = sql_for_field(field, operator, value, Enumeration.table_name, 'parent_id')
                 ids = value.map(&:to_i).join(',')
                 table_name = Enumeration.table_name
                 if operator == '='
                   "(#{table_name}.id IN (#{ids}) OR #{table_name}.parent_id IN (#{ids}))"
                 else
                   "(#{table_name}.id NOT IN (#{ids}) AND (#{table_name}.parent_id IS NULL OR #{table_name}.parent_id NOT IN (#{ids})))"
                 end
               end
               # Accepts :from/:to params as shortcut filters
               def build_from_params(params)
                 super
                 if params[:from].present? && params[:to].present?
                   add_filter('spent_on', '><', [params[:from], params[:to]])
                 elsif params[:from].present?
                   add_filter('spent_on', '>=', [params[:from]])
                 elsif params[:to].present?
                   add_filter('spent_on', '<=', [params[:to]])
                 end
                 self
               end
+              def issue_custom_fields
+                if project
+                  project.all_issue_custom_fields
+                else
+                  IssueCustomField.where(:is_for_all => true)
+                end
+              end
             end

test/unit/time_entry_query_test.rb +24 0

             # Redmine - project management software
             # Copyright (C) 2006-2016  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.expand_path('../../test_helper', __FILE__)
             class TimeEntryQueryTest < ActiveSupport::TestCase
               fixtures :issues, :projects, :users,
                        :members, :roles, :member_roles,
                        :trackers, :issue_statuses,
                        :projects_trackers,
                        :journals, :journal_details,
                        :issue_categories, :enumerations,
                        :groups_users,
                        :enabled_modules
               def test_cross_project_activity_filter_should_propose_non_active_activities
                 activity = TimeEntryActivity.create!(:name => 'Disabled', :active => false)
                 assert !activity.active?
                 query = TimeEntryQuery.new(:name => '_')
                 assert options = query.available_filters['activity_id']
                 assert values = options[:values]
                 assert_include ["Disabled", activity.id.to_s], values
               end
               def test_activity_filter_should_consider_system_and_project_activities
                 TimeEntry.delete_all
                 system = TimeEntryActivity.create!(:name => 'Foo')
                 TimeEntry.generate!(:activity => system, :hours => 1.0)
                 override = TimeEntryActivity.create!(:name => 'Foo', :parent_id => system.id, :project_id => 1)
                 other = TimeEntryActivity.create!(:name => 'Bar')
                 TimeEntry.generate!(:activity => override, :hours => 2.0)
                 TimeEntry.generate!(:activity => other, :hours => 4.0)
                 query = TimeEntryQuery.new(:name => '_')
                 query.add_filter('activity_id', '=', [system.id.to_s])
                 assert_equal 3.0, query.results_scope.sum(:hours)
                 query = TimeEntryQuery.new(:name => '_')
                 query.add_filter('activity_id', '!', [system.id.to_s])
                 assert_equal 4.0, query.results_scope.sum(:hours)
               end
+              def test_project_query_should_include_project_issue_custom_fields_only_as_filters
+                global = IssueCustomField.generate!(:is_for_all => true, :is_filter => true)
+                field_on_project = IssueCustomField.generate!(:is_for_all => false, :project_ids => [3], :is_filter => true)
+                field_not_on_project = IssueCustomField.generate!(:is_for_all => false, :project_ids => [1,2], :is_filter => true)
+                query = TimeEntryQuery.new(:project => Project.find(3))
+                assert_include "issue.cf_#{global.id}", query.available_filters.keys
+                assert_include "issue.cf_#{field_on_project.id}", query.available_filters.keys
+                assert_not_include "issue.cf_#{field_not_on_project.id}", query.available_filters.keys
+              end
+              def test_project_query_should_include_project_issue_custom_fields_only_as_columns
+                global = IssueCustomField.generate!(:is_for_all => true, :is_filter => true)
+                field_on_project = IssueCustomField.generate!(:is_for_all => false, :project_ids => [3], :is_filter => true)
+                field_not_on_project = IssueCustomField.generate!(:is_for_all => false, :project_ids => [1,2], :is_filter => true)
+                query = TimeEntryQuery.new(:project => Project.find(3))
+                assert_include "issue.cf_#{global.id}", query.available_columns.map(&:name).map(&:to_s)
+                assert_include "issue.cf_#{field_on_project.id}", query.available_columns.map(&:name).map(&:to_s)
+                assert_not_include "issue.cf_#{field_not_on_project.id}", query.available_columns.map(&:name).map(&:to_s)
+              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