You are here

Home » API reference » Search API 8 » ReverseEntityReferences.php

class ReverseEntityReferences in Search API 8

Allows indexing of reverse entity references.

Plugin annotation


@SearchApiProcessor(
  id = "reverse_entity_references",
  label = @Translation("Reverse entity references"),
  description = @Translation("Allows indexing of entities that link to the indexed entity."),
  stages = {
    "add_properties" = 0,
  },
)

Hierarchy

Expanded class hierarchy of ReverseEntityReferences

File

src/Plugin/search_api/processor/ReverseEntityReferences.php, line 36

Namespace

Drupal\search_api\Plugin\search_api\processor
View source 
class ReverseEntityReferences extends ProcessorPluginBase {

  /**
   * Static cache for all entity references.
   *
   * @var array[][]|null
   *
   * @see \Drupal\search_api\Plugin\search_api\processor\ReverseEntityReferences::getEntityReferences()
   */
  protected $references;

  /**
   * The entity type manager.
   *
   * @var \Drupal\Core\Entity\EntityTypeManagerInterface|null
   */
  protected $entityTypeManager;

  /**
   * The entity field manager.
   *
   * @var \Drupal\Core\Entity\EntityFieldManager|null
   */
  protected $entityFieldManager;

  /**
   * The entity type bundle info.
   *
   * @var \Drupal\Core\Entity\EntityTypeBundleInfoInterface|null
   */
  protected $entityTypeBundleInfo;

  /**
   * The language manager.
   *
   * @var \Drupal\Core\Language\LanguageManagerInterface|null
   */
  protected $languageManager;

  /**
   * The cache.
   *
   * @var \Drupal\Core\Cache\CacheBackendInterface|null
   */
  protected $cache;

  /**
   * {@inheritdoc}
   */
  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {

    /** @var static $processor */
    $processor = parent::create($container, $configuration, $plugin_id, $plugin_definition);
    $processor
      ->setEntityTypeManager($container
      ->get('entity_type.manager'));
    $processor
      ->setEntityFieldManager($container
      ->get('entity_field.manager'));
    $processor
      ->setEntityTypeBundleInfo($container
      ->get('entity_type.bundle.info'));
    $processor
      ->setLanguageManager($container
      ->get('language_manager'));
    $processor
      ->setCache($container
      ->get('cache.default'));
    return $processor;
  }

  /**
   * Retrieves the entity type manager.
   *
   * @return \Drupal\Core\Entity\EntityTypeManagerInterface
   *   The entity type manager.
   */
  public function getEntityTypeManager() {
    return $this->entityTypeManager ?: \Drupal::entityTypeManager();
  }

  /**
   * Sets the entity type manager.
   *
   * @param \Drupal\Core\Entity\EntityTypeManagerInterface $entity_type_manager
   *   The new entity type manager.
   *
   * @return $this
   */
  public function setEntityTypeManager(EntityTypeManagerInterface $entity_type_manager) {
    $this->entityTypeManager = $entity_type_manager;
    return $this;
  }

  /**
   * Retrieves the entity field manager.
   *
   * @return \Drupal\Core\Entity\EntityFieldManager
   *   The entity field manager.
   */
  public function getEntityFieldManager() {
    return $this->entityFieldManager ?: \Drupal::service('entity_field.manager');
  }

  /**
   * Sets the entity field manager.
   *
   * @param \Drupal\Core\Entity\EntityFieldManager $entity_field_manager
   *   The new entity field manager.
   *
   * @return $this
   */
  public function setEntityFieldManager(EntityFieldManager $entity_field_manager) {
    $this->entityFieldManager = $entity_field_manager;
    return $this;
  }

  /**
   * Retrieves the entity type bundle info.
   *
   * @return \Drupal\Core\Entity\EntityTypeBundleInfoInterface
   *   The entity type bundle info.
   */
  public function getEntityTypeBundleInfo() {
    return $this->entityTypeBundleInfo ?: \Drupal::service('entity_type.bundle.info');
  }

  /**
   * Sets the entity type bundle info.
   *
   * @param \Drupal\Core\Entity\EntityTypeBundleInfoInterface $entity_type_bundle_info
   *   The new entity type bundle info.
   *
   * @return $this
   */
  public function setEntityTypeBundleInfo(EntityTypeBundleInfoInterface $entity_type_bundle_info) {
    $this->entityTypeBundleInfo = $entity_type_bundle_info;
    return $this;
  }

  /**
   * Retrieves the language manager.
   *
   * @return \Drupal\Core\Language\LanguageManagerInterface
   *   The language manager.
   */
  public function getLanguageManager() {
    return $this->languageManager ?: \Drupal::service('language_manager');
  }

  /**
   * Sets the language manager.
   *
   * @param \Drupal\Core\Language\LanguageManagerInterface $language_manager
   *   The new language manager.
   *
   * @return $this
   */
  public function setLanguageManager(LanguageManagerInterface $language_manager) {
    $this->languageManager = $language_manager;
    return $this;
  }

  /**
   * Retrieves the cache.
   *
   * @return \Drupal\Core\Cache\CacheBackendInterface
   *   The cache.
   */
  public function getCache() {
    return $this->cache ?: \Drupal::service('cache.default');
  }

  /**
   * Sets the cache.
   *
   * @param \Drupal\Core\Cache\CacheBackendInterface $cache
   *   The new cache.
   *
   * @return $this
   */
  public function setCache(CacheBackendInterface $cache) {
    $this->cache = $cache;
    return $this;
  }

  /**
   * {@inheritdoc}
   */
  public static function supportsIndex(IndexInterface $index) {
    foreach ($index
      ->getDatasources() as $datasource) {
      if ($datasource
        ->getEntityTypeId()) {
        return TRUE;
      }
    }
    return FALSE;
  }

  /**
   * {@inheritdoc}
   */
  public function getPropertyDefinitions(DatasourceInterface $datasource = NULL) {
    $properties = [];
    if (!$datasource || !$datasource
      ->getEntityTypeId()) {
      return $properties;
    }
    $references = $this
      ->getEntityReferences();
    $entity_type_id = $datasource
      ->getEntityTypeId();
    if (isset($references[$entity_type_id])) {
      foreach ($references[$entity_type_id] as $key => $reference) {
        $entity_type_id = $reference['entity_type'];
        try {
          $entity_type = $this
            ->getEntityTypeManager()
            ->getDefinition($entity_type_id);
        } catch (PluginNotFoundException $e) {
          continue;
        }
        $args = [
          '%entity_type' => $entity_type
            ->getLabel(),
          '%property' => $reference['label'],
        ];
        $definition = [
          'label' => $this
            ->t('Reverse reference: %entity_type using %property', $args),
          'description' => $this
            ->t("All %entity_type entities that reference this item via the %property field."),
          'type' => "entity:{$entity_type_id}",
          'processor_id' => $this
            ->getPluginId(),
          // We can't really know whether this will end up being multi-valued, so
          // we err on the side of caution.
          'is_list' => TRUE,
        ];
        $property = new EntityProcessorProperty($definition);
        $property
          ->setEntityTypeId($entity_type_id);
        $properties["search_api_reverse_entity_references_{$key}"] = $property;
      }
    }
    return $properties;
  }

  /**
   * {@inheritdoc}
   */
  public function addFieldValues(ItemInterface $item) {
    try {
      $entity = $item
        ->getOriginalObject()
        ->getValue();
    } catch (SearchApiException $e) {
      return;
    }
    if (!$entity instanceof EntityInterface) {
      return;
    }
    $entity_type_id = $entity
      ->getEntityTypeId();
    $entity_id = $entity
      ->id();
    $langcode = $entity
      ->language()
      ->getId();
    $datasource_id = $item
      ->getDatasourceId();

    /** @var \Drupal\search_api\Item\FieldInterface[][][] $to_extract */
    $to_extract = [];
    $prefix = 'search_api_reverse_entity_references_';
    $prefix_length = strlen($prefix);
    foreach ($item
      ->getFields() as $field) {
      $property_path = $field
        ->getPropertyPath();
      list($direct, $nested) = Utility::splitPropertyPath($property_path, FALSE);
      if ($field
        ->getDatasourceId() === $datasource_id && substr($direct, 0, $prefix_length) === $prefix) {
        $property_name = substr($direct, $prefix_length);
        $to_extract[$property_name][$nested][] = $field;
      }
    }
    $references = $this
      ->getEntityReferences();
    foreach ($to_extract as $property_name => $fields_to_extract) {
      if (!isset($references[$entity_type_id][$property_name])) {
        continue;
      }
      $property_info = $references[$entity_type_id][$property_name];
      try {
        $storage = $this
          ->getEntityTypeManager()
          ->getStorage($property_info['entity_type']);
      } catch (InvalidPluginDefinitionException $e) {
        continue;
      } catch (PluginNotFoundException $e) {
        continue;
      }
      $entity_ids = $storage
        ->getQuery()
        ->accessCheck(FALSE)
        ->condition($property_info['property'], $entity_id)
        ->execute();
      $entities = $storage
        ->loadMultiple($entity_ids);
      if (!$entities) {
        continue;
      }

      // This is a pretty hack-y work-around to make property extraction work for
      // Views fields, too. In general, adding entities as field values is a
      // pretty bad idea, so this might blow up in some use cases. Just do it for
      // now and hope for the best.
      if (isset($fields_to_extract[''])) {
        foreach ($fields_to_extract[''] as $field) {
          $field
            ->setValues(array_values($entities));
        }
        unset($fields_to_extract['']);
      }
      foreach ($entities as $referencing_entity) {
        $typed_data = $referencing_entity
          ->getTypedData();
        $this
          ->getFieldsHelper()
          ->extractFields($typed_data, $fields_to_extract, $langcode);
      }
    }
  }

  /**
   * Collects all entity references.
   *
   * @return array[][]
   *   An associative array of entity reference information keyed by the
   *   referenced entity type's ID and a custom identifier for the property
   *   (consisting of referencing entity type and property name), with values
   *   being associative arrays with the following keys:
   *   - label: The property label.
   *   - entity_type: The referencing entity type.
   *   - property: The property name.
   */
  public function getEntityReferences() {
    if ($this->references !== NULL) {
      return $this->references;
    }

    // Property labels differ by language, so we need to vary the cache
    // according to the current language.
    $langcode = $this
      ->getLanguageManager()
      ->getCurrentLanguage()
      ->getId();
    $cid = "search_api:reverse_entity_references:{$langcode}";
    $cache = $this
      ->getCache()
      ->get($cid);
    if (isset($cache->data)) {
      $this->references = $cache->data;
    }
    else {
      $this->references = [];
      $entity_types = $this
        ->getEntityTypeManager()
        ->getDefinitions();
      $field_manager = $this
        ->getEntityFieldManager();
      $entity_type_bundle_info = $this
        ->getEntityTypeBundleInfo();
      foreach ($entity_types as $entity_type_id => $entity_type) {
        if (!$entity_type instanceof ContentEntityTypeInterface) {
          continue;
        }

        /** @var \Drupal\Core\Field\FieldDefinitionInterface[] $properties */
        $properties = $field_manager
          ->getBaseFieldDefinitions($entity_type_id);
        $bundles = $entity_type_bundle_info
          ->getBundleInfo($entity_type_id);
        foreach ($bundles as $bundle => $info) {
          $properties += $field_manager
            ->getFieldDefinitions($entity_type_id, $bundle);
        }
        foreach ($properties as $name => $property) {
          if ($property
            ->getType() !== 'entity_reference') {
            continue;
          }
          $settings = $property
            ->getSettings();
          if (empty($settings['target_type'])) {
            continue;
          }
          $this->references[$settings['target_type']]["{$entity_type_id}__{$name}"] = [
            'label' => $property
              ->getLabel(),
            'entity_type' => $entity_type_id,
            'property' => $name,
          ];
        }
      }
      $tags = [
        'entity_types',
        'entity_bundles',
        'entity_field_info',
      ];
      $this
        ->getCache()
        ->set($cid, $this->references, Cache::PERMANENT, $tags);
    }
    return $this->references;
  }

}

Members

Namesort descending Modifiers Type Description Overrides
ConfigurablePluginBase::calculateDependencies public function Calculates dependencies for the configured plugin. Overrides DependentPluginInterface::calculateDependencies 6
ConfigurablePluginBase::calculatePluginDependencies Deprecated protected function Calculates and adds dependencies of a specific plugin instance.
ConfigurablePluginBase::defaultConfiguration public function Gets default configuration for this plugin. Overrides ConfigurableInterface::defaultConfiguration 11
ConfigurablePluginBase::getConfiguration public function Gets this plugin's configuration. Overrides ConfigurableInterface::getConfiguration
ConfigurablePluginBase::getDescription public function Returns the plugin's description. Overrides ConfigurablePluginInterface::getDescription
ConfigurablePluginBase::getPluginDependencies Deprecated protected function Calculates and returns dependencies of a specific plugin instance.
ConfigurablePluginBase::label public function Returns the label for use on the administration pages. Overrides ConfigurablePluginInterface::label
ConfigurablePluginBase::moduleHandler Deprecated protected function Wraps the module handler.
ConfigurablePluginBase::onDependencyRemoval public function Informs the plugin that some of its dependencies are being removed. Overrides ConfigurablePluginInterface::onDependencyRemoval 5
ConfigurablePluginBase::setConfiguration public function Sets the configuration for this plugin instance. Overrides ConfigurableInterface::setConfiguration 3
ConfigurablePluginBase::themeHandler Deprecated protected function Wraps the theme handler.
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.
IndexPluginBase::$index protected property The index this processor is configured for.
IndexPluginBase::getIndex public function Retrieves the index this plugin is configured for. Overrides IndexPluginInterface::getIndex
IndexPluginBase::setIndex public function Sets the index this plugin is configured for. Overrides IndexPluginInterface::setIndex
IndexPluginBase::__construct public function Constructs a \Drupal\Component\Plugin\PluginBase object. Overrides ConfigurablePluginBase::__construct 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.
PluginDependencyTrait::calculatePluginDependencies protected function Calculates and adds dependencies of a specific plugin instance. Aliased as: traitCalculatePluginDependencies 1
PluginDependencyTrait::getPluginDependencies protected function Calculates and returns dependencies of a specific plugin instance. Aliased as: traitGetPluginDependencies
PluginDependencyTrait::moduleHandler protected function Wraps the module handler. Aliased as: traitModuleHandler 1
PluginDependencyTrait::themeHandler protected function Wraps the theme handler. Aliased as: traitThemeHandler 1
ProcessorInterface::STAGE_ADD_PROPERTIES constant Processing stage: add properties.
ProcessorInterface::STAGE_ALTER_ITEMS constant Processing stage: alter indexed items.
ProcessorInterface::STAGE_POSTPROCESS_QUERY constant Processing stage: postprocess query.
ProcessorInterface::STAGE_PREPROCESS_INDEX constant Processing stage: preprocess index.
ProcessorInterface::STAGE_PREPROCESS_QUERY constant Processing stage: preprocess query.
ProcessorInterface::STAGE_PRE_INDEX_SAVE constant Processing stage: preprocess index.
ProcessorPluginBase::$fieldsHelper protected property The fields helper. 1
ProcessorPluginBase::alterIndexedItems public function Alter the items to be indexed. Overrides ProcessorInterface::alterIndexedItems 3
ProcessorPluginBase::ensureField protected function Ensures that a field with certain properties is indexed on the index.
ProcessorPluginBase::findField protected function Finds a certain field in the index.
ProcessorPluginBase::getFieldsHelper public function Retrieves the fields helper. 1
ProcessorPluginBase::getWeight public function Returns the weight for a specific processing stage. Overrides ProcessorInterface::getWeight
ProcessorPluginBase::isHidden public function Determines whether this plugin should be hidden in the UI. Overrides HideablePluginBase::isHidden
ProcessorPluginBase::isLocked public function Determines whether this processor should always be enabled. Overrides ProcessorInterface::isLocked
ProcessorPluginBase::postprocessSearchResults public function Postprocess search results before they are returned by the query. Overrides ProcessorInterface::postprocessSearchResults 2
ProcessorPluginBase::preIndexSave public function Preprocesses the search index entity before it is saved. Overrides ProcessorInterface::preIndexSave 5
ProcessorPluginBase::preprocessIndexItems public function Preprocesses search items for indexing. Overrides ProcessorInterface::preprocessIndexItems 5
ProcessorPluginBase::preprocessSearchQuery public function Preprocesses a search query. Overrides ProcessorInterface::preprocessSearchQuery 4
ProcessorPluginBase::requiresReindexing public function Determines whether re-indexing is required after a settings change. Overrides ProcessorInterface::requiresReindexing
ProcessorPluginBase::setFieldsHelper public function Sets the fields helper. 1
ProcessorPluginBase::setWeight public function Sets the weight for a specific processing stage. Overrides ProcessorInterface::setWeight
ProcessorPluginBase::supportsStage public function Checks whether this processor implements a particular stage. Overrides ProcessorInterface::supportsStage 2
ReverseEntityReferences::$cache protected property The cache.
ReverseEntityReferences::$entityFieldManager protected property The entity field manager.
ReverseEntityReferences::$entityTypeBundleInfo protected property The entity type bundle info.
ReverseEntityReferences::$entityTypeManager protected property The entity type manager.
ReverseEntityReferences::$languageManager protected property The language manager.
ReverseEntityReferences::$references protected property Static cache for all entity references.
ReverseEntityReferences::addFieldValues public function Adds the values of properties defined by this processor to the item. Overrides ProcessorPluginBase::addFieldValues
ReverseEntityReferences::create public static function Creates an instance of the plugin. Overrides ProcessorPluginBase::create
ReverseEntityReferences::getCache public function Retrieves the cache.
ReverseEntityReferences::getEntityFieldManager public function Retrieves the entity field manager.
ReverseEntityReferences::getEntityReferences public function Collects all entity references.
ReverseEntityReferences::getEntityTypeBundleInfo public function Retrieves the entity type bundle info.
ReverseEntityReferences::getEntityTypeManager public function Retrieves the entity type manager.
ReverseEntityReferences::getLanguageManager public function Retrieves the language manager.
ReverseEntityReferences::getPropertyDefinitions public function Retrieves the properties this processor defines for the given datasource. Overrides ProcessorPluginBase::getPropertyDefinitions
ReverseEntityReferences::setCache public function Sets the cache.
ReverseEntityReferences::setEntityFieldManager public function Sets the entity field manager.
ReverseEntityReferences::setEntityTypeBundleInfo public function Sets the entity type bundle info.
ReverseEntityReferences::setEntityTypeManager public function Sets the entity type manager.
ReverseEntityReferences::setLanguageManager public function Sets the language manager.
ReverseEntityReferences::supportsIndex public static function Checks whether this processor is applicable for a certain index. Overrides ProcessorPluginBase::supportsIndex
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.