Redmine

      elsif %w(author_group author_role).include?(field)

        group = :field_author

    add_available_filter(

      "author_group",

      :type => :list,

      :values => lambda {Group.givable.visible.pluck(:name, :id).map {|name, id| [name, id.to_s]}}

    )

    add_available_filter(

      "author_role",

      :type => :list,

      :values => lambda {Role.givable.pluck(:name, :id).map {|name, id| [name, id.to_s]}}

    )

  def sql_for_author_group_field(field, operator, value)

    groups = if value.empty?

      Group.givable

    else

      Group.where(:id => value).to_a

    end

    author_groups = groups.inject([]) do |user_ids, group|

      user_ids + group.user_ids + [group.id]

    end.uniq.compact.sort.collect(&:to_s)

    '(' + sql_for_field("author_id", operator, author_groups, Issue.table_name, "author_id", false) + ')'

  end

  def sql_for_author_role_field(field, operator, value)

    role_cond =

      if value.any?

        "#{MemberRole.table_name}.role_id IN (" + value.collect{|val| "'#{self.class.connection.quote_string(val)}'"}.join(",") + ")"

      else

        "1=0"

      end

    sw = operator == "!" ? 'NOT' : ''

    nl = operator == "!" ? "#{Issue.table_name}.author_id IS NULL OR" : ''

    subquery =

      "SELECT 1" +

      " FROM #{Member.table_name} inner join #{MemberRole.table_name} on members.id = member_roles.member_id" +

      " WHERE #{Issue.table_name}.project_id = #{Member.table_name}.project_id AND #{Member.table_name}.user_id = #{Issue.table_name}.author_id AND #{role_cond}"

    "(#{nl} #{sw} EXISTS (#{subquery}))"

  end

  field_author_group: "Author's group"

  field_author_role: "Author's role"

  field_author_group: 作成者のグループ

  field_author_role: 作成者のロール

  def test_filters_options_for_select_should_group_author_filters

    with_locale 'en' do

      options = filters_options_for_select(IssueQuery.new)

      assert_select_in options, 'optgroup[label=?]', "Author", 1

      assert_select_in options, 'optgroup > option[value=author_group]', :text => "Author's group"

      assert_select_in options, 'optgroup > option[value=author_role]', :text => "Author's role"

    end

  end

  def test_available_filters_should_include_author_group_filter

    query = IssueQuery.new

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

    assert_equal :list, query.available_filters["author_group"][:type]

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

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

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

  end

  def test_available_filters_should_include_author_role_filter

    query = IssueQuery.new

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

    assert_equal :list, query.available_filters["author_role"][:type]

    assert query.available_filters["author_role"][:values].include?(['Manager', '1'])

    assert query.available_filters["author_role"][:values].include?(['Developer', '2'])

    assert query.available_filters["author_role"][:values].include?(['Reporter', '3'])

    assert ! query.available_filters["author_role"][:values].include?(['Non member', '4'])

    assert ! query.available_filters["author_role"][:values].include?(['Anonymous', '5'])

  end

  def test_author_group_filter_should_return_issues_with_or_without_author_in_group

    project = Project.generate!

    author = User.generate!

    author_group = Group.generate!

    not_author_group = Group.generate!

    author.groups << author_group

    issues = 3.times.collect { Issue.generate!(:project => project, :author => author) }

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

    query.add_filter('author_group', '=', [author_group.id.to_s])

    assert_equal 3, query.issues.count

    assert_query_result issues, query

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

    query.add_filter('author_group', '!', [not_author_group.id.to_s])

    assert_equal 3, query.issues.count

    assert_query_result issues, query

  end

  def test_author_role_filter_should_return_issues_with_or_without_author_in_role

    project = Project.generate!

    author = User.generate!

    manager_role = Role.find_by_name('Manager')

    developer_role = Role.find_by_name('Developer')

    User.add_to_project(author, project, manager_role)

    issues = 3.times.collect { Issue.generate!(:project => project, :author => author) }

    query = IssueQuery.new(:name => 'issues generated by manager', :project => project)

    query.add_filter('author_role', '=', [manager_role.id.to_s])

    assert_equal 3, query.issues.count

    assert_query_result issues, query

    query = IssueQuery.new(:name => 'issues does not generated by developer', :project => project)

    query.add_filter('author_role', '!', [developer_role.id.to_s])

    assert_equal 3, query.issues.count

    assert_query_result issues, query

  end