jro_apps/redmine Commit - r3963:109b42f4828c

Added a "Member of Group" to the issues filter. #5869...

Eric Davis -

r3963:109b42f4828c

parent child

Context file:

r3963:109b42f4828c

Collapse all files

app/models/query.rb +19 0

             # 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.
             class QueryColumn
               attr_accessor :name, :sortable, :groupable, :default_order
               include Redmine::I18n
               def initialize(name, options={})
                 self.name = name
                 self.sortable = options[:sortable]
                 self.groupable = options[:groupable] || false
                 if groupable == true
                   self.groupable = name.to_s
                 end
                 self.default_order = options[:default_order]
                 @caption_key = options[:caption] || "field_#{name}"
               end
               def caption
                 l(@caption_key)
               end
               # Returns true if the column is sortable, otherwise false
               def sortable?
                 !sortable.nil?
               end
               def value(issue)
                 issue.send name
               end
             end
             class QueryCustomFieldColumn < QueryColumn
               def initialize(custom_field)
                 self.name = "cf_#{custom_field.id}".to_sym
                 self.sortable = custom_field.order_statement || false
                 if %w(list date bool int).include?(custom_field.field_format)
                   self.groupable = custom_field.order_statement
                 end
                 self.groupable ||= false
                 @cf = custom_field
               end
               def caption
                 @cf.name
               end
               def custom_field
                 @cf
               end
               def value(issue)
                 cv = issue.custom_values.detect {|v| v.custom_field_id == @cf.id}
                 cv && @cf.cast_value(cv.value)
               end
             end
             class Query < ActiveRecord::Base
               class StatementInvalid < ::ActiveRecord::StatementInvalid
               end
               belongs_to :project
               belongs_to :user
               serialize :filters
               serialize :column_names
               serialize :sort_criteria, Array
               attr_protected :project_id, :user_id
               validates_presence_of :name, :on => :save
               validates_length_of :name, :maximum => 255
               @@operators = { "="   => :label_equals,
                               "!"   => :label_not_equals,
                               "o"   => :label_open_issues,
                               "c"   => :label_closed_issues,
                               "!*"  => :label_none,
                               "*"   => :label_all,
                               ">="  => :label_greater_or_equal,
                               "<="  => :label_less_or_equal,
                               "<t+" => :label_in_less_than,
                               ">t+" => :label_in_more_than,
                               "t+"  => :label_in,
                               "t"   => :label_today,
                               "w"   => :label_this_week,
                               ">t-" => :label_less_than_ago,
                               "<t-" => :label_more_than_ago,
                               "t-"  => :label_ago,
                               "~"   => :label_contains,
                               "!~"  => :label_not_contains }
               cattr_reader :operators
               @@operators_by_filter_type = { :list => [ "=", "!" ],
                                              :list_status => [ "o", "=", "!", "c", "*" ],
                                              :list_optional => [ "=", "!", "!*", "*" ],
                                              :list_subprojects => [ "*", "!*", "=" ],
                                              :date => [ "<t+", ">t+", "t+", "t", "w", ">t-", "<t-", "t-" ],
                                              :date_past => [ ">t-", "<t-", "t-", "t", "w" ],
                                              :string => [ "=", "~", "!", "!~" ],
                                              :text => [  "~", "!~" ],
                                              :integer => [ "=", ">=", "<=", "!*", "*" ] }
               cattr_reader :operators_by_filter_type
               @@available_columns = [
                 QueryColumn.new(:project, :sortable => "#{Project.table_name}.name", :groupable => true),
                 QueryColumn.new(:tracker, :sortable => "#{Tracker.table_name}.position", :groupable => true),
                 QueryColumn.new(:parent, :sortable => ["#{Issue.table_name}.root_id", "#{Issue.table_name}.lft ASC"], :default_order => 'desc', :caption => :field_parent_issue),
                 QueryColumn.new(:status, :sortable => "#{IssueStatus.table_name}.position", :groupable => true),
                 QueryColumn.new(:priority, :sortable => "#{IssuePriority.table_name}.position", :default_order => 'desc', :groupable => true),
                 QueryColumn.new(:subject, :sortable => "#{Issue.table_name}.subject"),
                 QueryColumn.new(:author),
                 QueryColumn.new(:assigned_to, :sortable => ["#{User.table_name}.lastname", "#{User.table_name}.firstname", "#{User.table_name}.id"], :groupable => true),
                 QueryColumn.new(:updated_on, :sortable => "#{Issue.table_name}.updated_on", :default_order => 'desc'),
                 QueryColumn.new(:category, :sortable => "#{IssueCategory.table_name}.name", :groupable => true),
                 QueryColumn.new(:fixed_version, :sortable => ["#{Version.table_name}.effective_date", "#{Version.table_name}.name"], :default_order => 'desc', :groupable => true),
                 QueryColumn.new(:start_date, :sortable => "#{Issue.table_name}.start_date"),
                 QueryColumn.new(:due_date, :sortable => "#{Issue.table_name}.due_date"),
                 QueryColumn.new(:estimated_hours, :sortable => "#{Issue.table_name}.estimated_hours"),
                 QueryColumn.new(:done_ratio, :sortable => "#{Issue.table_name}.done_ratio", :groupable => true),
                 QueryColumn.new(:created_on, :sortable => "#{Issue.table_name}.created_on", :default_order => 'desc'),
               ]
               cattr_reader :available_columns
               def initialize(attributes = nil)
                 super attributes
                 self.filters ||= { 'status_id' => {:operator => "o", :values => [""]} }
               end
               def after_initialize
                 # Store the fact that project is nil (used in #editable_by?)
                 @is_for_all = project.nil?
               end
               def validate
                 filters.each_key do |field|
                   errors.add label_for(field), :blank unless
                       # filter requires one or more values
                       (values_for(field) and !values_for(field).first.blank?) or
                       # filter doesn't require any value
                       ["o", "c", "!*", "*", "t", "w"].include? operator_for(field)
                 end if filters
               end
               def editable_by?(user)
                 return false unless user
                 # Admin can edit them all and regular users can edit their private queries
                 return true if user.admin? || (!is_public && self.user_id == user.id)
                 # Members can not edit public queries that are for all project (only admin is allowed to)
                 is_public && !@is_for_all && user.allowed_to?(:manage_public_queries, project)
               end
               def available_filters
                 return @available_filters if @available_filters
                 trackers = project.nil? ? Tracker.find(:all, :order => 'position') : project.rolled_up_trackers
                 @available_filters = { "status_id" => { :type => :list_status, :order => 1, :values => IssueStatus.find(:all, :order => 'position').collect{|s| [s.name, s.id.to_s] } },
                                        "tracker_id" => { :type => :list, :order => 2, :values => trackers.collect{|s| [s.name, s.id.to_s] } },
                                        "priority_id" => { :type => :list, :order => 3, :values => IssuePriority.all.collect{|s| [s.name, s.id.to_s] } },
                                        "subject" => { :type => :text, :order => 8 },
                                        "created_on" => { :type => :date_past, :order => 9 },
                                        "updated_on" => { :type => :date_past, :order => 10 },
                                        "start_date" => { :type => :date, :order => 11 },
                                        "due_date" => { :type => :date, :order => 12 },
                                        "estimated_hours" => { :type => :integer, :order => 13 },
                                        "done_ratio" =>  { :type => :integer, :order => 14 }}
                 user_values = []
                 user_values << ["<< #{l(:label_me)} >>", "me"] if User.current.logged?
                 if project
                   user_values += project.users.sort.collect{|s| [s.name, s.id.to_s] }
                 else
                   project_ids = Project.all(:conditions => Project.visible_by(User.current)).collect(&:id)
                   if project_ids.any?
                     # members of the user's projects
                     user_values += User.active.find(:all, :conditions => ["#{User.table_name}.id IN (SELECT DISTINCT user_id FROM members WHERE project_id IN (?))", project_ids]).sort.collect{|s| [s.name, s.id.to_s] }
                   end
                 end
                 @available_filters["assigned_to_id"] = { :type => :list_optional, :order => 4, :values => user_values } unless user_values.empty?
                 @available_filters["author_id"] = { :type => :list, :order => 5, :values => user_values } unless user_values.empty?
+                group_values = Group.all.collect {|g| [g.name, g.id] }
+                @available_filters["member_of_group"] = { :type => :list_optional, :order => 6, :values => group_values } unless group_values.empty?
                 if User.current.logged?
                   @available_filters["watcher_id"] = { :type => :list, :order => 15, :values => [["<< #{l(:label_me)} >>", "me"]] }
                 end
                 if project
                   # project specific filters
                   unless @project.issue_categories.empty?
                     @available_filters["category_id"] = { :type => :list_optional, :order => 6, :values => @project.issue_categories.collect{|s| [s.name, s.id.to_s] } }
                   end
                   unless @project.shared_versions.empty?
                     @available_filters["fixed_version_id"] = { :type => :list_optional, :order => 7, :values => @project.shared_versions.sort.collect{|s| ["#{s.project.name} - #{s.name}", s.id.to_s] } }
                   end
                   unless @project.descendants.active.empty?
                     @available_filters["subproject_id"] = { :type => :list_subprojects, :order => 13, :values => @project.descendants.visible.collect{|s| [s.name, s.id.to_s] } }
                   end
                   add_custom_fields_filters(@project.all_issue_custom_fields)
                 else
                   # global filters for cross project issue list
                   system_shared_versions = Version.visible.find_all_by_sharing('system')
                   unless system_shared_versions.empty?
                     @available_filters["fixed_version_id"] = { :type => :list_optional, :order => 7, :values => system_shared_versions.sort.collect{|s| ["#{s.project.name} - #{s.name}", s.id.to_s] } }
                   end
                   add_custom_fields_filters(IssueCustomField.find(:all, :conditions => {:is_filter => true, :is_for_all => true}))
                   # project filter
                   project_values = Project.all(:conditions => Project.visible_by(User.current), :order => 'lft').map do |p|
                     pre = (p.level > 0 ? ('--' * p.level + ' ') : '')
                     ["#{pre}#{p.name}",p.id.to_s]
                   end
                   @available_filters["project_id"] = { :type => :list, :order => 1, :values => project_values}
                 end
                 @available_filters
               end
               def add_filter(field, operator, values)
                 # values must be an array
                 return unless values and values.is_a? Array # and !values.first.empty?
                 # check if field is defined as an available filter
                 if available_filters.has_key? field
                   filter_options = available_filters[field]
                   # check if operator is allowed for that filter
                   #if @@operators_by_filter_type[filter_options[:type]].include? operator
                   #  allowed_values = values & ([""] + (filter_options[:values] || []).collect {|val| val[1]})
                   #  filters[field] = {:operator => operator, :values => allowed_values } if (allowed_values.first and !allowed_values.first.empty?) or ["o", "c", "!*", "*", "t"].include? operator
                   #end
                   filters[field] = {:operator => operator, :values => values }
                 end
               end
               def add_short_filter(field, expression)
                 return unless expression
                 parms = expression.scan(/^(o|c|!\*|!|\*)?(.*)$/).first
                 add_filter field, (parms[0] || "="), [parms[1] || ""]
               end
               # Add multiple filters using +add_filter+
               def add_filters(fields, operators, values)
                 fields.each do |field|
                   add_filter(field, operators[field], values[field])
                 end
               end
               def has_filter?(field)
                 filters and filters[field]
               end
               def operator_for(field)
                 has_filter?(field) ? filters[field][:operator] : nil
               end
               def values_for(field)
                 has_filter?(field) ? filters[field][:values] : nil
               end
               def label_for(field)
                 label = available_filters[field][:name] if available_filters.has_key?(field)
                 label ||= field.gsub(/\_id$/, "")
               end
               def available_columns
                 return @available_columns if @available_columns
                 @available_columns = Query.available_columns
                 @available_columns += (project ?
                                         project.all_issue_custom_fields :
                                         IssueCustomField.find(:all)
                                        ).collect {|cf| QueryCustomFieldColumn.new(cf) }
               end
               def self.available_columns=(v)
                 self.available_columns = (v)
               end
               def self.add_available_column(column)
                 self.available_columns << (column) if column.is_a?(QueryColumn)
               end
               # Returns an array of columns that can be used to group the results
               def groupable_columns
                 available_columns.select {|c| c.groupable}
               end
               # Returns a Hash of columns and the key for sorting
               def sortable_columns
                 {'id' => "#{Issue.table_name}.id"}.merge(available_columns.inject({}) {|h, column|
                                                            h[column.name.to_s] = column.sortable
                                                            h
                                                          })
               end
               def columns
                 if has_default_columns?
                   available_columns.select do |c|
                     # Adds the project column by default for cross-project lists
                     Setting.issue_list_default_columns.include?(c.name.to_s) || (c.name == :project && project.nil?)
                   end
                 else
                   # preserve the column_names order
                   column_names.collect {|name| available_columns.find {|col| col.name == name}}.compact
                 end
               end
               def column_names=(names)
                 if names
                   names = names.select {|n| n.is_a?(Symbol) || !n.blank? }
                   names = names.collect {|n| n.is_a?(Symbol) ? n : n.to_sym }
                   # Set column_names to nil if default columns
                   if names.map(&:to_s) == Setting.issue_list_default_columns
                     names = nil
                   end
                 end
                 write_attribute(:column_names, names)
               end
               def has_column?(column)
                 column_names && column_names.include?(column.name)
               end
               def has_default_columns?
                 column_names.nil? || column_names.empty?
               end
               def sort_criteria=(arg)
                 c = []
                 if arg.is_a?(Hash)
                   arg = arg.keys.sort.collect {|k| arg[k]}
                 end
                 c = arg.select {|k,o| !k.to_s.blank?}.slice(0,3).collect {|k,o| [k.to_s, o == 'desc' ? o : 'asc']}
                 write_attribute(:sort_criteria, c)
               end
               def sort_criteria
                 read_attribute(:sort_criteria) || []
               end
               def sort_criteria_key(arg)
                 sort_criteria && sort_criteria[arg] && sort_criteria[arg].first
               end
               def sort_criteria_order(arg)
                 sort_criteria && sort_criteria[arg] && sort_criteria[arg].last
               end
               # Returns the SQL sort order that should be prepended for grouping
               def group_by_sort_order
                 if grouped? && (column = group_by_column)
                   column.sortable.is_a?(Array) ?
                     column.sortable.collect {|s| "#{s} #{column.default_order}"}.join(',') :
                     "#{column.sortable} #{column.default_order}"
                 end
               end
               # Returns true if the query is a grouped query
               def grouped?
                 !group_by.blank?
               end
               def group_by_column
                 groupable_columns.detect {|c| c.name.to_s == group_by}
               end
               def group_by_statement
                 group_by_column.groupable
               end
               def project_statement
                 project_clauses = []
                 if project && !@project.descendants.active.empty?
                   ids = [project.id]
                   if has_filter?("subproject_id")
                     case operator_for("subproject_id")
                     when '='
                       # include the selected subprojects
                       ids += values_for("subproject_id").each(&:to_i)
                     when '!*'
                       # main project only
                     else
                       # all subprojects
                       ids += project.descendants.collect(&:id)
                     end
                   elsif Setting.display_subprojects_issues?
                     ids += project.descendants.collect(&:id)
                   end
                   project_clauses << "#{Project.table_name}.id IN (%s)" % ids.join(',')
                 elsif project
                   project_clauses << "#{Project.table_name}.id = %d" % project.id
                 end
                 project_clauses <<  Project.allowed_to_condition(User.current, :view_issues)
                 project_clauses.join(' AND ')
               end
               def statement
                 # filters clauses
                 filters_clauses = []
                 filters.each_key do |field|
                   next if field == "subproject_id"
                   v = values_for(field).clone
                   next unless v and !v.empty?
                   operator = operator_for(field)
                   # "me" value subsitution
                   if %w(assigned_to_id author_id watcher_id).include?(field)
                     v.push(User.current.logged? ? User.current.id.to_s : "0") if v.delete("me")
                   end
                   sql = ''
                   if field =~ /^cf_(\d+)$/
                     # custom field
                     db_table = CustomValue.table_name
                     db_field = 'value'
                     is_custom_filter = true
                     sql << "#{Issue.table_name}.id IN (SELECT #{Issue.table_name}.id FROM #{Issue.table_name} LEFT OUTER JOIN #{db_table} ON #{db_table}.customized_type='Issue' AND #{db_table}.customized_id=#{Issue.table_name}.id AND #{db_table}.custom_field_id=#{$1} WHERE "
                     sql << sql_for_field(field, operator, v, db_table, db_field, true) + ')'
                   elsif field == 'watcher_id'
                     db_table = Watcher.table_name
                     db_field = 'user_id'
                     sql << "#{Issue.table_name}.id #{ operator == '=' ? 'IN' : 'NOT IN' } (SELECT #{db_table}.watchable_id FROM #{db_table} WHERE #{db_table}.watchable_type='Issue' AND "
                     sql << sql_for_field(field, '=', v, db_table, db_field) + ')'
+                  elsif field == "member_of_group" # named field
+                    if operator == '*' # Any group
+                      groups = Group.all
+                      members_of_groups = groups.collect(&:user_ids).flatten.compact.collect(&:to_s)
+                      operator = '=' # Override the operator since we want to find by assigned_to
+                    elsif operator == "!*"
+                      groups = Group.all
+                      members_of_groups = groups.collect(&:user_ids).flatten.compact.collect(&:to_s)
+                      operator = '!' # Override the operator since we want to find by assigned_to
+                    else
+                      groups = Group.find_all_by_id(v)
+                      members_of_groups = groups.collect(&:user_ids).flatten.compact.collect(&:to_s)
+                    end
+                    sql << '(' + sql_for_field("assigned_to_id", operator, members_of_groups, Issue.table_name, "assigned_to_id", false) + ')'
                   else
                     # regular field
                     db_table = Issue.table_name
                     db_field = field
                     sql << '(' + sql_for_field(field, operator, v, db_table, db_field) + ')'
                   end
                   filters_clauses << sql
                 end if filters and valid?
                 (filters_clauses << project_statement).join(' AND ')
               end
               # Returns the issue count
               def issue_count
                 Issue.count(:include => [:status, :project], :conditions => statement)
               rescue ::ActiveRecord::StatementInvalid => e
                 raise StatementInvalid.new(e.message)
               end
               # Returns the issue count by group or nil if query is not grouped
               def issue_count_by_group
                 r = nil
                 if grouped?
                   begin
                     # Rails will raise an (unexpected) RecordNotFound if there's only a nil group value
                     r = Issue.count(:group => group_by_statement, :include => [:status, :project], :conditions => statement)
                   rescue ActiveRecord::RecordNotFound
                     r = {nil => issue_count}
                   end
                   c = group_by_column
                   if c.is_a?(QueryCustomFieldColumn)
                     r = r.keys.inject({}) {|h, k| h[c.custom_field.cast_value(k)] = r[k]; h}
                   end
                 end
                 r
               rescue ::ActiveRecord::StatementInvalid => e
                 raise StatementInvalid.new(e.message)
               end
               # Returns the issues
               # Valid options are :order, :offset, :limit, :include, :conditions
               def issues(options={})
                 order_option = [group_by_sort_order, options[:order]].reject {|s| s.blank?}.join(',')
                 order_option = nil if order_option.blank?
                 Issue.find :all, :include => ([:status, :project] + (options[:include] || [])).uniq,
                                  :conditions => Query.merge_conditions(statement, options[:conditions]),
                                  :order => order_option,
                                  :limit  => options[:limit],
                                  :offset => options[:offset]
               rescue ::ActiveRecord::StatementInvalid => e
                 raise StatementInvalid.new(e.message)
               end
               # Returns the journals
               # Valid options are :order, :offset, :limit
               def journals(options={})
                 Journal.find :all, :include => [:details, :user, {:issue => [:project, :author, :tracker, :status]}],
                                    :conditions => statement,
                                    :order => options[:order],
                                    :limit => options[:limit],
                                    :offset => options[:offset]
               rescue ::ActiveRecord::StatementInvalid => e
                 raise StatementInvalid.new(e.message)
               end
               # Returns the versions
               # Valid options are :conditions
               def versions(options={})
                 Version.find :all, :include => :project,
                                    :conditions => Query.merge_conditions(project_statement, options[:conditions])
               rescue ::ActiveRecord::StatementInvalid => e
                 raise StatementInvalid.new(e.message)
               end
               private
               # Helper method to generate the WHERE sql for a +field+, +operator+ and a +value+
               def sql_for_field(field, operator, value, db_table, db_field, is_custom_filter=false)
                 sql = ''
                 case operator
                 when "="
                   sql = "#{db_table}.#{db_field} IN (" + value.collect{|val| "'#{connection.quote_string(val)}'"}.join(",") + ")"
                 when "!"
                   sql = "(#{db_table}.#{db_field} IS NULL OR #{db_table}.#{db_field} NOT IN (" + value.collect{|val| "'#{connection.quote_string(val)}'"}.join(",") + "))"
                 when "!*"
                   sql = "#{db_table}.#{db_field} IS NULL"
                   sql << " OR #{db_table}.#{db_field} = ''" if is_custom_filter
                 when "*"
                   sql = "#{db_table}.#{db_field} IS NOT NULL"
                   sql << " AND #{db_table}.#{db_field} <> ''" if is_custom_filter
                 when ">="
                   sql = "#{db_table}.#{db_field} >= #{value.first.to_i}"
                 when "<="
                   sql = "#{db_table}.#{db_field} <= #{value.first.to_i}"
                 when "o"
                   sql = "#{IssueStatus.table_name}.is_closed=#{connection.quoted_false}" if field == "status_id"
                 when "c"
                   sql = "#{IssueStatus.table_name}.is_closed=#{connection.quoted_true}" if field == "status_id"
                 when ">t-"
                   sql = date_range_clause(db_table, db_field, - value.first.to_i, 0)
                 when "<t-"
                   sql = date_range_clause(db_table, db_field, nil, - value.first.to_i)
                 when "t-"
                   sql = date_range_clause(db_table, db_field, - value.first.to_i, - value.first.to_i)
                 when ">t+"
                   sql = date_range_clause(db_table, db_field, value.first.to_i, nil)
                 when "<t+"
                   sql = date_range_clause(db_table, db_field, 0, value.first.to_i)
                 when "t+"
                   sql = date_range_clause(db_table, db_field, value.first.to_i, value.first.to_i)
                 when "t"
                   sql = date_range_clause(db_table, db_field, 0, 0)
                 when "w"
                   from = l(:general_first_day_of_week) == '7' ?
                   # week starts on sunday
                   ((Date.today.cwday == 7) ? Time.now.at_beginning_of_day : Time.now.at_beginning_of_week - 1.day) :
                     # week starts on monday (Rails default)
                     Time.now.at_beginning_of_week
                   sql = "#{db_table}.#{db_field} BETWEEN '%s' AND '%s'" % [connection.quoted_date(from), connection.quoted_date(from + 7.days)]
                 when "~"
                   sql = "LOWER(#{db_table}.#{db_field}) LIKE '%#{connection.quote_string(value.first.to_s.downcase)}%'"
                 when "!~"
                   sql = "LOWER(#{db_table}.#{db_field}) NOT LIKE '%#{connection.quote_string(value.first.to_s.downcase)}%'"
                 end
                 return sql
               end
               def add_custom_fields_filters(custom_fields)
                 @available_filters ||= {}
                 custom_fields.select(&:is_filter?).each do |field|
                   case field.field_format
                   when "text"
                     options = { :type => :text, :order => 20 }
                   when "list"
                     options = { :type => :list_optional, :values => field.possible_values, :order => 20}
                   when "date"
                     options = { :type => :date, :order => 20 }
                   when "bool"
                     options = { :type => :list, :values => [[l(:general_text_yes), "1"], [l(:general_text_no), "0"]], :order => 20 }
                   else
                     options = { :type => :string, :order => 20 }
                   end
                   @available_filters["cf_#{field.id}"] = options.merge({ :name => field.name })
                 end
               end
               # Returns a SQL clause for a date or datetime field.
               def date_range_clause(table, field, from, to)
                 s = []
                 if from
                   s << ("#{table}.#{field} > '%s'" % [connection.quoted_date((Date.yesterday + from).to_time.end_of_day)])
                 end
                 if to
                   s << ("#{table}.#{field} <= '%s'" % [connection.quoted_date((Date.today + to).to_time.end_of_day)])
                 end
                 s.join(' AND ')
               end
             end

config/locales/en.yml +1 0

             en:
               # Text direction: Left-to-Right (ltr) or Right-to-Left (rtl)
               direction: ltr
               date:
                 formats:
                   # Use the strftime parameters for formats.
                   # When no format has been given, it uses default.
                   # You can provide other formats here if you like!
                   default: "%m/%d/%Y"
                   short: "%b %d"
                   long: "%B %d, %Y"
                 day_names: [Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday]
                 abbr_day_names: [Sun, Mon, Tue, Wed, Thu, Fri, Sat]
                 # Don't forget the nil at the beginning; there's no such thing as a 0th month
                 month_names: [~, January, February, March, April, May, June, July, August, September, October, November, December]
                 abbr_month_names: [~, Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec]
                 # Used in date_select and datime_select.
                 order: [ :year, :month, :day ]
               time:
                 formats:
                   default: "%m/%d/%Y %I:%M %p"
                   time: "%I:%M %p"
                   short: "%d %b %H:%M"
                   long: "%B %d, %Y %H:%M"
                 am: "am"
                 pm: "pm"
               datetime:
                 distance_in_words:
                   half_a_minute: "half a minute"
                   less_than_x_seconds:
                     one:   "less than 1 second"
                     other: "less than {{count}} seconds"
                   x_seconds:
                     one:   "1 second"
                     other: "{{count}} seconds"
                   less_than_x_minutes:
                     one:   "less than a minute"
                     other: "less than {{count}} minutes"
                   x_minutes:
                     one:   "1 minute"
                     other: "{{count}} minutes"
                   about_x_hours:
                     one:   "about 1 hour"
                     other: "about {{count}} hours"
                   x_days:
                     one:   "1 day"
                     other: "{{count}} days"
                   about_x_months:
                     one:   "about 1 month"
                     other: "about {{count}} months"
                   x_months:
                     one:   "1 month"
                     other: "{{count}} months"
                   about_x_years:
                     one:   "about 1 year"
                     other: "about {{count}} years"
                   over_x_years:
                     one:   "over 1 year"
                     other: "over {{count}} years"
                   almost_x_years:
                     one:   "almost 1 year"
                     other: "almost {{count}} years"
               number:
                 # Default format for numbers
                 format:
                   separator: "."
                   delimiter: ""
                   precision: 3
                 human:
                   format:
                     delimiter: ""
                     precision: 1
                   storage_units:
                     format: "%n %u"
                     units:
                       byte:
                         one: "Byte"
                         other: "Bytes"
                       kb: "KB"
                       mb: "MB"
                       gb: "GB"
                       tb: "TB"
             # Used in array.to_sentence.
               support:
                 array:
                   sentence_connector: "and"
                   skip_last_comma: false
               activerecord:
                 errors:
                   messages:
                     inclusion: "is not included in the list"
                     exclusion: "is reserved"
                     invalid: "is invalid"
                     confirmation: "doesn't match confirmation"
                     accepted: "must be accepted"
                     empty: "can't be empty"
                     blank: "can't be blank"
                     too_long: "is too long (maximum is {{count}} characters)"
                     too_short: "is too short (minimum is {{count}} characters)"
                     wrong_length: "is the wrong length (should be {{count}} characters)"
                     taken: "has already been taken"
                     not_a_number: "is not a number"
                     not_a_date: "is not a valid date"
                     greater_than: "must be greater than {{count}}"
                     greater_than_or_equal_to: "must be greater than or equal to {{count}}"
                     equal_to: "must be equal to {{count}}"
                     less_than: "must be less than {{count}}"
                     less_than_or_equal_to: "must be less than or equal to {{count}}"
                     odd: "must be odd"
                     even: "must be even"
                     greater_than_start_date: "must be greater than start date"
                     not_same_project: "doesn't belong to the same project"
                     circular_dependency: "This relation would create a circular dependency"
                     cant_link_an_issue_with_a_descendant: "An issue can not be linked to one of its subtasks"
               actionview_instancetag_blank_option: Please select
               general_text_No: 'No'
               general_text_Yes: 'Yes'
               general_text_no: 'no'
               general_text_yes: 'yes'
               general_lang_name: 'English'
               general_csv_separator: ','
               general_csv_decimal_separator: '.'
               general_csv_encoding: ISO-8859-1
               general_pdf_encoding: ISO-8859-1
               general_first_day_of_week: '7'
               notice_account_updated: Account was successfully updated.
               notice_account_invalid_creditentials: Invalid user or password
               notice_account_password_updated: Password was successfully updated.
               notice_account_wrong_password: Wrong password
               notice_account_register_done: Account was successfully created. To activate your account, click on the link that was emailed to you.
               notice_account_unknown_email: Unknown user.
               notice_can_t_change_password: This account uses an external authentication source. Impossible to change the password.
               notice_account_lost_email_sent: An email with instructions to choose a new password has been sent to you.
               notice_account_activated: Your account has been activated. You can now log in.
               notice_successful_create: Successful creation.
               notice_successful_update: Successful update.
               notice_successful_delete: Successful deletion.
               notice_successful_connection: Successful connection.
               notice_file_not_found: The page you were trying to access doesn't exist or has been removed.
               notice_locking_conflict: Data has been updated by another user.
               notice_not_authorized: You are not authorized to access this page.
               notice_email_sent: "An email was sent to {{value}}"
               notice_email_error: "An error occurred while sending mail ({{value}})"
               notice_feeds_access_key_reseted: Your RSS access key was reset.
               notice_api_access_key_reseted: Your API access key was reset.
               notice_failed_to_save_issues: "Failed to save {{count}} issue(s) on {{total}} selected: {{ids}}."
               notice_failed_to_save_members: "Failed to save member(s): {{errors}}."
               notice_no_issue_selected: "No issue is selected! Please, check the issues you want to edit."
               notice_account_pending: "Your account was created and is now pending administrator approval."
               notice_default_data_loaded: Default configuration successfully loaded.
               notice_unable_delete_version: Unable to delete version.
               notice_unable_delete_time_entry: Unable to delete time log entry.
               notice_issue_done_ratios_updated: Issue done ratios updated.
               error_can_t_load_default_data: "Default configuration could not be loaded: {{value}}"
               error_scm_not_found: "The entry or revision was not found in the repository."
               error_scm_command_failed: "An error occurred when trying to access the repository: {{value}}"
               error_scm_annotate: "The entry does not exist or can not be annotated."
               error_issue_not_found_in_project: 'The issue was not found or does not belong to this project'
               error_no_tracker_in_project: 'No tracker is associated to this project. Please check the Project settings.'
               error_no_default_issue_status: 'No default issue status is defined. Please check your configuration (Go to "Administration -> Issue statuses").'
               error_can_not_delete_custom_field: Unable to delete custom field
               error_can_not_delete_tracker: "This tracker contains issues and can't be deleted."
               error_can_not_remove_role: "This role is in use and can not be deleted."
               error_can_not_reopen_issue_on_closed_version: 'An issue assigned to a closed version can not be reopened'
               error_can_not_archive_project: This project can not be archived
               error_issue_done_ratios_not_updated: "Issue done ratios not updated."
               error_workflow_copy_source: 'Please select a source tracker or role'
               error_workflow_copy_target: 'Please select target tracker(s) and role(s)'
               error_unable_delete_issue_status: 'Unable to delete issue status'
               error_unable_to_connect: "Unable to connect ({{value}})"
               warning_attachments_not_saved: "{{count}} file(s) could not be saved."
               mail_subject_lost_password: "Your {{value}} password"
               mail_body_lost_password: 'To change your password, click on the following link:'
               mail_subject_register: "Your {{value}} account activation"
               mail_body_register: 'To activate your account, click on the following link:'
               mail_body_account_information_external: "You can use your {{value}} account to log in."
               mail_body_account_information: Your account information
               mail_subject_account_activation_request: "{{value}} account activation request"
               mail_body_account_activation_request: "A new user ({{value}}) has registered. The account is pending your approval:"
               mail_subject_reminder: "{{count}} issue(s) due in the next {{days}} days"
               mail_body_reminder: "{{count}} issue(s) that are assigned to you are due in the next {{days}} days:"
               mail_subject_wiki_content_added: "'{{page}}' wiki page has been added"
               mail_body_wiki_content_added: "The '{{page}}' wiki page has been added by {{author}}."
               mail_subject_wiki_content_updated: "'{{page}}' wiki page has been updated"
               mail_body_wiki_content_updated: "The '{{page}}' wiki page has been updated by {{author}}."
               gui_validation_error: 1 error
               gui_validation_error_plural: "{{count}} errors"
               field_name: Name
               field_description: Description
               field_summary: Summary
               field_is_required: Required
               field_firstname: Firstname
               field_lastname: Lastname
               field_mail: Email
               field_filename: File
               field_filesize: Size
               field_downloads: Downloads
               field_author: Author
               field_created_on: Created
               field_updated_on: Updated
               field_field_format: Format
               field_is_for_all: For all projects
               field_possible_values: Possible values
               field_regexp: Regular expression
               field_min_length: Minimum length
               field_max_length: Maximum length
               field_value: Value
               field_category: Category
               field_title: Title
               field_project: Project
               field_issue: Issue
               field_status: Status
               field_notes: Notes
               field_is_closed: Issue closed
               field_is_default: Default value
               field_tracker: Tracker
               field_subject: Subject
               field_due_date: Due date
               field_assigned_to: Assignee
               field_priority: Priority
               field_fixed_version: Target version
               field_user: User
               field_principal: Principal
               field_role: Role
               field_homepage: Homepage
               field_is_public: Public
               field_parent: Subproject of
               field_is_in_roadmap: Issues displayed in roadmap
               field_login: Login
               field_mail_notification: Email notifications
               field_admin: Administrator
               field_last_login_on: Last connection
               field_language: Language
               field_effective_date: Date
               field_password: Password
               field_new_password: New password
               field_password_confirmation: Confirmation
               field_version: Version
               field_type: Type
               field_host: Host
               field_port: Port
               field_account: Account
               field_base_dn: Base DN
               field_attr_login: Login attribute
               field_attr_firstname: Firstname attribute
               field_attr_lastname: Lastname attribute
               field_attr_mail: Email attribute
               field_onthefly: On-the-fly user creation
               field_start_date: Start
               field_done_ratio: % Done
               field_auth_source: Authentication mode
               field_hide_mail: Hide my email address
               field_comments: Comment
               field_url: URL
               field_start_page: Start page
               field_subproject: Subproject
               field_hours: Hours
               field_activity: Activity
               field_spent_on: Date
               field_identifier: Identifier
               field_is_filter: Used as a filter
               field_issue_to: Related issue
               field_delay: Delay
               field_assignable: Issues can be assigned to this role
               field_redirect_existing_links: Redirect existing links
               field_estimated_hours: Estimated time
               field_column_names: Columns
               field_time_entries: Log time
               field_time_zone: Time zone
               field_searchable: Searchable
               field_default_value: Default value
               field_comments_sorting: Display comments
               field_parent_title: Parent page
               field_editable: Editable
               field_watcher: Watcher
               field_identity_url: OpenID URL
               field_content: Content
               field_group_by: Group results by
               field_sharing: Sharing
               field_parent_issue: Parent task
+              field_member_of_group: Member of Group
               setting_app_title: Application title
               setting_app_subtitle: Application subtitle
               setting_welcome_text: Welcome text
               setting_default_language: Default language
               setting_login_required: Authentication required
               setting_self_registration: Self-registration
               setting_attachment_max_size: Attachment max. size
               setting_issues_export_limit: Issues export limit
               setting_mail_from: Emission email address
               setting_bcc_recipients: Blind carbon copy recipients (bcc)
               setting_plain_text_mail: Plain text mail (no HTML)
               setting_host_name: Host name and path
               setting_text_formatting: Text formatting
               setting_wiki_compression: Wiki history compression
               setting_feeds_limit: Feed content limit
               setting_default_projects_public: New projects are public by default
               setting_autofetch_changesets: Autofetch commits
               setting_sys_api_enabled: Enable WS for repository management
               setting_commit_ref_keywords: Referencing keywords
               setting_commit_fix_keywords: Fixing keywords
               setting_autologin: Autologin
               setting_date_format: Date format
               setting_time_format: Time format
               setting_cross_project_issue_relations: Allow cross-project issue relations
               setting_issue_list_default_columns: Default columns displayed on the issue list
               setting_repositories_encodings: Repositories encodings
               setting_commit_logs_encoding: Commit messages encoding
               setting_emails_footer: Emails footer
               setting_protocol: Protocol
               setting_per_page_options: Objects per page options
               setting_user_format: Users display format
               setting_activity_days_default: Days displayed on project activity
               setting_display_subprojects_issues: Display subprojects issues on main projects by default
               setting_enabled_scm: Enabled SCM
               setting_mail_handler_body_delimiters: "Truncate emails after one of these lines"
               setting_mail_handler_api_enabled: Enable WS for incoming emails
               setting_mail_handler_api_key: API key
               setting_sequential_project_identifiers: Generate sequential project identifiers
               setting_gravatar_enabled: Use Gravatar user icons
               setting_gravatar_default: Default Gravatar image
               setting_diff_max_lines_displayed: Max number of diff lines displayed
               setting_file_max_size_displayed: Max size of text files displayed inline
               setting_repository_log_display_limit: Maximum number of revisions displayed on file log
               setting_openid: Allow OpenID login and registration
               setting_password_min_length: Minimum password length
               setting_new_project_user_role_id: Role given to a non-admin user who creates a project
               setting_default_projects_modules: Default enabled modules for new projects
               setting_issue_done_ratio: Calculate the issue done ratio with
               setting_issue_done_ratio_issue_field: Use the issue field
               setting_issue_done_ratio_issue_status: Use the issue status
               setting_start_of_week: Start calendars on
               setting_rest_api_enabled: Enable REST web service
               setting_cache_formatted_text: Cache formatted text
               permission_add_project: Create project
               permission_add_subprojects: Create subprojects
               permission_edit_project: Edit project
               permission_select_project_modules: Select project modules
               permission_manage_members: Manage members
               permission_manage_project_activities: Manage project activities
               permission_manage_versions: Manage versions
               permission_manage_categories: Manage issue categories
               permission_view_issues: View Issues
               permission_add_issues: Add issues
               permission_edit_issues: Edit issues
               permission_manage_issue_relations: Manage issue relations
               permission_add_issue_notes: Add notes
               permission_edit_issue_notes: Edit notes
               permission_edit_own_issue_notes: Edit own notes
               permission_move_issues: Move issues
               permission_delete_issues: Delete issues
               permission_manage_public_queries: Manage public queries
               permission_save_queries: Save queries
               permission_view_gantt: View gantt chart
               permission_view_calendar: View calendar
               permission_view_issue_watchers: View watchers list
               permission_add_issue_watchers: Add watchers
               permission_delete_issue_watchers: Delete watchers
               permission_log_time: Log spent time
               permission_view_time_entries: View spent time
               permission_edit_time_entries: Edit time logs
               permission_edit_own_time_entries: Edit own time logs
               permission_manage_news: Manage news
               permission_comment_news: Comment news
               permission_manage_documents: Manage documents
               permission_view_documents: View documents
               permission_manage_files: Manage files
               permission_view_files: View files
               permission_manage_wiki: Manage wiki
               permission_rename_wiki_pages: Rename wiki pages
               permission_delete_wiki_pages: Delete wiki pages
               permission_view_wiki_pages: View wiki
               permission_view_wiki_edits: View wiki history
               permission_edit_wiki_pages: Edit wiki pages
               permission_delete_wiki_pages_attachments: Delete attachments
               permission_protect_wiki_pages: Protect wiki pages
               permission_manage_repository: Manage repository
               permission_browse_repository: Browse repository
               permission_view_changesets: View changesets
               permission_commit_access: Commit access
               permission_manage_boards: Manage boards
               permission_view_messages: View messages
               permission_add_messages: Post messages
               permission_edit_messages: Edit messages
               permission_edit_own_messages: Edit own messages
               permission_delete_messages: Delete messages
               permission_delete_own_messages: Delete own messages
               permission_export_wiki_pages: Export wiki pages
               permission_manage_subtasks: Manage subtasks
               project_module_issue_tracking: Issue tracking
               project_module_time_tracking: Time tracking
               project_module_news: News
               project_module_documents: Documents
               project_module_files: Files
               project_module_wiki: Wiki
               project_module_repository: Repository
               project_module_boards: Boards
               project_module_calendar: Calendar
               project_module_gantt: Gantt
               label_user: User
               label_user_plural: Users
               label_user_new: New user
               label_user_anonymous: Anonymous
               label_project: Project
               label_project_new: New project
               label_project_plural: Projects
               label_x_projects:
                 zero:  no projects
                 one:   1 project
                 other: "{{count}} projects"
               label_project_all: All Projects
               label_project_latest: Latest projects
               label_issue: Issue
               label_issue_new: New issue
               label_issue_plural: Issues
               label_issue_view_all: View all issues
               label_issues_by: "Issues by {{value}}"
               label_issue_added: Issue added
               label_issue_updated: Issue updated
               label_document: Document
               label_document_new: New document
               label_document_plural: Documents
               label_document_added: Document added
               label_role: Role
               label_role_plural: Roles
               label_role_new: New role
               label_role_and_permissions: Roles and permissions
               label_member: Member
               label_member_new: New member
               label_member_plural: Members
               label_tracker: Tracker
               label_tracker_plural: Trackers
               label_tracker_new: New tracker
               label_workflow: Workflow
               label_issue_status: Issue status
               label_issue_status_plural: Issue statuses
               label_issue_status_new: New status
               label_issue_category: Issue category
               label_issue_category_plural: Issue categories
               label_issue_category_new: New category
               label_custom_field: Custom field
               label_custom_field_plural: Custom fields
               label_custom_field_new: New custom field
               label_enumerations: Enumerations
               label_enumeration_new: New value
               label_information: Information
               label_information_plural: Information
               label_please_login: Please log in
               label_register: Register
               label_login_with_open_id_option: or login with OpenID
               label_password_lost: Lost password
               label_home: Home
               label_my_page: My page
               label_my_account: My account
               label_my_projects: My projects
               label_my_page_block: My page block
               label_administration: Administration
               label_login: Sign in
               label_logout: Sign out
               label_help: Help
               label_reported_issues: Reported issues
               label_assigned_to_me_issues: Issues assigned to me
               label_last_login: Last connection
               label_registered_on: Registered on
               label_activity: Activity
               label_overall_activity: Overall activity
               label_user_activity: "{{value}}'s activity"
               label_new: New
               label_logged_as: Logged in as
               label_environment: Environment
               label_authentication: Authentication
               label_auth_source: Authentication mode
               label_auth_source_new: New authentication mode
               label_auth_source_plural: Authentication modes
               label_subproject_plural: Subprojects
               label_subproject_new: New subproject
               label_and_its_subprojects: "{{value}} and its subprojects"
               label_min_max_length: Min - Max length
               label_list: List
               label_date: Date
               label_integer: Integer
               label_float: Float
               label_boolean: Boolean
               label_string: Text
               label_text: Long text
               label_attribute: Attribute
               label_attribute_plural: Attributes
               label_download: "{{count}} Download"
               label_download_plural: "{{count}} Downloads"
               label_no_data: No data to display
               label_change_status: Change status
               label_history: History
               label_attachment: File
               label_attachment_new: New file
               label_attachment_delete: Delete file
               label_attachment_plural: Files
               label_file_added: File added
               label_report: Report
               label_report_plural: Reports
               label_news: News
               label_news_new: Add news
               label_news_plural: News
               label_news_latest: Latest news
               label_news_view_all: View all news
               label_news_added: News added
               label_settings: Settings
               label_overview: Overview
               label_version: Version
               label_version_new: New version
               label_version_plural: Versions
               label_close_versions: Close completed versions
               label_confirmation: Confirmation
               label_export_to: 'Also available in:'
               label_read: Read...
               label_public_projects: Public projects
               label_open_issues: open
               label_open_issues_plural: open
               label_closed_issues: closed
               label_closed_issues_plural: closed
               label_x_open_issues_abbr_on_total:
                 zero:  0 open / {{total}}
                 one:   1 open / {{total}}
                 other: "{{count}} open / {{total}}"
               label_x_open_issues_abbr:
                 zero:  0 open
                 one:   1 open
                 other: "{{count}} open"
               label_x_closed_issues_abbr:
                 zero:  0 closed
                 one:   1 closed
                 other: "{{count}} closed"
               label_total: Total
               label_permissions: Permissions
               label_current_status: Current status
               label_new_statuses_allowed: New statuses allowed
               label_all: all
               label_none: none
               label_nobody: nobody
               label_next: Next
               label_previous: Previous
               label_used_by: Used by
               label_details: Details
               label_add_note: Add a note
               label_per_page: Per page
               label_calendar: Calendar
               label_months_from: months from
               label_gantt: Gantt
               label_internal: Internal
               label_last_changes: "last {{count}} changes"
               label_change_view_all: View all changes
               label_personalize_page: Personalize this page
               label_comment: Comment
               label_comment_plural: Comments
               label_x_comments:
                 zero: no comments
                 one: 1 comment
                 other: "{{count}} comments"
               label_comment_add: Add a comment
               label_comment_added: Comment added
               label_comment_delete: Delete comments
               label_query: Custom query
               label_query_plural: Custom queries
               label_query_new: New query
               label_filter_add: Add filter
               label_filter_plural: Filters
               label_equals: is
               label_not_equals: is not
               label_in_less_than: in less than
               label_in_more_than: in more than
               label_greater_or_equal: '>='
               label_less_or_equal: '<='
               label_in: in
               label_today: today
               label_all_time: all time
               label_yesterday: yesterday
               label_this_week: this week
               label_last_week: last week
               label_last_n_days: "last {{count}} days"
               label_this_month: this month
               label_last_month: last month
               label_this_year: this year
               label_date_range: Date range
               label_less_than_ago: less than days ago
               label_more_than_ago: more than days ago
               label_ago: days ago
               label_contains: contains
               label_not_contains: doesn't contain
               label_day_plural: days
               label_repository: Repository
               label_repository_plural: Repositories
               label_browse: Browse
               label_modification: "{{count}} change"
               label_modification_plural: "{{count}} changes"
               label_branch: Branch
               label_tag: Tag
               label_revision: Revision
               label_revision_plural: Revisions
               label_revision_id: "Revision {{value}}"
               label_associated_revisions: Associated revisions
               label_added: added
               label_modified: modified
               label_copied: copied
               label_renamed: renamed
               label_deleted: deleted
               label_latest_revision: Latest revision
               label_latest_revision_plural: Latest revisions
               label_view_revisions: View revisions
               label_view_all_revisions: View all revisions
               label_max_size: Maximum size
               label_sort_highest: Move to top
               label_sort_higher: Move up
               label_sort_lower: Move down
               label_sort_lowest: Move to bottom
               label_roadmap: Roadmap
               label_roadmap_due_in: "Due in {{value}}"
               label_roadmap_overdue: "{{value}} late"
               label_roadmap_no_issues: No issues for this version
               label_search: Search
               label_result_plural: Results
               label_all_words: All words
               label_wiki: Wiki
               label_wiki_edit: Wiki edit
               label_wiki_edit_plural: Wiki edits
               label_wiki_page: Wiki page
               label_wiki_page_plural: Wiki pages
               label_index_by_title: Index by title
               label_index_by_date: Index by date
               label_current_version: Current version
               label_preview: Preview
               label_feed_plural: Feeds
               label_changes_details: Details of all changes
               label_issue_tracking: Issue tracking
               label_spent_time: Spent time
               label_overall_spent_time: Overall spent time
               label_f_hour: "{{value}} hour"
               label_f_hour_plural: "{{value}} hours"
               label_time_tracking: Time tracking
               label_change_plural: Changes
               label_statistics: Statistics
               label_commits_per_month: Commits per month
               label_commits_per_author: Commits per author
               label_view_diff: View differences
               label_diff_inline: inline
               label_diff_side_by_side: side by side
               label_options: Options
               label_copy_workflow_from: Copy workflow from
               label_permissions_report: Permissions report
               label_watched_issues: Watched issues
               label_related_issues: Related issues
               label_applied_status: Applied status
               label_loading: Loading...
               label_relation_new: New relation
               label_relation_delete: Delete relation
               label_relates_to: related to
               label_duplicates: duplicates
               label_duplicated_by: duplicated by
               label_blocks: blocks
               label_blocked_by: blocked by
               label_precedes: precedes
               label_follows: follows
               label_end_to_start: end to start
               label_end_to_end: end to end
               label_start_to_start: start to start
               label_start_to_end: start to end
               label_stay_logged_in: Stay logged in
               label_disabled: disabled
               label_show_completed_versions: Show completed versions
               label_me: me
               label_board: Forum
               label_board_new: New forum
               label_board_plural: Forums
               label_board_locked: Locked
               label_board_sticky: Sticky
               label_topic_plural: Topics
               label_message_plural: Messages
               label_message_last: Last message
               label_message_new: New message
               label_message_posted: Message added
               label_reply_plural: Replies
               label_send_information: Send account information to the user
               label_year: Year
               label_month: Month
               label_week: Week
               label_date_from: From
               label_date_to: To
               label_language_based: Based on user's language
               label_sort_by: "Sort by {{value}}"
               label_send_test_email: Send a test email
               label_feeds_access_key: RSS access key
               label_missing_feeds_access_key: Missing a RSS access key
               label_feeds_access_key_created_on: "RSS access key created {{value}} ago"
               label_module_plural: Modules
               label_added_time_by: "Added by {{author}} {{age}} ago"
               label_updated_time_by: "Updated by {{author}} {{age}} ago"
               label_updated_time: "Updated {{value}} ago"
               label_jump_to_a_project: Jump to a project...
               label_file_plural: Files
               label_changeset_plural: Changesets
               label_default_columns: Default columns
               label_no_change_option: (No change)
               label_bulk_edit_selected_issues: Bulk edit selected issues
               label_theme: Theme
               label_default: Default
               label_search_titles_only: Search titles only
               label_user_mail_option_all: "For any event on all my projects"
               label_user_mail_option_selected: "For any event on the selected projects only..."
               label_user_mail_option_none: "Only for things I watch or I'm involved in"
               label_user_mail_no_self_notified: "I don't want to be notified of changes that I make myself"
               label_registration_activation_by_email: account activation by email
               label_registration_manual_activation: manual account activation
               label_registration_automatic_activation: automatic account activation
               label_display_per_page: "Per page: {{value}}"
               label_age: Age
               label_change_properties: Change properties
               label_general: General
               label_more: More
               label_scm: SCM
               label_plugins: Plugins
               label_ldap_authentication: LDAP authentication
               label_downloads_abbr: D/L
               label_optional_description: Optional description
               label_add_another_file: Add another file
               label_preferences: Preferences
               label_chronological_order: In chronological order
               label_reverse_chronological_order: In reverse chronological order
               label_planning: Planning
               label_incoming_emails: Incoming emails
               label_generate_key: Generate a key
               label_issue_watchers: Watchers
               label_example: Example
               label_display: Display
               label_sort: Sort
               label_ascending: Ascending
               label_descending: Descending
               label_date_from_to: From {{start}} to {{end}}
               label_wiki_content_added: Wiki page added
               label_wiki_content_updated: Wiki page updated
               label_group: Group
               label_group_plural: Groups
               label_group_new: New group
               label_time_entry_plural: Spent time
               label_version_sharing_none: Not shared
               label_version_sharing_descendants: With subprojects
               label_version_sharing_hierarchy: With project hierarchy
               label_version_sharing_tree: With project tree
               label_version_sharing_system: With all projects
               label_update_issue_done_ratios: Update issue done ratios
               label_copy_source: Source
               label_copy_target: Target
               label_copy_same_as_target: Same as target
               label_display_used_statuses_only: Only display statuses that are used by this tracker
               label_api_access_key: API access key
               label_missing_api_access_key: Missing an API access key
               label_api_access_key_created_on: "API access key created {{value}} ago"
               label_profile: Profile
               label_subtask_plural: Subtasks
               label_project_copy_notifications: Send email notifications during the project copy
               button_login: Login
               button_submit: Submit
               button_save: Save
               button_check_all: Check all
               button_uncheck_all: Uncheck all
               button_delete: Delete
               button_create: Create
               button_create_and_continue: Create and continue
               button_test: Test
               button_edit: Edit
               button_add: Add
               button_change: Change
               button_apply: Apply
               button_clear: Clear
               button_lock: Lock
               button_unlock: Unlock
               button_download: Download
               button_list: List
               button_view: View
               button_move: Move
               button_move_and_follow: Move and follow
               button_back: Back
               button_cancel: Cancel
               button_activate: Activate
               button_sort: Sort
               button_log_time: Log time
               button_rollback: Rollback to this version
               button_watch: Watch
               button_unwatch: Unwatch
               button_reply: Reply
               button_archive: Archive
               button_unarchive: Unarchive
               button_reset: Reset
               button_rename: Rename
               button_change_password: Change password
               button_copy: Copy
               button_copy_and_follow: Copy and follow
               button_annotate: Annotate
               button_update: Update
               button_configure: Configure
               button_quote: Quote
               button_duplicate: Duplicate
               button_show: Show
               status_active: active
               status_registered: registered
               status_locked: locked
               version_status_open: open
               version_status_locked: locked
               version_status_closed: closed
               field_active: Active
               text_select_mail_notifications: Select actions for which email notifications should be sent.
               text_regexp_info: eg. ^[A-Z0-9]+$
               text_min_max_length_info: 0 means no restriction
               text_project_destroy_confirmation: Are you sure you want to delete this project and related data ?
               text_subprojects_destroy_warning: "Its subproject(s): {{value}} will be also deleted."
               text_workflow_edit: Select a role and a tracker to edit the workflow
               text_are_you_sure: Are you sure ?
               text_journal_changed: "{{label}} changed from {{old}} to {{new}}"
               text_journal_set_to: "{{label}} set to {{value}}"
               text_journal_deleted: "{{label}} deleted ({{old}})"
               text_journal_added: "{{label}} {{value}} added"
               text_tip_task_begin_day: task beginning this day
               text_tip_task_end_day: task ending this day
               text_tip_task_begin_end_day: task beginning and ending this day
               text_project_identifier_info: 'Only lower case letters (a-z), numbers and dashes are allowed.<br />Once saved, the identifier can not be changed.'
               text_caracters_maximum: "{{count}} characters maximum."
               text_caracters_minimum: "Must be at least {{count}} characters long."
               text_length_between: "Length between {{min}} and {{max}} characters."
               text_tracker_no_workflow: No workflow defined for this tracker
               text_unallowed_characters: Unallowed characters
               text_comma_separated: Multiple values allowed (comma separated).
               text_line_separated: Multiple values allowed (one line for each value).
               text_issues_ref_in_commit_messages: Referencing and fixing issues in commit messages
               text_issue_added: "Issue {{id}} has been reported by {{author}}."
               text_issue_updated: "Issue {{id}} has been updated by {{author}}."
               text_wiki_destroy_confirmation: Are you sure you want to delete this wiki and all its content ?
               text_issue_category_destroy_question: "Some issues ({{count}}) are assigned to this category. What do you want to do ?"
               text_issue_category_destroy_assignments: Remove category assignments
               text_issue_category_reassign_to: Reassign issues to this category
               text_user_mail_option: "For unselected projects, you will only receive notifications about things you watch or you're involved in (eg. issues you're the author or assignee)."
               text_no_configuration_data: "Roles, trackers, issue statuses and workflow have not been configured yet.\nIt is highly recommended to load the default configuration. You will be able to modify it once loaded."
               text_load_default_configuration: Load the default configuration
               text_status_changed_by_changeset: "Applied in changeset {{value}}."
               text_issues_destroy_confirmation: 'Are you sure you want to delete the selected issue(s) ?'
               text_select_project_modules: 'Select modules to enable for this project:'
               text_default_administrator_account_changed: Default administrator account changed
               text_file_repository_writable: Attachments directory writable
               text_plugin_assets_writable: Plugin assets directory writable
               text_rmagick_available: RMagick available (optional)
               text_destroy_time_entries_question: "{{hours}} hours were reported on the issues you are about to delete. What do you want to do ?"
               text_destroy_time_entries: Delete reported hours
               text_assign_time_entries_to_project: Assign reported hours to the project
               text_reassign_time_entries: 'Reassign reported hours to this issue:'
               text_user_wrote: "{{value}} wrote:"
               text_enumeration_destroy_question: "{{count}} objects are assigned to this value."
               text_enumeration_category_reassign_to: 'Reassign them to this value:'
               text_email_delivery_not_configured: "Email delivery is not configured, and notifications are disabled.\nConfigure your SMTP server in config/email.yml and restart the application to enable them."
               text_repository_usernames_mapping: "Select or update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."
               text_diff_truncated: '... This diff was truncated because it exceeds the maximum size that can be displayed.'
               text_custom_field_possible_values_info: 'One line for each value'
               text_wiki_page_destroy_question: "This page has {{descendants}} child page(s) and descendant(s). What do you want to do?"
               text_wiki_page_nullify_children: "Keep child pages as root pages"
               text_wiki_page_destroy_children: "Delete child pages and all their descendants"
               text_wiki_page_reassign_children: "Reassign child pages to this parent page"
               text_own_membership_delete_confirmation: "You are about to remove some or all of your permissions and may no longer be able to edit this project after that.\nAre you sure you want to continue?"
               text_zoom_in: Zoom in
               text_zoom_out: Zoom out
               default_role_manager: Manager
               default_role_developer: Developer
               default_role_reporter: Reporter
               default_tracker_bug: Bug
               default_tracker_feature: Feature
               default_tracker_support: Support
               default_issue_status_new: New
               default_issue_status_in_progress: In Progress
               default_issue_status_resolved: Resolved
               default_issue_status_feedback: Feedback
               default_issue_status_closed: Closed
               default_issue_status_rejected: Rejected
               default_doc_category_user: User documentation
               default_doc_category_tech: Technical documentation
               default_priority_low: Low
               default_priority_normal: Normal
               default_priority_high: High
               default_priority_urgent: Urgent
               default_priority_immediate: Immediate
               default_activity_design: Design
               default_activity_development: Development
               enumeration_issue_priorities: Issue priorities
               enumeration_doc_categories: Document categories
               enumeration_activities: Activities (time tracking)
               enumeration_system_activity: System Activity

test/unit/query_test.rb +88 -2

             # 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 QueryTest < ActiveSupport::TestCase
               fixtures :projects, :enabled_modules, :users, :members, :member_roles, :roles, :trackers, :issue_statuses, :issue_categories, :enumerations, :issues, :watchers, :custom_fields, :custom_values, :versions, :queries
               def test_custom_fields_for_all_projects_should_be_available_in_global_queries
                 query = Query.new(:project => nil, :name => '_')
                 assert query.available_filters.has_key?('cf_1')
                 assert !query.available_filters.has_key?('cf_3')
               end
               def test_system_shared_versions_should_be_available_in_global_queries
                 Version.find(2).update_attribute :sharing, 'system'
                 query = Query.new(:project => nil, :name => '_')
                 assert query.available_filters.has_key?('fixed_version_id')
                 assert query.available_filters['fixed_version_id'][:values].detect {|v| v.last == '2'}
               end
               def test_project_filter_in_global_queries
                 query = Query.new(:project => nil, :name => '_')
                 project_filter = query.available_filters["project_id"]
                 assert_not_nil project_filter
                 project_ids = project_filter[:values].map{|p| p[1]}
                 assert project_ids.include?("1")  #public project
                 assert !project_ids.include?("2") #private project user cannot see
               end
               def find_issues_with_query(query)
                 Issue.find :all,
                   :include => [ :assigned_to, :status, :tracker, :project, :priority ],
                   :conditions => query.statement
               end
+              def assert_find_issues_with_query_is_successful(query)
+                assert_nothing_raised do
+                  find_issues_with_query(query)
+                end
+              end
+              def assert_query_statement_includes(query, condition)
+                assert query.statement.include?(condition), "Query statement condition not found in: #{query.statement}"
+              end
               def test_query_should_allow_shared_versions_for_a_project_query
                 subproject_version = Version.find(4)
                 query = Query.new(:project => Project.find(1), :name => '_')
                 query.add_filter('fixed_version_id', '=', [subproject_version.id.to_s])
                 assert query.statement.include?("#{Issue.table_name}.fixed_version_id IN ('4')")
               end
               def test_query_with_multiple_custom_fields
                 query = Query.find(1)
                 assert query.valid?
                 assert query.statement.include?("#{CustomValue.table_name}.value IN ('MySQL')")
                 issues = find_issues_with_query(query)
                 assert_equal 1, issues.length
                 assert_equal Issue.find(3), issues.first
               end
               def test_operator_none
                 query = Query.new(:project => Project.find(1), :name => '_')
                 query.add_filter('fixed_version_id', '!*', [''])
                 query.add_filter('cf_1', '!*', [''])
                 assert query.statement.include?("#{Issue.table_name}.fixed_version_id IS NULL")
                 assert query.statement.include?("#{CustomValue.table_name}.value IS NULL OR #{CustomValue.table_name}.value = ''")
                 find_issues_with_query(query)
               end
               def test_operator_none_for_integer
                 query = Query.new(:project => Project.find(1), :name => '_')
                 query.add_filter('estimated_hours', '!*', [''])
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 assert issues.all? {|i| !i.estimated_hours}
               end
               def test_operator_all
                 query = Query.new(:project => Project.find(1), :name => '_')
                 query.add_filter('fixed_version_id', '*', [''])
                 query.add_filter('cf_1', '*', [''])
                 assert query.statement.include?("#{Issue.table_name}.fixed_version_id IS NOT NULL")
                 assert query.statement.include?("#{CustomValue.table_name}.value IS NOT NULL AND #{CustomValue.table_name}.value <> ''")
                 find_issues_with_query(query)
               end
               def test_operator_greater_than
                 query = Query.new(:project => Project.find(1), :name => '_')
                 query.add_filter('done_ratio', '>=', ['40'])
                 assert query.statement.include?("#{Issue.table_name}.done_ratio >= 40")
                 find_issues_with_query(query)
               end
               def test_operator_in_more_than
                 Issue.find(7).update_attribute(:due_date, (Date.today + 15))
                 query = Query.new(:project => Project.find(1), :name => '_')
                 query.add_filter('due_date', '>t+', ['15'])
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 issues.each {|issue| assert(issue.due_date >= (Date.today + 15))}
               end
               def test_operator_in_less_than
                 query = Query.new(:project => Project.find(1), :name => '_')
                 query.add_filter('due_date', '<t+', ['15'])
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 issues.each {|issue| assert(issue.due_date >= Date.today && issue.due_date <= (Date.today + 15))}
               end
               def test_operator_less_than_ago
                 Issue.find(7).update_attribute(:due_date, (Date.today - 3))
                 query = Query.new(:project => Project.find(1), :name => '_')
                 query.add_filter('due_date', '>t-', ['3'])
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 issues.each {|issue| assert(issue.due_date >= (Date.today - 3) && issue.due_date <= Date.today)}
               end
               def test_operator_more_than_ago
                 Issue.find(7).update_attribute(:due_date, (Date.today - 10))
                 query = Query.new(:project => Project.find(1), :name => '_')
                 query.add_filter('due_date', '<t-', ['10'])
                 assert query.statement.include?("#{Issue.table_name}.due_date <=")
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 issues.each {|issue| assert(issue.due_date <= (Date.today - 10))}
               end
               def test_operator_in
                 Issue.find(7).update_attribute(:due_date, (Date.today + 2))
                 query = Query.new(:project => Project.find(1), :name => '_')
                 query.add_filter('due_date', 't+', ['2'])
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 issues.each {|issue| assert_equal((Date.today + 2), issue.due_date)}
               end
               def test_operator_ago
                 Issue.find(7).update_attribute(:due_date, (Date.today - 3))
                 query = Query.new(:project => Project.find(1), :name => '_')
                 query.add_filter('due_date', 't-', ['3'])
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 issues.each {|issue| assert_equal((Date.today - 3), issue.due_date)}
               end
               def test_operator_today
                 query = Query.new(:project => Project.find(1), :name => '_')
                 query.add_filter('due_date', 't', [''])
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 issues.each {|issue| assert_equal Date.today, issue.due_date}
               end
               def test_operator_this_week_on_date
                 query = Query.new(:project => Project.find(1), :name => '_')
                 query.add_filter('due_date', 'w', [''])
                 find_issues_with_query(query)
               end
               def test_operator_this_week_on_datetime
                 query = Query.new(:project => Project.find(1), :name => '_')
                 query.add_filter('created_on', 'w', [''])
                 find_issues_with_query(query)
               end
               def test_operator_contains
                 query = Query.new(:project => Project.find(1), :name => '_')
                 query.add_filter('subject', '~', ['uNable'])
                 assert query.statement.include?("LOWER(#{Issue.table_name}.subject) LIKE '%unable%'")
                 result = find_issues_with_query(query)
                 assert result.empty?
                 result.each {|issue| assert issue.subject.downcase.include?('unable') }
               end
               def test_operator_does_not_contains
                 query = Query.new(:project => Project.find(1), :name => '_')
                 query.add_filter('subject', '!~', ['uNable'])
                 assert query.statement.include?("LOWER(#{Issue.table_name}.subject) NOT LIKE '%unable%'")
                 find_issues_with_query(query)
               end
               def test_filter_watched_issues
                 User.current = User.find(1)
                 query = Query.new(:name => '_', :filters => { 'watcher_id' => {:operator => '=', :values => ['me']}})
                 result = find_issues_with_query(query)
                 assert_not_nil result
                 assert !result.empty?
                 assert_equal Issue.visible.watched_by(User.current).sort_by(&:id), result.sort_by(&:id)
                 User.current = nil
               end
               def test_filter_unwatched_issues
                 User.current = User.find(1)
                 query = Query.new(:name => '_', :filters => { 'watcher_id' => {:operator => '!', :values => ['me']}})
                 result = find_issues_with_query(query)
                 assert_not_nil result
                 assert !result.empty?
                 assert_equal((Issue.visible - Issue.watched_by(User.current)).sort_by(&:id).size, result.sort_by(&:id).size)
                 User.current = nil
               end
               def test_default_columns
                 q = Query.new
                 assert !q.columns.empty?
               end
               def test_set_column_names
                 q = Query.new
                 q.column_names = ['tracker', :subject, '', 'unknonw_column']
                 assert_equal [:tracker, :subject], q.columns.collect {|c| c.name}
                 c = q.columns.first
                 assert q.has_column?(c)
               end
               def test_groupable_columns_should_include_custom_fields
                 q = Query.new
                 assert q.groupable_columns.detect {|c| c.is_a? QueryCustomFieldColumn}
               end
               def test_default_sort
                 q = Query.new
                 assert_equal [], q.sort_criteria
               end
               def test_set_sort_criteria_with_hash
                 q = Query.new
                 q.sort_criteria = {'0' => ['priority', 'desc'], '2' => ['tracker']}
                 assert_equal [['priority', 'desc'], ['tracker', 'asc']], q.sort_criteria
               end
               def test_set_sort_criteria_with_array
                 q = Query.new
                 q.sort_criteria = [['priority', 'desc'], 'tracker']
                 assert_equal [['priority', 'desc'], ['tracker', 'asc']], q.sort_criteria
               end
               def test_create_query_with_sort
                 q = Query.new(:name => 'Sorted')
                 q.sort_criteria = [['priority', 'desc'], 'tracker']
                 assert q.save
                 q.reload
                 assert_equal [['priority', 'desc'], ['tracker', 'asc']], q.sort_criteria
               end
               def test_sort_by_string_custom_field_asc
                 q = Query.new
                 c = q.available_columns.find {|col| col.is_a?(QueryCustomFieldColumn) && col.custom_field.field_format == 'string' }
                 assert c
                 assert c.sortable
                 issues = Issue.find :all,
                                     :include => [ :assigned_to, :status, :tracker, :project, :priority ],
                                     :conditions => q.statement,
                                     :order => "#{c.sortable} ASC"
                 values = issues.collect {|i| i.custom_value_for(c.custom_field).to_s}
                 assert !values.empty?
                 assert_equal values.sort, values
               end
               def test_sort_by_string_custom_field_desc
                 q = Query.new
                 c = q.available_columns.find {|col| col.is_a?(QueryCustomFieldColumn) && col.custom_field.field_format == 'string' }
                 assert c
                 assert c.sortable
                 issues = Issue.find :all,
                                     :include => [ :assigned_to, :status, :tracker, :project, :priority ],
                                     :conditions => q.statement,
                                     :order => "#{c.sortable} DESC"
                 values = issues.collect {|i| i.custom_value_for(c.custom_field).to_s}
                 assert !values.empty?
                 assert_equal values.sort.reverse, values
               end
               def test_sort_by_float_custom_field_asc
                 q = Query.new
                 c = q.available_columns.find {|col| col.is_a?(QueryCustomFieldColumn) && col.custom_field.field_format == 'float' }
                 assert c
                 assert c.sortable
                 issues = Issue.find :all,
                                     :include => [ :assigned_to, :status, :tracker, :project, :priority ],
                                     :conditions => q.statement,
                                     :order => "#{c.sortable} ASC"
                 values = issues.collect {|i| begin; Kernel.Float(i.custom_value_for(c.custom_field).to_s); rescue; nil; end}.compact
                 assert !values.empty?
                 assert_equal values.sort, values
               end
               def test_invalid_query_should_raise_query_statement_invalid_error
                 q = Query.new
                 assert_raise Query::StatementInvalid do
                   q.issues(:conditions => "foo = 1")
                 end
               end
               def test_issue_count_by_association_group
                 q = Query.new(:name => '_', :group_by => 'assigned_to')
                 count_by_group = q.issue_count_by_group
                 assert_kind_of Hash, count_by_group
                 assert_equal %w(NilClass User), count_by_group.keys.collect {|k| k.class.name}.uniq.sort
                 assert_equal %w(Fixnum), count_by_group.values.collect {|k| k.class.name}.uniq
                 assert count_by_group.has_key?(User.find(3))
               end
               def test_issue_count_by_list_custom_field_group
                 q = Query.new(:name => '_', :group_by => 'cf_1')
                 count_by_group = q.issue_count_by_group
                 assert_kind_of Hash, count_by_group
                 assert_equal %w(NilClass String), count_by_group.keys.collect {|k| k.class.name}.uniq.sort
                 assert_equal %w(Fixnum), count_by_group.values.collect {|k| k.class.name}.uniq
                 assert count_by_group.has_key?('MySQL')
               end
               def test_issue_count_by_date_custom_field_group
                 q = Query.new(:name => '_', :group_by => 'cf_8')
                 count_by_group = q.issue_count_by_group
                 assert_kind_of Hash, count_by_group
                 assert_equal %w(Date NilClass), count_by_group.keys.collect {|k| k.class.name}.uniq.sort
                 assert_equal %w(Fixnum), count_by_group.values.collect {|k| k.class.name}.uniq
               end
               def test_label_for
                 q = Query.new
                 assert_equal 'assigned_to', q.label_for('assigned_to_id')
               end
               def test_editable_by
                 admin = User.find(1)
                 manager = User.find(2)
                 developer = User.find(3)
                 # Public query on project 1
                 q = Query.find(1)
                 assert q.editable_by?(admin)
                 assert q.editable_by?(manager)
                 assert !q.editable_by?(developer)
                 # Private query on project 1
                 q = Query.find(2)
                 assert q.editable_by?(admin)
                 assert !q.editable_by?(manager)
                 assert q.editable_by?(developer)
                 # Private query for all projects
                 q = Query.find(3)
                 assert q.editable_by?(admin)
                 assert !q.editable_by?(manager)
                 assert q.editable_by?(developer)
                 # Public query for all projects
                 q = Query.find(4)
                 assert q.editable_by?(admin)
                 assert !q.editable_by?(manager)
                 assert !q.editable_by?(developer)
               end
               context "#available_filters" do
+                setup do
+                  @query = Query.new(:name => "_")
+                end
                 should "include users of visible projects in cross-project view" do
-                  query = Query.new(:name => "_")
+                  users = @query.available_filters["assigned_to_id"]
-                  users = query.available_filters["assigned_to_id"]
                   assert_not_nil users
                   assert users[:values].map{|u|u[1]}.include?("3")
                 end
+                context "'member_of_group' filter" do
+                  should "be present" do
+                    assert @query.available_filters.keys.include?("member_of_group")
+                  end
+                  should "be an optional list" do
+                    assert_equal :list_optional, @query.available_filters["member_of_group"][:type]
+                  end
+                  should "have a list of the groups as values" do
+                    Group.destroy_all # No fixtures
+                    group1 = Group.generate!.reload
+                    group2 = Group.generate!.reload
+                    expected_group_list = [
+                                           [group1.name, group1.id],
+                                           [group2.name, group2.id]
+                                          ]
+                    assert_equal expected_group_list, @query.available_filters["member_of_group"][:values]
+                  end
+                end
               end
+              context "#statement" do
+                context "with 'member_of_group' filter" do
+                  setup do
+                    Group.destroy_all # No fixtures
+                    @user_in_group = User.generate!
+                    @second_user_in_group = User.generate!
+                    @user_in_group2 = User.generate!
+                    @user_not_in_group = User.generate!
+                    @group = Group.generate!.reload
+                    @group.users << @user_in_group
+                    @group.users << @second_user_in_group
+                    @group2 = Group.generate!.reload
+                    @group2.users << @user_in_group2
+                  end
+                  should "search assigned to for users in the group" do
+                    @query = Query.new(:name => '_')
+                    @query.add_filter('member_of_group', '=', [@group.id.to_s])
+                    assert_query_statement_includes @query, "#{Issue.table_name}.assigned_to_id IN ('#{@user_in_group.id}','#{@second_user_in_group.id}')"
+                    assert_find_issues_with_query_is_successful @query
+                  end
+                  should "search not assigned to any group member (none)" do
+                    @query = Query.new(:name => '_')
+                    @query.add_filter('member_of_group', '!*', [''])
+                    # Users not in a group
+                    assert_query_statement_includes @query, "#{Issue.table_name}.assigned_to_id IS NULL OR #{Issue.table_name}.assigned_to_id NOT IN ('#{@user_in_group.id}','#{@second_user_in_group.id}','#{@user_in_group2.id}')"
+                    assert_find_issues_with_query_is_successful @query
+                  end
+                  should "search assigned to any group member (all)" do
+                    @query = Query.new(:name => '_')
+                    @query.add_filter('member_of_group', '*', [''])
+                    # Only users in a group
+                    assert_query_statement_includes @query, "#{Issue.table_name}.assigned_to_id IN ('#{@user_in_group.id}','#{@second_user_in_group.id}','#{@user_in_group2.id}')"
+                    assert_find_issues_with_query_is_successful @query
+                  end
+                end
+              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