Redmine

      end

      principals.uniq!

      principals.sort!

      principals.reject! {|p| p.is_a?(GroupBuiltin)}

      principals

    end

  end

  def users

    principals.select {|p| p.is_a?(User)}

  end

  def author_values

    author_values = []

    author_values << ["<< #{l(:label_me)} >>", "me"] if User.current.logged?

    author_values +=

      users.sort_by{|p| [p.status, p]}.

        collect{|s| [s.name, s.id.to_s, l("status_#{User::LABEL_BY_STATUS[s.status]}")]}

    author_values << [l(:label_user_anonymous), User.anonymous.id.to_s]

    author_values

  end

  def assigned_to_values

    assigned_to_values = []

    assigned_to_values << ["<< #{l(:label_me)} >>", "me"] if User.current.logged?

    assigned_to_values +=

      (Setting.issue_group_assignment? ? principals : users).sort_by{|p| [p.status, p]}.

        collect{|s| [s.name, s.id.to_s, l("status_#{User::LABEL_BY_STATUS[s.status]}")]}

    assigned_to_values

  end

  def fixed_version_values

    versions = []

    if project

      versions = project.shared_versions.to_a

    else

      versions = Version.visible.to_a

    end

    Version.sort_by_status(versions).

      collect{|s| ["#{s.project.name} - #{s.name}", s.id.to_s, l("version_status_#{s.status}")]}

  end

  # Returns a scope of issue statuses that are available as columns for filters

  def issue_statuses_values

    if project

      statuses = project.rolled_up_statuses

    else

      statuses = IssueStatus.all.sorted

    end

    statuses.collect{|s| [s.name, s.id.to_s]}

      next unless v and !v.empty?

      operator = operator_for(field)

      # "me" value substitution

      if %w(assigned_to_id author_id user_id watcher_id updated_by last_updated_by).include?(field)

        if v.delete("me")

          if User.current.logged?

            v.push(User.current.id.to_s)

            v += User.current.group_ids.map(&:to_s) if %w(assigned_to_id watcher_id).include?(field)

          else

            v.push("0")

          end

        end

      end

      if field == 'project_id' || (is_a?(ProjectQuery) && %w[id parent_id].include?(field))

        if v.delete('mine')

          v += User.current.memberships.map {|m| m.project_id.to_s}

        end

        if v.delete('bookmarks')

          v += User.current.bookmarked_project_ids

        end

      end

      if field =~ /^cf_(\d+)\.cf_(\d+)$/

        filters_clauses << sql_for_chained_custom_field(field, operator, v, $1, $2)

      elsif field =~ /cf_(\d+)$/

        # custom field

        filters_clauses << sql_for_custom_field(field, operator, v, $1)

      elsif field =~ /^cf_(\d+)\.(.+)$/

        filters_clauses << sql_for_custom_field_attribute(field, operator, v, $1, $2)

      elsif respond_to?(method = "sql_for_#{field.tr('.', '_')}_field")

        # specific statement

        filters_clauses << send(method, field, operator, v)

      else

        # regular field

        filters_clauses << '(' + sql_for_field(field, operator, v, queried_table_name, field) + ')'

      end

    end if filters and valid?

    if (c = group_by_column) && c.is_a?(QueryCustomFieldColumn)

      # Excludes results for which the grouped custom field is not visible

      filters_clauses << c.custom_field.visibility_by_project_condition

    end

    filters_clauses << project_statement

    filters_clauses.reject!(&:blank?)

    filters_clauses.any? ? filters_clauses.join(' AND ') : nil

  end

  # Returns the result count by group or nil if query is not grouped

  def result_count_by_group

    grouped_query do |scope|

      scope.count

    end

  end

  # Returns the sum of values for the given column

    with_settings :issue_group_assignment => '1' do

      i1 = Issue.generate!(:project_id => 1, :tracker_id => 1, :assigned_to => user)

      i2 = Issue.generate!(:project_id => 1, :tracker_id => 1, :assigned_to => group)

      i3 = Issue.generate!(:project_id => 1, :tracker_id => 1, :assigned_to => other_group)

      query =

        IssueQuery.new(

          :name => '_',

          :filters => {

            'assigned_to_id' => {

              :operator => '=',

              :values => ['me']

            }

          }

        )

      result = query.issues

      assert_equal(

        Issue.visible.where(:assigned_to_id => ([2] + user.reload.group_ids)).sort_by(&:id),

        result.sort_by(&:id)

      )

      assert result.include?(i1)

      assert result.include?(i2)

      assert !result.include?(i3)

    end

  end

  def test_filter_notes

    user = User.generate!

    Journal.create!(:user_id => user.id, :journalized => Issue.find(2), :notes => 'Notes.')

    Journal.create!(:user_id => user.id, :journalized => Issue.find(3), :notes => 'Notes.')

    issue_journals = Issue.find(1).journals.sort

    assert_equal ['Journal notes', 'Some notes with Redmine links: #2, r2.'], issue_journals.map(&:notes)

    assert_equal [false, false], issue_journals.map(&:private_notes)

    query = IssueQuery.new(:name => '_')

    filter_name = 'notes'

    assert_include filter_name, query.available_filters.keys

    {

      '~' => [1, 2, 3],

      '!~' => Issue.ids.sort - [1, 2, 3],

      '^' => [2, 3],

      '$' => [1],

    }.each do |operator, expected|

      query.filters = {filter_name => {:operator => operator, :values => ['Notes']}}

      assert_equal expected, find_issues_with_query(query).map(&:id).sort

    end

  end

  def test_filter_notes_should_ignore_private_notes_that_are_not_visible

      IssueQuery.create!(

        :name => 'Query',

        :type => "IssueQuery",

        :user => User.find(7),

        :filters => {"status_id" => {:values => ["1"], :operator => "o"}},

        :column_names => [:tracker, :status],

        :sort_criteria => ['id', 'asc'],

        :group_by => "project",

        :options => {

          :totalable_names=>[:estimated_hours],

          :draw_relations => '1',

          :draw_progress_line => '1'

        }

      )

    old_attributes = q.attributes

    q.build_from_params({})

    assert_equal old_attributes, q.attributes

  end

  test "#available_filters should include users of visible projects in cross-project view" do

    users = IssueQuery.new.available_filters["assigned_to_id"]

    assert_not_nil users

    assert users[:values].pluck(1).include?("3")

  end

  test "#available_filters should include users of subprojects" do

    user1 = User.generate!

    user2 = User.generate!

    project = Project.find(1)

    Member.create!(:principal => user1, :project => project.children.visible.first, :role_ids => [1])

    users = IssueQuery.new(:project => project).available_filters["assigned_to_id"]

    assert_not_nil users

    assert users[:values].pluck(1).include?(user1.id.to_s)

    assert !users[:values].pluck(1).include?(user2.id.to_s)

  end

  test "#available_filters should include visible projects in cross-project view" do

    projects = IssueQuery.new.available_filters["project_id"]

    assert_not_nil projects

    assert projects[:values].pluck(1).include?("1")

  end

  test "#available_filters should include 'member_of_group' filter" do

    query = IssueQuery.new

    assert query.available_filters.key?("member_of_group")

    assert_equal :list_optional, query.available_filters["member_of_group"][:type]

    assert query.available_filters["member_of_group"][:values].present?

    assert_equal Group.givable.sort.map {|g| [g.name, g.id.to_s]},

                 query.available_filters["member_of_group"][:values].sort

  end