class UserRole in Feeds 8.3

Defines a user role mapper.

Plugin annotation


@FeedsTarget(
  id = "user_role",
)

Hierarchy

class \Drupal\Component\Plugin\PluginBase implements DerivativeInspectionInterface, PluginInspectionInterface
- class \Drupal\Core\Plugin\PluginBase uses DependencySerializationTrait, MessengerTrait, StringTranslationTrait
  - class \Drupal\feeds\Plugin\Type\PluginBase implements FeedsPluginInterface uses DependencyTrait
    class \Drupal\feeds\Plugin\Type\ConfigurablePluginBase implements PluginFormInterface
    class \Drupal\feeds\Plugin\Type\Target\TargetBase implements TargetInterface
    class \Drupal\feeds\Plugin\Type\Target\FieldTargetBase implements ConfigurableTargetInterface, TranslatableTargetInterface
    class \Drupal\feeds\Feeds\Target\ConfigEntityReference implements ContainerFactoryPluginInterface, ConfigurableTargetInterface
    class \Drupal\feeds\Feeds\Target\UserRole

Expanded class hierarchy of UserRole

1 file declares its use of UserRole

UserRoleTest.php in tests/src/Unit/Feeds/Target/UserRoleTest.php

File

src/Feeds/Target/UserRole.php, line 21

Namespace

Drupal\feeds\Feeds\Target

View source

class UserRole extends ConfigEntityReference {

  /**
   * {@inheritdoc}
   */
  public static function targets(array &$targets, FeedTypeInterface $feed_type, array $definition) {
    $processor = $feed_type
      ->getProcessor();
    if (!$processor instanceof EntityProcessorInterface) {
      return $targets;
    }
    $field_definitions = \Drupal::service('entity_field.manager')
      ->getFieldDefinitions($processor
      ->entityType(), $processor
      ->bundle());
    foreach ($field_definitions as $id => $field_definition) {
      if ($field_definition
        ->getType() == 'entity_reference' && $field_definition
        ->getSetting('target_type') == 'user_role') {
        if ($target = static::prepareTarget($field_definition)) {
          $target
            ->setPluginId($definition['id']);
          $targets[$id] = $target;
        }
      }
    }
  }

  /**
   * {@inheritdoc}
   */
  public function setTarget(FeedInterface $feed, EntityInterface $entity, $field_name, array $values) {

    // Check if values list is currently empty.
    $entity_target = $this
      ->getEntityTarget($feed, $entity);
    $is_empty = empty($entity_target
      ->get($field_name)
      ->getValue());
    if (empty($entity_target)) {
      return;
    }
    parent::setTarget($feed, $entity, $field_name, $values);
    $item_list = $entity_target
      ->get($field_name);

    // Append roles from unsaved entity, if there is one.
    if ($entity_target
      ->id() && $is_empty) {
      $original = $this->entityTypeManager
        ->getStorage($entity_target
        ->getEntityTypeId())
        ->loadUnchanged($entity
        ->id());
      if ($original) {
        $original_values = $original
          ->get($field_name)
          ->getValue();

        // Revoke roles, when that option is enabled. But do not touch roles
        // that are not allowed to set by the source.
        if ($this->configuration['revoke_roles']) {
          foreach ($original_values as $key => $value) {
            $rid = $value['target_id'];
            if (!empty($this->configuration['allowed_roles'][$rid])) {
              unset($original_values[$key]);
            }
          }
        }

        // Merge the remaining values.
        $values = array_merge($item_list
          ->getValue(), $original_values);
        $item_list
          ->setValue($values);
      }
    }
  }

  /**
   * {@inheritdoc}
   */
  protected function prepareValue($delta, array &$values) {
    try {
      return parent::prepareValue($delta, $values);
    } catch (ReferenceNotFoundException $e) {

      // Throw an exception with a more understandable message.
      throw new ReferenceNotFoundException($this
        ->t('The role %role cannot be assigned because it does not exist.', [
        '%role' => $values['target_id'],
      ]));
    }
  }

  /**
   * {@inheritdoc}
   */
  protected function findEntity(string $field, $search) {
    $entity_id = parent::findEntity($field, $search);
    if ($entity_id !== FALSE) {

      // Check if the role may be assigned.
      if (isset($this->configuration['allowed_roles'][$entity_id]) && !$this->configuration['allowed_roles'][$entity_id]) {

        // This role may *not* be assigned.
        throw new TargetValidationException($this
          ->t('The role %role may not be referenced.', [
          '%role' => $entity_id,
        ]));
      }
      return $entity_id;
    }

    // Automatically create a new role.
    if ($this->configuration['autocreate'] && in_array($this->configuration['reference_by'], [
      'id',
      'label',
    ])) {
      return $this
        ->createRole($search);
    }
  }

  /**
   * Creates a new role with the given label and saves it.
   *
   * @param string $label
   *   The label the new role should get.
   *
   * @return int|string|false
   *   The ID of the new role or false if the given label is empty.
   */
  protected function createRole($label) {
    if (!strlen(trim($label))) {
      return FALSE;
    }
    $values = [
      'id' => $this
        ->generateMachineName($label),
      'label' => $label,
    ];
    $entity = $this->entityTypeManager
      ->getStorage($this
      ->getEntityType())
      ->create($values);
    $entity
      ->save();
    return $entity
      ->id();
  }

  /**
   * {@inheritdoc}
   */
  public function defaultConfiguration() {
    $role_names = array_keys($this
      ->getRoleNames());
    $config = parent::defaultConfiguration() + [
      'allowed_roles' => array_combine($role_names, $role_names),
      'autocreate' => FALSE,
      'revoke_roles' => FALSE,
    ];
    return $config;
  }

  /**
   * Returns a list of role names, keyed by role ID.
   *
   * @return array
   *   A list of role names.
   */
  protected function getRoleNames() {
    $roles = $this->entityTypeManager
      ->getStorage('user_role')
      ->loadMultiple();
    unset($roles[RoleInterface::ANONYMOUS_ID]);
    unset($roles[RoleInterface::AUTHENTICATED_ID]);
    return array_map(function ($item) {
      return $item
        ->label();
    }, $roles);
  }

  /**
   * {@inheritdoc}
   */
  public function buildConfigurationForm(array $form, FormStateInterface $form_state) {
    $form = parent::buildConfigurationForm($form, $form_state);

    // Hack to find out the target delta.
    $delta = 0;
    foreach ($form_state
      ->getValues() as $key => $value) {
      if (strpos($key, 'target-settings-') === 0) {
        list(, , $delta) = explode('-', $key);
        break;
      }
    }
    $form['allowed_roles'] = [
      '#type' => 'checkboxes',
      '#title' => $this
        ->t('Allowed roles'),
      '#options' => $this
        ->getRoleNames(),
      '#default_value' => $this->configuration['allowed_roles'],
      '#description' => $this
        ->t('Select the roles to accept from the feed.<br />Any other roles will be ignored.'),
    ];
    $form['autocreate'] = [
      '#type' => 'checkbox',
      '#title' => $this
        ->t('Auto create'),
      '#description' => $this
        ->t("Create the role if it doesn't exist. This option has only effect when referencing by ID or label."),
      '#default_value' => $this->configuration['autocreate'],
      '#states' => [
        'enabled' => [
          [
            ':input[name="mappings[' . $delta . '][settings][reference_by]"]' => [
              'value' => 'id',
            ],
          ],
          [
            ':input[name="mappings[' . $delta . '][settings][reference_by]"]' => [
              'value' => 'label',
            ],
          ],
        ],
      ],
    ];
    $form['revoke_roles'] = [
      '#type' => 'checkbox',
      '#title' => $this
        ->t('Revoke roles'),
      '#description' => t('If enabled, roles that are not provided by the feed will be revoked for the user. This affects only the "Allowed roles" as configured above.'),
      '#default_value' => $this->configuration['revoke_roles'],
    ];
    return $form;
  }

  /**
   * {@inheritdoc}
   */
  public function getSummary() {
    $summary = parent::getSummary();

    // Allowed roles.
    $role_names = array_intersect_key($this
      ->getRoleNames(), array_filter($this->configuration['allowed_roles']));
    if (empty($role_names)) {
      $role_names = [
        '<' . $this
          ->t('none') . '>',
      ];
    }
    $summary[] = $this
      ->t('Allowed roles: %roles', [
      '%roles' => implode(', ', $role_names),
    ]);

    // Autocreate.
    if ($this->configuration['autocreate']) {
      $summary[] = $this
        ->t('Automatically create roles');
    }
    else {
      $summary[] = $this
        ->t('Only assign existing roles');
    }

    // Revoke roles.
    if ($this->configuration['revoke_roles']) {
      $summary[] = $this
        ->t('Revoke roles: yes');
    }
    else {
      $summary[] = $this
        ->t('Revoke roles: no');
    }
    return $summary;
  }

}

Members

Name	Modifiers	Type	Description	Overrides
ConfigEntityReference::$entityFinder	protected	property	The Feeds entity finder service.
ConfigEntityReference::$entityTypeManager	protected	property	The entity type manager.
ConfigEntityReference::$transliteration	protected	property	The transliteration manager.
ConfigEntityReference::$typedConfigManager	protected	property	The manager for managing config schema type plugins.
ConfigEntityReference::create	public static	function	Creates an instance of the plugin. Overrides ContainerFactoryPluginInterface::create
ConfigEntityReference::generateMachineName	protected	function	Generates a machine name from a string.
ConfigEntityReference::getEntityType	protected	function	Returns the entity type that can be referenced.
ConfigEntityReference::getPotentialFields	protected	function	Returns possible fields to reference by for a config entity.
ConfigEntityReference::prepareTarget	protected static	function	Prepares a target definition. Overrides FieldTargetBase::prepareTarget
ConfigEntityReference::__construct	public	function	Constructs a ConfigEntityReference object. Overrides FieldTargetBase::__construct
ConfigurablePluginBase::validateConfigurationForm	public	function	Form validation handler. Overrides PluginFormInterface::validateConfigurationForm
DependencySerializationTrait::$_entityStorages	protected	property	An array of entity type IDs keyed by the property name of their storages.
DependencySerializationTrait::$_serviceIds	protected	property	An array of service IDs keyed by property name used for serialization.
DependencySerializationTrait::__sleep	public	function		1
DependencySerializationTrait::__wakeup	public	function		2
DependencyTrait::$dependencies	protected	property	The object's dependencies.
DependencyTrait::addDependencies	protected	function	Adds multiple dependencies.
DependencyTrait::addDependency	protected	function	Adds a dependency.
FieldTargetBase::$fieldSettings	protected	property	The field settings.
FieldTargetBase::$languageManager	protected	property	The language manager.
FieldTargetBase::addMessage	protected	function	Adds a message.
FieldTargetBase::calculateDependencies	public	function	Calculates dependencies for the configured plugin. Overrides PluginBase::calculateDependencies
FieldTargetBase::getEntityTarget	public	function	Get entity, or entity translation to set the map.
FieldTargetBase::getLangcode	public	function	Gets the configured language. Overrides TranslatableTargetInterface::getLangcode
FieldTargetBase::getLanguageManager	protected	function	Gets the language manager.
FieldTargetBase::getMessenger	protected	function	Returns the messenger to use.
FieldTargetBase::getUniqueQuery	protected	function	Constructs a base query which is used to find an existing entity.
FieldTargetBase::getUniqueValue	public	function	Looks for an existing entity and returns an entity ID if found.
FieldTargetBase::isEmpty	public	function	Returns if the value for the target is empty. Overrides TargetInterface::isEmpty
FieldTargetBase::isMutable	public	function	Returns if the target is mutable. Overrides TargetInterface::isMutable	1
FieldTargetBase::isTargetFieldTranslatable	protected	function	Checks if the targeted field is translatable.
FieldTargetBase::isTargetTranslatable	public	function	Checks if the target is translatable. Overrides TranslatableTargetInterface::isTargetTranslatable
FieldTargetBase::languageExists	public	function	Checks if the language selected on the target exists. Overrides TranslatableTargetInterface::languageExists
FieldTargetBase::onDependencyRemoval	public	function	Allows a plugin to define whether it should be removed. Overrides TargetBase::onDependencyRemoval
FieldTargetBase::prepareValues	protected	function	Prepares the the values that will be mapped to an entity.
FieldTargetBase::setLanguageManager	public	function	Sets the language manager.
MessengerTrait::$messenger	protected	property	The messenger.	29
MessengerTrait::messenger	public	function	Gets the messenger.	29
MessengerTrait::setMessenger	public	function	Sets the messenger.
PluginBase::$configuration	protected	property	Configuration information passed into the plugin.	1
PluginBase::$feedType	protected	property	The importer this plugin is working for.
PluginBase::$linkGenerator	protected	property	The link generator.
PluginBase::$pluginDefinition	protected	property	The plugin implementation definition.	1
PluginBase::$pluginId	protected	property	The plugin_id.
PluginBase::$urlGenerator	protected	property	The url generator.
PluginBase::container	private	function	Returns the service container.
PluginBase::defaultFeedConfiguration	public	function	Returns default feed configuration. Overrides FeedsPluginInterface::defaultFeedConfiguration	3
PluginBase::DERIVATIVE_SEPARATOR		constant	A string which is used to separate base plugin IDs from the derivative ID.
PluginBase::getBaseId	public	function	Gets the base_plugin_id of the plugin instance. Overrides DerivativeInspectionInterface::getBaseId
PluginBase::getConfiguration	public	function	Gets this plugin's configuration. Overrides ConfigurableInterface::getConfiguration
PluginBase::getDerivativeId	public	function	Gets the derivative_id of the plugin instance. Overrides DerivativeInspectionInterface::getDerivativeId
PluginBase::getPluginDefinition	public	function	Gets the definition of the plugin implementation. Overrides PluginInspectionInterface::getPluginDefinition	3
PluginBase::getPluginId	public	function	Gets the plugin_id of the plugin instance. Overrides PluginInspectionInterface::getPluginId
PluginBase::isConfigurable	public	function	Determines if the plugin is configurable.
PluginBase::l	protected	function	Renders a link to a route given a route name and its parameters.
PluginBase::linkGenerator	protected	function	Returns the link generator service.
PluginBase::onFeedDeleteMultiple	public	function	A feed is being deleted.	3
PluginBase::onFeedSave	public	function	A feed is being saved.
PluginBase::onFeedTypeDelete	public	function	The feed type is being deleted.	1
PluginBase::onFeedTypeSave	public	function	The feed type is being saved.	1
PluginBase::pluginType	public	function	Returns the type of plugin. Overrides FeedsPluginInterface::pluginType
PluginBase::setConfiguration	public	function	Sets the configuration for this plugin instance. Overrides ConfigurableInterface::setConfiguration	1
PluginBase::url	protected	function	Generates a URL or path for a specific route based on the given parameters.
PluginBase::urlGenerator	protected	function	Returns the URL generator service.
StringTranslationTrait::$stringTranslation	protected	property	The string translation service.	1
StringTranslationTrait::formatPlural	protected	function	Formats a string containing a count of items.
StringTranslationTrait::getNumberOfPlurals	protected	function	Returns the number of plurals supported by a given language.
StringTranslationTrait::getStringTranslation	protected	function	Gets the string translation service.
StringTranslationTrait::setStringTranslation	public	function	Sets the string translation service to use.	2
StringTranslationTrait::t	protected	function	Translates a string to the current language or to a given language.
TargetBase::$targetDefinition	protected	property	The target definition.
TargetBase::getTargetDefinition	public	function	Returns the target's definition. Overrides TargetInterface::getTargetDefinition
TargetBase::submitConfigurationForm	public	function	Form submission handler. Overrides ConfigurablePluginBase::submitConfigurationForm
UserRole::buildConfigurationForm	public	function	Form constructor. Overrides ConfigEntityReference::buildConfigurationForm
UserRole::createRole	protected	function	Creates a new role with the given label and saves it.
UserRole::defaultConfiguration	public	function	Gets default configuration for this plugin. Overrides ConfigEntityReference::defaultConfiguration
UserRole::findEntity	protected	function	Searches for an entity by entity key. Overrides ConfigEntityReference::findEntity
UserRole::getRoleNames	protected	function	Returns a list of role names, keyed by role ID.
UserRole::getSummary	public	function	Returns the summary for a target. Overrides ConfigEntityReference::getSummary
UserRole::prepareValue	protected	function	Prepares a single value. Overrides ConfigEntityReference::prepareValue
UserRole::setTarget	public	function	Sets the values on an object. Overrides ConfigEntityReference::setTarget
UserRole::targets	public static	function	Returns the targets defined by this plugin. Overrides FieldTargetBase::targets

You are here

class UserRole in Feeds 8.3

Plugin annotation

Hierarchy

File

Namespace

Members

API Navigation