jro_apps/redmine Commit - r3964:41f8d043eb29

Added a "Member of Role" to the issues filters. #5869...

Eric Davis -

r3964:41f8d043eb29

parent child

Context file:

r3964:41f8d043eb29

Collapse all files

app/models/query.rb +23 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?
+                 role_values = Role.givable.collect {|r| [r.name, r.id] }
+                 @available_filters["assigned_to_role"] = { :type => :list_optional, :order => 7, :values => role_values } unless role_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) + ')'
+                   elsif field == "assigned_to_role" # named field
+                     if operator == "*" # Any Role
+                       roles = Role.givable
+                       operator = '=' # Override the operator since we want to find by assigned_to
+                     elsif operator == "!*" # No role
+                       roles = Role.givable
+                       operator = '!' # Override the operator since we want to find by assigned_to
+                     else
+                       roles = Role.givable.find_all_by_id(v)
+                     end
+                     roles ||= []
+                     members_of_roles = roles.inject([]) {|user_ids, role|
+                       if role && role.members
+                         user_ids << role.members.collect(&:user_id)
+                       end
+                       user_ids.flatten.uniq.compact
+                     }.sort.collect(&:to_s)
+                     sql << '(' + sql_for_field("assigned_to_id", operator, members_of_roles, 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
+               field_assigned_to_role: Member of Role
                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/object_daddy_helpers.rb +5 0

              module ObjectDaddyHelpers
                # TODO: Remove these three once everyone has ported their code to use the
                # new object_daddy version with protected attribute support
                def User.generate_with_protected(attributes={})
                  User.generate(attributes)
                end
                def User.generate_with_protected!(attributes={})
                  User.generate!(attributes)
                end
                def User.spawn_with_protected(attributes={})
                  User.spawn(attributes)
                end
+               def User.add_to_project(user, project, roles)
+                 roles = [roles] unless roles.is_a?(Array)
+                 Member.generate!(:principal => user, :project => project, :roles => roles)
+               end
                # Generate the default Query
                def Query.generate_default!(attributes={})
                  query = Query.spawn(attributes)
                  query.name ||= '_'
                  query.save!
                  query
                end
                # Generate an issue for a project, using it's trackers
                def Issue.generate_for_project!(project, attributes={})
                  issue = Issue.spawn(attributes) do |issue|
                    issue.project = project
                    issue.tracker = project.trackers.first unless project.trackers.empty?
                    yield issue if block_given?
                  end
                  issue.save!
                  issue
                end
              end

test/unit/query_test.rb +67 -1

              # 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
                    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
+                 context "'assigned_to_role' filter" do
+                   should "be present" do
+                     assert @query.available_filters.keys.include?("assigned_to_role")
+                   end
+                   should "be an optional list" do
+                     assert_equal :list_optional, @query.available_filters["assigned_to_role"][:type]
+                   end
+                   should "have a list of the Roles as values" do
+                     assert @query.available_filters["assigned_to_role"][:values].include?(['Manager',1])
+                     assert @query.available_filters["assigned_to_role"][:values].include?(['Developer',2])
+                     assert @query.available_filters["assigned_to_role"][:values].include?(['Reporter',3])
+                   end
+                   should "not include the built in Roles as values" do
+                     assert ! @query.available_filters["assigned_to_role"][:values].include?(['Non member',4])
+                     assert ! @query.available_filters["assigned_to_role"][:values].include?(['Anonymous',5])
+                   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
+                 context "with 'assigned_to_role' filter" do
+                   setup do
+                     # No fixtures
+                     MemberRole.delete_all
+                     Member.delete_all
+                     Role.delete_all
+                     @manager_role = Role.generate!(:name => 'Manager')
+                     @developer_role = Role.generate!(:name => 'Developer')
+                     @project = Project.generate!
+                     @manager = User.generate!
+                     @developer = User.generate!
+                     @boss = User.generate!
+                     User.add_to_project(@manager, @project, @manager_role)
+                     User.add_to_project(@developer, @project, @developer_role)
+                     User.add_to_project(@boss, @project, [@manager_role, @developer_role])
+                   end
+                   should "search assigned to for users with the Role" do
+                     @query = Query.new(:name => '_')
+                     @query.add_filter('assigned_to_role', '=', [@manager_role.id.to_s])
+                     assert_query_statement_includes @query, "#{Issue.table_name}.assigned_to_id IN ('#{@manager.id}','#{@boss.id}')"
+                     assert_find_issues_with_query_is_successful @query
+                   end
+                   should "search assigned to for users not assigned to any Role (none)" do
+                     @query = Query.new(:name => '_')
+                     @query.add_filter('assigned_to_role', '!*', [''])
+                     assert_query_statement_includes @query, "#{Issue.table_name}.assigned_to_id IS NULL OR #{Issue.table_name}.assigned_to_id NOT IN ('#{@manager.id}','#{@developer.id}','#{@boss.id}')"
+                     assert_find_issues_with_query_is_successful @query
+                   end
+                   should "search assigned to for users assigned to any Role (all)" do
+                     @query = Query.new(:name => '_')
+                     @query.add_filter('assigned_to_role', '*', [''])
+                     assert_query_statement_includes @query, "#{Issue.table_name}.assigned_to_id IN ('#{@manager.id}','#{@developer.id}','#{@boss.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