Redmine

        @roles_with_active_members = @project.roles_with_active_members.load

  def show_all_members

    @role = @project.roles_with_active_members.detect {|role| role.id == params[:role_id].to_i}

    unless @role

      render_404

      return

    end

    @principals, _more = @project.principals_for_role(@role, :offset => params[:offset].to_i, :limit => nil)

    render :layout => false

  end

import { Controller } from '@hotwired/stimulus'

import { get } from '@rails/request.js'

// Connects to data-controller="project-members-box-expand"

export default class extends Controller {

  static targets = ['trigger']

  async showAll(event) {

    event.preventDefault()

    // Ignore clicks while a request is in flight, so the members can't be inserted twice.

    const trigger = this.triggerTarget

    if (trigger.dataset.loading) {

      return

    }

    trigger.dataset.loading = 'true'

    try {

      const response = await get(event.currentTarget.href, { responseKind: 'html' })

      if (!response.ok) {

        return

      }

      trigger.insertAdjacentHTML('beforebegin', await response.html)

      trigger.remove()

    } finally {

      delete trigger.dataset.loading

    }

  }

}

  # Number of principals initially listed per role in the overview page's members box

  MEMBERS_BOX_PRINCIPALS_PER_ROLE = 50 unless const_defined?(:MEMBERS_BOX_PRINCIPALS_PER_ROLE)

  # Kept for backward compatibility; no longer used by Redmine core.

  # Returns the roles that have at least one active member, without loading any principal.

  def roles_with_active_members

    Role.where(:id => memberships.active.joins(:roles).select("#{Role.table_name}.id")).sorted

  end

  # Returns [principals, more]: a page of the project's active members having the

  # given role. A nil limit returns everything from the offset on, and more is false.

  def principals_for_role(role, offset: 0, limit: MEMBERS_BOX_PRINCIPALS_PER_ROLE)

    offset = 0 if offset < 0

    # A subquery avoids DISTINCT + ORDER BY on non-selected columns, which PostgreSQL rejects.

    scope = Principal.where(

      :id => memberships.active.joins(:roles).where(:roles => {:id => role.id}).select(:user_id)

    ).sorted.offset(offset)

    if limit

      principals = scope.limit(limit + 1).to_a

      more = principals.size > limit

      principals.pop if more

    else

      principals = scope.to_a

      more = false

    end

    [principals, more]

  end

  <% if @roles_with_active_members.any? %>

    <% @roles_with_active_members.each do |role| %>

      <%= render :partial => 'members_box_role', :locals => {:role => role} %>

<%= principals.collect {|p| link_to_principal(p, :class => p.is_a?(Group) ? 'icon icon-group' : nil)}.join(", ").html_safe %>

<%

  principals, more = @project.principals_for_role(role)

%>

<p class="member-role" data-controller="project-members-box-expand">

  <span class="label"><%= role %>:</span>

  <%= render :partial => 'members_box_principals', :locals => {:principals => principals} %><% if more %><span class="show-all-members-trigger" data-project-members-box-expand-target="trigger"> <%= link_to(sprite_icon('angle-right', l(:label_show_all), rtl: true), show_all_members_project_path(@project, :role_id => role.id, :offset => principals.size), :class => 'icon icon-angle-right', :data => {:action => 'click->project-members-box-expand#showAll'}) %></span><% end %>

</p>

<% if @principals.any? %>, <%= render :partial => 'members_box_principals', :locals => {:principals => @principals} %><% end %>

  label_show_all: Show all

  label_show_all: すべて表示

      get 'show_all_members'

        map.permission :view_project, {:projects => [:show, :bookmark, :show_all_members], :activities => [:index]}, :public => true, :read => true

  def test_show_should_display_members_box_grouped_by_role

    get(:show, :params => {:id => 'ecookbook'})

    assert_response :success

    assert_select 'div.members.box' do

      assert_select 'p.member-role', :count => 2

      assert_select 'p.member-role:nth-of-type(1) span.label', :text => 'Manager:'

      assert_select 'p.member-role:nth-of-type(1) a', :text => 'John Smith'

      assert_select 'p.member-role:nth-of-type(2) span.label', :text => 'Developer:'

    end

  end

  def test_show_should_load_roles_with_active_members_to_avoid_a_duplicate_query

    role_queries = []

    subscriber = lambda do |*, payload|

      # Matches only #roles_with_active_members's self-referential subquery,

      # not other queries in the request that also touch the roles table.

      role_queries << payload[:sql] if payload[:sql].match?(/"roles"\."id"\s+IN\s+\(SELECT\s+"roles"\."id"/i)

    end

    ActiveSupport::Notifications.subscribed(subscriber, 'sql.active_record') do

      get(:show, :params => {:id => 'ecookbook'})

    end

    assert_response :success

    # An unloaded relation would run this query twice: once for #any?, once for #each.

    assert_equal 1, role_queries.size, role_queries.join("\n")

  end

  def test_show_should_not_display_locked_users_in_members_box

    get(:show, :params => {:id => 'ecookbook'})

    assert_response :success

    # User 5 is a locked member with the Developer role (see test/fixtures/members.yml)

    assert_select 'div.members.box a', :text => User.find(5).name, :count => 0

  end

  def test_show_should_not_display_more_link_when_role_has_few_members

    project = Project.find(1)

    role = Role.find(1) # Manager, already has 1 active member (John Smith)

    5.times {Member.create!(:principal => User.generate!, :project => project, :role_ids => [role.id])}

    get(:show, :params => {:id => 'ecookbook'})

    assert_response :success

    assert_select 'div.members.box p.member-role:nth-of-type(1)' do

      assert_select 'a[href^=?]', '/users/', :count => 6

      assert_select 'span.show-all-members-trigger', :count => 0

    end

  end

  def test_show_should_limit_members_box_principals_per_role_and_display_more_link

    project = Project.find(1)

    role = Role.find(1)

    (Project::MEMBERS_BOX_PRINCIPALS_PER_ROLE + 5).times {Member.create!(:principal => User.generate!, :project => project, :role_ids => [role.id])}

    get(:show, :params => {:id => 'ecookbook'})

    assert_response :success

    assert_select 'div.members.box p.member-role:nth-of-type(1)' do

      assert_select 'a[href^=?]', '/users/', :count => Project::MEMBERS_BOX_PRINCIPALS_PER_ROLE

      assert_select 'span.show-all-members-trigger a[data-action=?][href*=?]',

                    'click->project-members-box-expand#showAll', "offset=#{Project::MEMBERS_BOX_PRINCIPALS_PER_ROLE}",

                    :text => 'Show all'

    end

  end

  def test_show_should_keep_the_separating_space_inside_the_show_all_trigger

    project = Project.find(1)

    role = Role.find(1)

    (Project::MEMBERS_BOX_PRINCIPALS_PER_ROLE + 5).times {Member.create!(:principal => User.generate!, :project => project, :role_ids => [role.id])}

    get(:show, :params => {:id => 'ecookbook'})

    assert_response :success

    # The separator space must be inside the trigger, not a sibling text node,

    # or clicking "Show all" leaves it stranded before the comma.

    assert_no_match(/<\/a> <span class="show-all-members-trigger"/, response.body)

    assert_match(/<span class="show-all-members-trigger"[^>]*> <a /, response.body)

  end

  def test_show_all_members_should_return_every_member_from_the_given_offset

    project = Project.find(1)

    role = Role.find(1)

    5.times {Member.create!(:principal => User.generate!, :project => project, :role_ids => [role.id])}

    get(:show_all_members, :params => {:id => 'ecookbook', :role_id => role.id, :offset => 1}, :xhr => true)

    assert_response :success

    assert_select 'a[href^=?]', '/users/', :count => 5

    assert_select 'span.show-all-members-trigger', :count => 0

  end

  def test_show_all_members_should_return_every_remaining_member_without_a_further_trigger

    project = Project.find(1)

    role = Role.find(1)

    (Project::MEMBERS_BOX_PRINCIPALS_PER_ROLE + 5).times {Member.create!(:principal => User.generate!, :project => project, :role_ids => [role.id])}

    get(

      :show_all_members,

      :params => {:id => 'ecookbook', :role_id => role.id, :offset => Project::MEMBERS_BOX_PRINCIPALS_PER_ROLE},

      :xhr => true

    )

    assert_response :success

    assert_select 'a[href^=?]', '/users/', :count => 6

    assert_select 'span.show-all-members-trigger', :count => 0

  end

  def test_show_all_members_should_not_include_locked_users

    get(:show_all_members, :params => {:id => 'ecookbook', :role_id => 2, :offset => 0}, :xhr => true)

    assert_response :success

    assert_select 'a', :text => User.find(5).name, :count => 0

  end

  def test_show_all_members_should_not_render_a_stray_comma_when_nothing_remains

    # Role 1 (Manager) on project 1 has only 1 active member, so offset 999 lands past the end.

    get(:show_all_members, :params => {:id => 'ecookbook', :role_id => 1, :offset => 999}, :xhr => true)

    assert_response :success

    assert_equal '', response.body.strip

  end

  def test_show_all_members_should_respond_with_not_found_for_a_role_without_active_members

    get(:show_all_members, :params => {:id => 'ecookbook', :role_id => 999}, :xhr => true)

    assert_response :not_found

  end

  def test_show_all_members_should_not_require_login_for_a_public_project

    get(:show_all_members, :params => {:id => 'ecookbook', :role_id => 1}, :xhr => true)

    assert_response :success

  end

  def test_roles_with_active_members

    # Project 1 has active members with role 1 (Manager) and role 2 (Developer)

    assert_equal [Role.find(1), Role.find(2)], Project.find(1).roles_with_active_members.to_a

  end

  def test_roles_with_active_members_should_not_include_roles_without_members

    project = Project.generate!

    assert_equal [], project.roles_with_active_members.to_a

  end

  def test_roles_with_active_members_should_not_include_roles_with_only_locked_members

    project = Project.find(1)

    role = Role.find(2)

    # Role 2 (Developer) only has active member 3 besides the locked member 5

    Member.find_by(:project_id => 1, :user_id => 3).destroy

    assert_not project.reload.roles_with_active_members.to_a.include?(role)

  end

  def test_principals_for_role

    principals, more = Project.find(1).principals_for_role(Role.find(1))

    assert_kind_of Array, principals

    assert principals.include?(User.find(2))

    assert_not more

  end

  def test_principals_for_role_should_only_return_active_users

    # Role 2 (Developer) on project 1 has active member 3 and locked member 5

    principals, _more = Project.find(1).principals_for_role(Role.find(2))

    assert_equal [User.find(3)], principals

  end

  def test_principals_for_role_should_include_groups

    group = Group.find(10)

    Member.create!(:principal => group, :project_id => 1, :role_ids => [1])

    principals, _more = Project.find(1).principals_for_role(Role.find(1))

    assert principals.include?(group)

  end

  def test_principals_for_role_should_not_duplicate_a_user_with_an_inherited_role_matching_a_direct_role

    project = Project.find(1)

    role = Role.find(1)

    user = User.generate!

    User.add_to_project(user, project, role)

    group = Group.generate!

    group.users << user

    # Also grants role via the group: the user now has 2 member_roles for the

    # same role (one direct, one inherited, see MemberRole#add_role_to_group_users)

    User.add_to_project(group, project, role)

    principals, _more = project.principals_for_role(role, :limit => 100)

    assert_equal 1, principals.count {|p| p == user}

  end

  def test_principals_for_role_should_paginate

    project = Project.find(1)

    role = Role.find(1)

    5.times {|i| Member.create!(:principal => User.generate!, :project => project, :role_ids => [role.id])}

    principals, more = project.principals_for_role(role, :limit => 2)

    assert_equal 2, principals.size

    assert more

    more_principals, more = project.principals_for_role(role, :offset => 2, :limit => 2)

    assert_equal 2, more_principals.size

    assert more

    assert_empty principals & more_principals

    rest, more = project.principals_for_role(role, :offset => 4, :limit => 2)

    assert_equal 2, rest.size

    assert_not more

  end

  def test_principals_for_role_should_treat_a_negative_offset_as_zero

    project = Project.find(1)

    role = Role.find(1)

    assert_equal project.principals_for_role(role), project.principals_for_role(role, :offset => -5)

  end

  def test_principals_for_role_with_a_nil_limit_should_return_every_remaining_member

    project = Project.find(1)

    role = Role.find(1)

    5.times {Member.create!(:principal => User.generate!, :project => project, :role_ids => [role.id])}

    first_page, more = project.principals_for_role(role, :limit => 2)

    assert_equal 2, first_page.size

    assert more

    rest, more = project.principals_for_role(role, :offset => first_page.size, :limit => nil)

    assert_equal 4, rest.size

    assert_not more

    assert_empty first_page & rest

  end