class User in Drupal 10

Validate whether an argument is a valid user.

This supports either numeric arguments (UID) or strings (username) and converts either one into the user's UID. This validator also sets the argument's title to the username.

Hierarchy

• class \Drupal\views\Plugin\views\argument_validator\Entity extends \Drupal\views\Plugin\views\argument_validator\ArgumentValidatorPluginBase
  • class \Drupal\user\Plugin\views\argument_validator\User

31 string references to 'User'

CategoryAutocompleteTest::providerTestAutocompleteSuggestions in core/modules/block/tests/src/Unit/CategoryAutocompleteTest.php

Data provider for testAutocompleteSuggestions().

CategoryAutocompleteTest::setUp in core/modules/block/tests/src/Unit/CategoryAutocompleteTest.php

contact_entity_extra_field_info in core/modules/contact/contact.module

Implements hook_entity_extra_field_info().

ContentModerationState::baseFieldDefinitions in core/modules/content_moderation/src/Entity/ContentModerationState.php

ContextPluginTest::testContext in core/tests/Drupal/KernelTests/Core/Plugin/ContextPluginTest.php

Tests basic context definition and value getters and setters.

... See full list

File

core/modules/user/src/Plugin/views/argument_validator/User.php, line 19

Namespace

Drupal\user\Plugin\views\argument_validator

class User extends Entity {

  /**
   * The user storage.
   *
   * @var \Drupal\Core\Entity\EntityStorageInterface
   */
  protected $userStorage;

  /**
   * {@inheritdoc}
   */
  public function __construct(array $configuration, $plugin_id, $plugin_definition, EntityTypeManagerInterface $entity_type_manager, EntityTypeBundleInfoInterface $entity_type_bundle_info = NULL) {
    parent::__construct($configuration, $plugin_id, $plugin_definition, $entity_type_manager, $entity_type_bundle_info);
    $this->userStorage = $entity_type_manager
      ->getStorage('user');
  }

  /**
   * {@inheritdoc}
   */
  protected function defineOptions() {
    $options = parent::defineOptions();
    $options['restrict_roles'] = [
      'default' => FALSE,
    ];
    $options['roles'] = [
      'default' => [],
    ];
    return $options;
  }

  /**
   * {@inheritdoc}
   */
  public function buildOptionsForm(&$form, FormStateInterface $form_state) {
    parent::buildOptionsForm($form, $form_state);
    $sanitized_id = ArgumentPluginBase::encodeValidatorId($this->definition['id']);
    $form['restrict_roles'] = [
      '#type' => 'checkbox',
      '#title' => $this
        ->t('Restrict user based on role'),
      '#default_value' => $this->options['restrict_roles'],
    ];
    $form['roles'] = [
      '#type' => 'checkboxes',
      '#title' => $this
        ->t('Restrict to the selected roles'),
      '#options' => array_map([
        '\\Drupal\\Component\\Utility\\Html',
        'escape',
      ], user_role_names(TRUE)),
      '#default_value' => $this->options['roles'],
      '#description' => $this
        ->t('If no roles are selected, users from any role will be allowed.'),
      '#states' => [
        'visible' => [
          ':input[name="options[validate][options][' . $sanitized_id . '][restrict_roles]"]' => [
            'checked' => TRUE,
          ],
        ],
      ],
    ];
  }

  /**
   * {@inheritdoc}
   */
  public function submitOptionsForm(&$form, FormStateInterface $form_state, &$options = []) {

    // filter trash out of the options so we don't store giant unnecessary arrays
    $options['roles'] = array_filter($options['roles']);
  }

  /**
   * {@inheritdoc}
   */
  protected function validateEntity(EntityInterface $entity) {

    /** @var \Drupal\user\UserInterface $entity */
    $role_check_success = TRUE;

    // See if we're filtering users based on roles.
    if (!empty($this->options['restrict_roles']) && !empty($this->options['roles'])) {
      $roles = $this->options['roles'];
      if (!(bool) array_intersect($entity
        ->getRoles(), $roles)) {
        $role_check_success = FALSE;
      }
    }
    return $role_check_success && parent::validateEntity($entity);
  }

  /**
   * {@inheritdoc}
   */
  public function calculateDependencies() {
    $dependencies = parent::calculateDependencies();
    foreach ($this->entityTypeManager
      ->getStorage('user_role')
      ->loadMultiple(array_keys($this->options['roles'])) as $role) {
      $dependencies[$role
        ->getConfigDependencyKey()][] = $role
        ->getConfigDependencyName();
    }
    return $dependencies;
  }

}

Members

Name	Modifiers	Type	Description	Overrides
Entity::$entityTypeBundleInfo	protected	property	The entity bundle info.
Entity::$entityTypeManager	protected	property	The entity type manager.
Entity::$multipleCapable	protected	property	If this validator can handle multiple arguments.
Entity::create	public static	function
Entity::getContextDefinition	public	function
Entity::validateArgument	public	function		2
User::$userStorage	protected	property	The user storage.
User::buildOptionsForm	public	function	Overrides Entity::buildOptionsForm	1
User::calculateDependencies	public	function	Overrides Entity::calculateDependencies
User::defineOptions	protected	function	Overrides Entity::defineOptions
User::submitOptionsForm	public	function	Overrides Entity::submitOptionsForm
User::validateEntity	protected	function	Validates an individual entity against class access settings. Overrides Entity::validateEntity
User::__construct	public	function	Constructs a \Drupal\views\Plugin\views\argument_validator\Entity object. Overrides Entity::__construct