comparison core/lib/Drupal/Core/ParamConverter/EntityConverter.php @ 18:af1871eacc83

Update to Drupal core 8.7.1

 <?php
 
 namespace Drupal\Core\ParamConverter;
 
-use Drupal\Core\Entity\EntityInterface;
+use Drupal\Core\DependencyInjection\DeprecatedServicePropertyTrait;
 use Drupal\Core\Entity\EntityManagerInterface;
+use Drupal\Core\Entity\EntityRepositoryInterface;
+use Drupal\Core\Entity\EntityTypeManagerInterface;
 use Drupal\Core\Entity\RevisionableInterface;
-use Drupal\Core\Entity\TranslatableRevisionableInterface;
 use Drupal\Core\Language\LanguageInterface;
-use Drupal\Core\Language\LanguageManagerInterface;
+use Drupal\Core\Plugin\Context\Context;
+use Drupal\Core\Plugin\Context\ContextDefinition;
 use Drupal\Core\TypedData\TranslatableInterface;
 use Symfony\Component\Routing\Route;
 
 /**
  * Parameter converter for upcasting entity IDs to full objects.

  *
  * @see entities_revisions_translations
  */
 class EntityConverter implements ParamConverterInterface {
 
-  /**
-   * Entity manager which performs the upcasting in the end.
-   *
-   * @var \Drupal\Core\Entity\EntityManagerInterface
-   */
-  protected $entityManager;
-
-  /**
-   * The language manager.
-   *
-   * @var \Drupal\Core\Language\LanguageManagerInterface
-   */
-  protected $languageManager;
+  use DeprecatedServicePropertyTrait;
+  use DynamicEntityTypeParamConverterTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected $deprecatedProperties = [
+    'entityManager' => 'entity.manager',
+    'languageManager' => 'language_manager',
+  ];
+
+  /**
+   * Entity type manager which performs the upcasting in the end.
+   *
+   * @var \Drupal\Core\Entity\EntityTypeManagerInterface
+   */
+  protected $entityTypeManager;
+
+  /**
+   * Entity repository.
+   *
+   * @var \Drupal\Core\Entity\EntityRepositoryInterface
+   */
+  protected $entityRepository;
 
   /**
    * Constructs a new EntityConverter.
    *
-   * @param \Drupal\Core\Entity\EntityManagerInterface $entity_manager
-   *   The entity manager.
-   * @param \Drupal\Core\Language\LanguageManagerInterface|null $language_manager
-   *   (optional) The language manager. Defaults to none.
-   */
-  public function __construct(EntityManagerInterface $entity_manager, LanguageManagerInterface $language_manager = NULL) {
-    $this->entityManager = $entity_manager;
-    $this->languageManager = $language_manager;
+   * @param \Drupal\Core\Entity\EntityTypeManagerInterface $entity_type_manager
+   *   The entity type manager.
+   * @param \Drupal\Core\Entity\EntityRepositoryInterface $entity_repository
+   *   The entity repository.
+   *
+   * @see https://www.drupal.org/node/2549139
+   * @see https://www.drupal.org/node/2938929
+   */
+  public function __construct(EntityTypeManagerInterface $entity_type_manager, $entity_repository = NULL) {
+    if ($entity_type_manager instanceof EntityManagerInterface) {
+      @trigger_error('Passing the entity.manager service to EntityConverter::__construct() is deprecated in Drupal 8.7.0 and will be removed before Drupal 9.0.0. Pass the entity_type.manager service instead. See https://www.drupal.org/node/2549139.', E_USER_DEPRECATED);
+    }
+    $this->entityTypeManager = $entity_type_manager;
+
+    if (!($entity_repository instanceof EntityRepositoryInterface)) {
+      @trigger_error('Calling EntityConverter::__construct() with the $entity_repository argument is supported in drupal:8.7.0 and will be required before drupal:9.0.0. See https://www.drupal.org/node/2549139.', E_USER_DEPRECATED);
+      $entity_repository = \Drupal::service('entity.repository');
+    }
+    $this->entityRepository = $entity_repository;
   }
 
   /**
    * {@inheritdoc}
    */
   public function convert($value, $definition, $name, array $defaults) {
     $entity_type_id = $this->getEntityTypeFromDefaults($definition, $name, $defaults);
-    $storage = $this->entityManager->getStorage($entity_type_id);
-    $entity_definition = $this->entityManager->getDefinition($entity_type_id);
-
-    $entity = $storage->load($value);
 
     // If the entity type is revisionable and the parameter has the
-    // "load_latest_revision" flag, load the latest revision.
-    if ($entity instanceof RevisionableInterface && !empty($definition['load_latest_revision']) && $entity_definition->isRevisionable()) {
-      // Retrieve the latest revision ID taking translations into account.
-      $langcode = $this->languageManager()
-        ->getCurrentLanguage(LanguageInterface::TYPE_CONTENT)
-        ->getId();
-      $entity = $this->getLatestTranslationAffectedRevision($entity, $langcode);
-    }
-
-    // If the entity type is translatable, ensure we return the proper
-    // translation object for the current context.
-    if ($entity instanceof EntityInterface && $entity instanceof TranslatableInterface) {
-      $entity = $this->entityManager->getTranslationFromContext($entity, NULL, ['operation' => 'entity_upcast']);
-    }
+    // "load_latest_revision" flag, load the active variant.
+    if (!empty($definition['load_latest_revision'])) {
+      return $this->entityRepository->getActive($entity_type_id, $value);
+    }
+
+    // Do not inject the context repository as it is not an actual dependency:
+    // it will be removed once both the TODOs below are fixed.
+    /** @var \Drupal\Core\Plugin\Context\ContextRepositoryInterface $contexts_repository */
+    $contexts_repository = \Drupal::service('context.repository');
+    // @todo Consider deprecating the legacy context operation altogether in
+    //   https://www.drupal.org/node/3031124.
+    $contexts = $contexts_repository->getAvailableContexts();
+    $contexts[EntityRepositoryInterface::CONTEXT_ID_LEGACY_CONTEXT_OPERATION] =
+      new Context(new ContextDefinition('string'), 'entity_upcast');
+    // @todo At the moment we do not need the current user context, which is
+    //   triggering some test failures. We can remove these lines once
+    //   https://www.drupal.org/node/2934192 is fixed.
+    $context_id = '@user.current_user_context:current_user';
+    if (isset($contexts[$context_id])) {
+      $account = $contexts[$context_id]->getContextValue();
+      unset($account->_skipProtectedUserFieldConstraint);
+      unset($contexts[$context_id]);
+    }
+    $entity = $this->entityRepository->getCanonical($entity_type_id, $value, $contexts);
 
     return $entity;
   }
 
   /**
-   * Returns the ID of the latest revision translation of the specified entity.
-   *
-   * @param \Drupal\Core\Entity\EntityInterface|\Drupal\Core\Entity\RevisionableInterface $entity
+   * Returns the latest revision translation of the specified entity.
+   *
+   * @param \Drupal\Core\Entity\RevisionableInterface $entity
    *   The default revision of the entity being converted.
    * @param string $langcode
    *   The language of the revision translation to be loaded.
    *
-   * @return \Drupal\Core\Entity\EntityInterface|\Drupal\Core\Entity\RevisionableInterface
+   * @return \Drupal\Core\Entity\RevisionableInterface
    *   The latest translation-affecting revision for the specified entity, or
    *   just the latest revision, if the specified entity is not translatable or
    *   does not have a matching translation yet.
+   *
+   * @deprecated in Drupal 8.7.0 and will be removed before Drupal 9.0.0.
+   *   Use \Drupal\Core\Entity\EntityRepositoryInterface::getActive() instead.
    */
   protected function getLatestTranslationAffectedRevision(RevisionableInterface $entity, $langcode) {
-    $revision = NULL;
-    $storage = $this->entityManager->getStorage($entity->getEntityTypeId());
-
-    if ($entity instanceof TranslatableRevisionableInterface && $entity->isTranslatable()) {
-      /** @var \Drupal\Core\Entity\TranslatableRevisionableStorageInterface $storage */
-      $revision_id = $storage->getLatestTranslationAffectedRevisionId($entity->id(), $langcode);
-
-      // If the latest translation-affecting revision was a default revision, it
-      // is fine to load the latest revision instead, because in this case the
-      // latest revision, regardless of it being default or pending, will always
-      // contain the most up-to-date values for the specified translation. This
-      // provides a BC behavior when the route is defined by a module always
-      // expecting the latest revision to be loaded and to be the default
-      // revision. In this particular case the latest revision is always going
-      // to be the default revision, since pending revisions would not be
-      // supported.
-      /** @var \Drupal\Core\Entity\TranslatableRevisionableInterface $revision */
-      $revision = $revision_id ? $this->loadRevision($entity, $revision_id) : NULL;
-      if (!$revision || ($revision->wasDefaultRevision() && !$revision->isDefaultRevision())) {
-        $revision = NULL;
-      }
-    }
-
-    // Fall back to the latest revisions if no affected revision for the current
-    // content language could be found. This is acceptable as it means the
-    // entity is not translated. This is the correct logic also on monolingual
-    // sites.
-    if (!isset($revision)) {
-      $revision_id = $storage->getLatestRevisionId($entity->id());
-      $revision = $this->loadRevision($entity, $revision_id);
-    }
-
+    @trigger_error('\Drupal\Core\ParamConverter\EntityConverter::getLatestTranslationAffectedRevision() is deprecated in Drupal 8.7.0 and will be removed before Drupal 9.0.0. Use \Drupal\Core\Entity\EntityRepositoryInterface::getActive() instead.', E_USER_DEPRECATED);
+    $data_type = 'language';
+    $context_id_prefix = '@language.current_language_context:';
+    $contexts = [
+      $context_id_prefix . LanguageInterface::TYPE_CONTENT => new Context(new ContextDefinition($data_type), $langcode),
+      $context_id_prefix . LanguageInterface::TYPE_INTERFACE => new Context(new ContextDefinition($data_type), $langcode),
+    ];
+    $revision = $this->entityRepository->getActive($entity->getEntityTypeId(), $entity->id(), $contexts);
+    // The EntityRepositoryInterface::getActive() method performs entity
+    // translation negotiation, but this used to return an untranslated entity
+    // object as translation negotiation happened later in ::convert().
+    if ($revision instanceof TranslatableInterface) {
+      $revision = $revision->getUntranslated();
+    }
     return $revision;
   }
 
   /**
    * Loads the specified entity revision.
    *
-   * @param \Drupal\Core\Entity\EntityInterface|\Drupal\Core\Entity\RevisionableInterface $entity
+   * @param \Drupal\Core\Entity\RevisionableInterface $entity
    *   The default revision of the entity being converted.
    * @param string $revision_id
    *   The identifier of the revision to be loaded.
    *
-   * @return \Drupal\Core\Entity\EntityInterface|\Drupal\Core\Entity\RevisionableInterface
+   * @return \Drupal\Core\Entity\RevisionableInterface
    *   An entity revision object.
+   *
+   * @deprecated in Drupal 8.7.0 and will be removed before Drupal 9.0.0.
    */
   protected function loadRevision(RevisionableInterface $entity, $revision_id) {
+    @trigger_error('\Drupal\Core\ParamConverter\EntityConverter::loadRevision() is deprecated in Drupal 8.7.0 and will be removed before Drupal 9.0.0.', E_USER_DEPRECATED);
     // We explicitly perform a loose equality check, since a revision ID may
     // be returned as an integer or a string.
     if ($entity->getLoadedRevisionId() != $revision_id) {
-      $storage = $this->entityManager->getStorage($entity->getEntityTypeId());
+      /** @var \Drupal\Core\Entity\RevisionableStorageInterface $storage */
+      $storage = $this->entityTypeManager->getStorage($entity->getEntityTypeId());
       return $storage->loadRevision($revision_id);
     }
     else {
       return $entity;
     }

       $entity_type_id = substr($definition['type'], strlen('entity:'));
       if (strpos($definition['type'], '{') !== FALSE) {
         $entity_type_slug = substr($entity_type_id, 1, -1);
         return $name != $entity_type_slug && in_array($entity_type_slug, $route->compile()->getVariables(), TRUE);
       }
-      return $this->entityManager->hasDefinition($entity_type_id);
+      return $this->entityTypeManager->hasDefinition($entity_type_id);
     }
     return FALSE;
-  }
-
-  /**
-   * Determines the entity type ID given a route definition and route defaults.
-   *
-   * @param mixed $definition
-   *   The parameter definition provided in the route options.
-   * @param string $name
-   *   The name of the parameter.
-   * @param array $defaults
-   *   The route defaults array.
-   *
-   * @return string
-   *   The entity type ID.
-   *
-   * @throws \Drupal\Core\ParamConverter\ParamNotConvertedException
-   *   Thrown when the dynamic entity type is not found in the route defaults.
-   */
-  protected function getEntityTypeFromDefaults($definition, $name, array $defaults) {
-    $entity_type_id = substr($definition['type'], strlen('entity:'));
-
-    // If the entity type is dynamic, it will be pulled from the route defaults.
-    if (strpos($entity_type_id, '{') === 0) {
-      $entity_type_slug = substr($entity_type_id, 1, -1);
-      if (!isset($defaults[$entity_type_slug])) {
-        throw new ParamNotConvertedException(sprintf('The "%s" parameter was not converted because the "%s" parameter is missing', $name, $entity_type_slug));
-      }
-      $entity_type_id = $defaults[$entity_type_slug];
-    }
-    return $entity_type_id;
   }
 
   /**
    * Returns a language manager instance.
    *

    *   The language manager.
    *
    * @internal
    */
   protected function languageManager() {
-    if (!isset($this->languageManager)) {
-      $this->languageManager = \Drupal::languageManager();
-      // @todo Turn this into a proper error (E_USER_ERROR) in
-      //   https://www.drupal.org/node/2938929.
-      @trigger_error('The language manager parameter has been added to EntityConverter since version 8.5.0 and will be made required in version 9.0.0 when requesting the latest translation-affected revision of an entity.', E_USER_DEPRECATED);
-    }
-    return $this->languageManager;
+    return $this->__get('languageManager');
   }
 
 }