You are here

Home » API reference » User restrictions 8 » UserRestrictionTypeBase.php

abstract class UserRestrictionTypeBase in User restrictions 8

Hierarchy

Expanded class hierarchy of UserRestrictionTypeBase

File

src/Plugin/UserRestrictionType/UserRestrictionTypeBase.php, line 13

Namespace

Drupal\user_restrictions\Plugin\UserRestrictionType
View source 
abstract class UserRestrictionTypeBase extends PluginBase implements UserRestrictionTypeInterface {
  use StringTranslationTrait;

  /**
   * The entity storage interfacce.
   *
   * @var \Drupal\Core\Entity\EntityStorageInterface
   */
  protected $entityStorage;

  /**
   * The logger instance.
   *
   * @var \Psr\Log\LoggerInterface
   */
  protected $logger;

  /**
   * List of patterns for the restriction type.
   *
   * @var string[]
   */
  protected $patterns = [];

  /**
   * {@inheritdoc}
   */
  public function __construct(array $configuration, $plugin_id, $plugin_definition, EntityTypeManagerInterface $entity_manager, LoggerInterface $logger) {
    parent::__construct($configuration, $plugin_id, $plugin_definition);
    $this->entityStorage = $entity_manager
      ->getStorage('user_restrictions');
    $this->logger = $logger;
  }

  /**
   * {@inheritdoc}
   */
  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
    return new static($configuration, $plugin_id, $plugin_definition, $container
      ->get('entity_type.manager'), $container
      ->get('logger.channel.user_restrictions'));
  }

  /**
   * Check if the specified value matches the restriction.
   *
   * @param string $value
   *   String to check against all restrictions of the type.
   *
   * @return bool|\Drupal\user_restrictions\Entity\UserRestrictions
   *   The restriction entity if the value matches one of the restrictions,
   *   FALSE otherwise.
   */
  protected function matchesValue($value) {

    // Load rules with exact pattern matches.
    $query = $this->entityStorage
      ->getQuery();
    $query
      ->condition('rule_type', $this
      ->getPluginId())
      ->condition('pattern', $value)
      ->condition('expiry', \Drupal::time()
      ->getRequestTime(), '>');
    $results = $query
      ->execute();
    $exact_rules = $this->entityStorage
      ->loadMultiple($results);
    if (!empty($exact_rules)) {

      // Simply take the first matching rule as we have no weight (yet).

      /** @var \Drupal\user_restrictions\Entity\UserRestrictions $rule */
      $rule = reset($exact_rules);
      return $rule
        ->getAccessType() === UserRestrictions::BLACKLIST ? $rule : FALSE;
    }

    // Load all rules of the restriction type.
    $query = $this->entityStorage
      ->getQuery();
    $query
      ->condition('rule_type', $this
      ->getPluginId())
      ->condition('expiry', \Drupal::time()
      ->getRequestTime(), '>');
    $results = $query
      ->execute();
    $rules = $this->entityStorage
      ->loadMultiple($results);
    if (empty($rules)) {
      return FALSE;
    }

    // Set the return variable to FALSE to allow by default.
    $return = FALSE;

    /** @var \Drupal\user_restrictions\Entity\UserRestrictions $rule */
    foreach ($rules as $rule) {
      if (preg_match('/' . $rule
        ->getPattern() . '/i', $value)) {

        // Exit loop after first whitelisted pattern.
        if ($rule
          ->getAccessType() === UserRestrictions::WHITELIST) {
          return FALSE;
        }
        elseif ($rule
          ->getAccessType() === UserRestrictions::BLACKLIST) {

          // If a matching pattern is blacklisted store it but don't return
          // as there may be a whitelisted pattern further in the loop.
          $return = $rule;
        }
      }
    }

    // Return either no match or the blacklisted rule.
    return $return;
  }

  /**
   * {@inheritdoc}
   */
  public function getPatterns() {
    if (!empty($this->patterns)) {
      return $this->patterns;
    }
    $rules = $this->entityStorage
      ->loadByProperties([
      'rule_type' => $this
        ->getPluginId(),
    ]);
    if (empty($rules)) {
      return [];
    }

    /** @var \Drupal\user_restrictions\Entity\UserRestrictions $rule */
    foreach ($rules as $id => $rule) {
      $this->patterns[$id] = $rule
        ->getPattern();
    }
    return $this->patterns;
  }

  /**
   * {@inheritdoc}
   */
  public function getLabel() {
    return $this->pluginDefinition['label'];
  }

  /**
   * {@inheritdoc}
   */
  public function getErrorMessage() {
    return $this
      ->t('Using reserved data.');
  }

}

Members

Namesort descending Modifiers Type Description Overrides
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
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::$pluginDefinition protected property The plugin implementation definition. 1
PluginBase::$pluginId protected property The plugin_id.
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::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.
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.
UserRestrictionTypeBase::$entityStorage protected property The entity storage interfacce.
UserRestrictionTypeBase::$logger protected property The logger instance.
UserRestrictionTypeBase::$patterns protected property List of patterns for the restriction type.
UserRestrictionTypeBase::create public static function Creates an instance of the plugin. Overrides ContainerFactoryPluginInterface::create 1
UserRestrictionTypeBase::getErrorMessage public function Get error message displayed to the user. Overrides UserRestrictionTypeInterface::getErrorMessage 3
UserRestrictionTypeBase::getLabel public function Get the plugin label. Overrides UserRestrictionTypeInterface::getLabel
UserRestrictionTypeBase::getPatterns public function Get the list of regular expression patterns of the type. Overrides UserRestrictionTypeInterface::getPatterns
UserRestrictionTypeBase::matchesValue protected function Check if the specified value matches the restriction.
UserRestrictionTypeBase::__construct public function Constructs a \Drupal\Component\Plugin\PluginBase object. Overrides PluginBase::__construct 1
UserRestrictionTypeInterface::matches public function Check if the given data matches the restriction. 3