Redmine

    'possible_principals',

    remove_user_custom_field_references

  # Removes the values of user custom fields that reference the principal

  def remove_user_custom_field_references

    user_custom_field_ids = CustomField.where(field_format: 'user').ids

    if user_custom_field_ids.any?

      CustomValue.where(custom_field_id: user_custom_field_ids, value: id.to_s).delete_all

    end

  end

        if filter[:field].format.try(:selectable_principal_types, filter[:field])&.include?('Group')

          value += User.current.group_ids.map(&:to_s)

        end

    remove_user_custom_field_references

<p><%= f.select :possible_principals,

      [

        [l(:label_user_plural), 'user'],

        [l(:label_users_and_groups), 'user_group'],

        [l(:label_group_plural), 'group']

      ],

      :label => :field_possible_values %></p>

  label_users_and_groups: Users and groups

  label_users_and_groups: ユーザーとグループ

          view.options_for_select(opts, value) + bulk_edit_tag_options(view, custom_field, objects, value),

        options_tags = blank_option + select_edit_tag_options(view, custom_value)

      # Returns the option tags of the select edit tag

      def select_edit_tag_options(view, custom_value)

        view.options_for_select(possible_custom_value_options(custom_value), custom_value.value)

      end

      # Returns the option tags of the bulk edit tag

      def bulk_edit_tag_options(view, custom_field, objects, value)

        view.options_for_select(possible_values_options(custom_field, objects), value)

      end

      field_attributes :user_role, :possible_principals

      # Maps the possible_principals option to the principal types that can be selected

      PRINCIPAL_TYPES = {

        'user' => ['User'],

        'user_group' => ['User', 'Group'],

        'group' => ['Group']

      }.freeze

        principals_options(custom_field, possible_values_records(custom_field, object))

          scope = object.project.principals.where(:type => selectable_principal_types(custom_field))

      # Returns the principal types (User and/or Group) that can be

      # selected for the given custom field

      def selectable_principal_types(custom_field)

        PRINCIPAL_TYPES[custom_field.possible_principals.to_s] || PRINCIPAL_TYPES['user']

      end

      def cast_single_value(custom_field, value, customized=nil)

        Principal.find_by_id(value.to_i) if value.present?

      end

      def possible_custom_value_options(custom_value)

        principals_options(custom_value.custom_field, possible_custom_value_records(custom_value))

      end

      # Returns the principals that can be selected for the given custom value,

      # including the principals that are currently set but no longer selectable

      def possible_custom_value_records(custom_value)

        principals = possible_values_records(custom_value.custom_field, custom_value.customized).to_a

        missing = [custom_value.value_was].flatten.reject(&:blank?).map(&:to_i) - principals.map(&:id)

        if missing.any?

          principals += Principal.where(:id => missing).to_a

        end

        principals

      end

        principals = possible_values_records(custom_field, object).to_a

          Principal.detect_by_keyword(principals, k).try(:id)

      protected

      def select_edit_tag_options(view, custom_value)

        principals_option_tags(view, custom_value.custom_field,

                               possible_custom_value_records(custom_value), custom_value.value)

      end

      def bulk_edit_tag_options(view, custom_field, objects, value)

        principals_option_tags(view, custom_field, possible_values_records(custom_field, objects), value)

      end

      # Returns the [name, id] options for the given principals,

      # with the "me" option first when the current user is selectable

      def principals_options(custom_field, principals)

        me_options(custom_field, principals) + principals_to_options(principals)

      end

      # Renders the option tags for the given principals. When both users

      # and groups are present, they are listed in separate optgroups

      def principals_option_tags(view, custom_field, principals, selected)

        users, groups = principals.partition {|principal| principal.is_a?(User)}

        options = view.options_for_select(me_options(custom_field, principals), selected)

        if users.any? && groups.any?

          optgroups = [

            [l(:label_user_plural), principals_to_options(users)],

            [l(:label_group_plural), principals_to_options(groups)]

          ]

          options + view.grouped_options_for_select(optgroups, selected)

        else

          options + view.options_for_select(principals_to_options(principals), selected)

        end

      end

      def me_options(custom_field, principals)

        if !custom_field.multiple? && principals.include?(User.current)

          [["<< #{l(:label_me)} >>", User.current.id.to_s]]

        else

          []

        end

      end

      def principals_to_options(principals)

        principals.map {|principal| [principal.name, principal.id.to_s]}

      end

        types = selectable_principal_types(custom_field)

        values =

          query.principals.select {|p| types.include?(p.type)}.

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

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

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

        values

  def test_create_user_custom_field

    assert_difference 'CustomField.count' do

      post(

        :create,

        :params => {

          :type => "IssueCustomField",

          :custom_field => {

            :name => "foo",

            :field_format => "user",

            :possible_principals => "user_group"

          }

        }

      )

      assert_response :found

    end

    field = IssueCustomField.order(id: :desc).first

    assert_equal 'user_group', field.possible_principals

  end

  def test_destroy_should_remove_references_from_issues

    cf = IssueCustomField.create!(:field_format => 'user', :possible_principals => 'user_group', :is_for_all => true, :name => 'User custom field', :tracker_ids => [1])

    issue_with_cf = Issue.generate!(:project_id => 5, :tracker_id => 1, :custom_field_values => {cf.id.to_s => group.id.to_s})

    assert_equal group.id.to_s, issue_with_cf.reload.custom_field_value(cf)

    assert_equal '', issue_with_cf.reload.custom_field_value(cf).to_s

    assert_nil field.possible_principals

    field = IssueCustomField.new(:field_format => 'user', :possible_principals => 'user_group', :user_role => ["2"])

    project = Project.find(5)

    assert_equal ['User Misc', 'A Team'], field.possible_values_options(project).map(&:first)

  def test_possible_values_options_with_groups_only_should_include_groups_only

    # The current user is a member of the project but should not be included

    User.current = User.find(2)

    field = IssueCustomField.new(:field_format => 'user', :possible_principals => 'group')

    project = Project.find(5)

    assert_equal [['A Team', '10']], field.possible_values_options(project)

  end

  def test_group_value_should_be_invalid_when_groups_are_not_allowed

    field = IssueCustomField.create!(:name => 'Foo', :field_format => 'user', :is_for_all => true, :trackers => Tracker.all)

    issue = Issue.new(:project_id => 5, :tracker_id => 1, :author_id => 2, :subject => 'Test',

                      :custom_field_values => {field.id => '10'})

    assert_equal false, issue.valid?

    assert_include "Foo #{::I18n.t('activerecord.errors.messages.inclusion')}", issue.errors.full_messages.first

  end

  def test_existing_group_value_should_remain_valid_after_disallowing_groups

    field = IssueCustomField.create!(:name => 'Foo', :field_format => 'user', :possible_principals => 'user_group',

                                     :is_for_all => true, :trackers => Tracker.all)

    issue = Issue.generate!(:project_id => 5, :tracker_id => 1, :custom_field_values => {field.id => '10'})

    field.update!(:possible_principals => 'user')

    issue.reload

    assert_equal '10', issue.custom_field_value(field)

    assert issue.valid?

    assert_equal 'A Team', field.format.formatted_value(self, field, '10', issue).to_s

    # Group can still be selected for the issue, but not for other issues

    assert_include '10', issue.custom_field_values.detect {|v| v.custom_field == field}.then {|v| field.format.possible_custom_value_options(v)}.map(&:last)

    assert_not_include '10', field.possible_values_options(Issue.new(:project_id => 5)).map(&:last)

  end

  def test_edit_tag_should_not_use_optgroups_with_users_only_or_groups_only

    field = IssueCustomField.new(:field_format => 'user', :is_required => false)

    value = CustomFieldValue.new(:custom_field => field, :customized => Issue.new(:project_id => 5))

    tag = field.format.edit_tag(self, 'abc', 'xyz', value)

    assert_select_in tag, 'select[id=abc][name=xyz]' do

      assert_select 'optgroup', 0

      assert_select 'select > option[value="2"]', :text => 'John Smith'

      assert_select 'option[value="10"]', 0

    end

    field = IssueCustomField.new(:field_format => 'user', :possible_principals => 'group', :is_required => false)

    value = CustomFieldValue.new(:custom_field => field, :customized => Issue.new(:project_id => 5))

    tag = field.format.edit_tag(self, 'abc', 'xyz', value)

    assert_select_in tag, 'select[id=abc][name=xyz]' do

      assert_select 'optgroup', 0

      assert_select 'select > option[value="10"]', :text => 'A Team'

      assert_select 'option[value="2"]', 0

    end

  end

  def test_edit_tag_with_groups_should_group_users_and_groups_in_optgroups

    set_language_if_valid 'en'

    User.current = User.find(2)

    field = IssueCustomField.new(:field_format => 'user', :possible_principals => 'user_group', :is_required => false)

    value = CustomFieldValue.new(:custom_field => field, :customized => Issue.new(:project_id => 5))

    tag = field.format.edit_tag(self, 'abc', 'xyz', value)

    assert_select_in tag, 'select[id=abc][name=xyz]' do

      assert_select 'option', :text => '<< me >>', :count => 1

      assert_select 'optgroup', 2

      assert_select 'optgroup:nth-of-type(1)[label="Users"]' do

        assert_select 'option[value="2"]', :text => 'John Smith'

        assert_select 'option[value="10"]', 0

      end

      assert_select 'optgroup:nth-of-type(2)[label="Groups"]' do

        assert_select 'option', 1

        assert_select 'option[value="10"]', :text => 'A Team'

      end

    end

  end

  def test_bulk_edit_tag_with_groups_should_group_users_and_groups_in_optgroups

    set_language_if_valid 'en'

    field = IssueCustomField.new(:field_format => 'user', :possible_principals => 'user_group', :is_required => false)

    issues = [Issue.new(:project_id => 5), Issue.new(:project_id => 5)]

    tag = field.format.bulk_edit_tag(self, 'abc', 'xyz', field, issues, '')

    assert_select_in tag, 'select[name=xyz]' do

      assert_select 'select > option[value=""]'

      assert_select 'select > option[value="__none__"]'

      assert_select 'optgroup[label="Users"] option[value="2"]', :text => 'John Smith'

      assert_select 'optgroup[label="Groups"] option[value="10"]', :text => 'A Team'

    end

  end

  def test_value_from_keyword_should_return_group_id_when_groups_are_allowed

    project = Project.find(5)

    field = IssueCustomField.new(:field_format => 'user', :possible_principals => 'user_group')

    assert_equal 10, field.value_from_keyword('A Team', project)

    field = IssueCustomField.new(:field_format => 'user')

    assert_nil field.value_from_keyword('A Team', project)

  end

  def test_user_custom_field_with_groups_should_be_filterable_on_users_and_groups

    User.current = User.find(8)

    cf = IssueCustomField.create!(:field_format => 'user', :possible_principals => 'user_group', :is_for_all => true, :is_filter => true, :name => 'User custom field', :tracker_ids => [1])

    issue1 = Issue.generate!(:project_id => 5, :tracker_id => 1, :custom_field_values => {cf.id.to_s => '10'})

    issue2 = Issue.generate!(:project_id => 5, :tracker_id => 1, :custom_field_values => {cf.id.to_s => '8'})

    issue3 = Issue.generate!(:project_id => 5, :tracker_id => 1, :custom_field_values => {cf.id.to_s => '2'})

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

    filter = query.available_filters["cf_#{cf.id}"]

    assert_not_nil filter

    values = filter[:values].pluck(1)

    assert_include 'me', values

    assert_include '2', values

    assert_include '10', values

    # "me" includes the groups of the current user

    query.filters = {"cf_#{cf.id}" => {:operator => '=', :values => ['me']}}

    assert_equal [issue1, issue2].map(&:id).sort, query.issues.map(&:id).sort

  end