You are here

class EntityDefinitionUpdateManager in Drupal 8

Same name and namespace in other branches
  1. 9 core/lib/Drupal/Core/Entity/EntityDefinitionUpdateManager.php \Drupal\Core\Entity\EntityDefinitionUpdateManager
  2. 10 core/lib/Drupal/Core/Entity/EntityDefinitionUpdateManager.php \Drupal\Core\Entity\EntityDefinitionUpdateManager

Manages entity definition updates.

Hierarchy

Expanded class hierarchy of EntityDefinitionUpdateManager

1 file declares its use of EntityDefinitionUpdateManager
EntityDefinitionUpdateManagerTest.php in core/tests/Drupal/Tests/Core/Entity/EntityDefinitionUpdateManagerTest.php
1 string reference to 'EntityDefinitionUpdateManager'
core.services.yml in core/core.services.yml
core/core.services.yml
1 service uses EntityDefinitionUpdateManager
entity.definition_update_manager in core/core.services.yml
Drupal\Core\Entity\EntityDefinitionUpdateManager

File

core/lib/Drupal/Core/Entity/EntityDefinitionUpdateManager.php, line 16

Namespace

Drupal\Core\Entity
View source
class EntityDefinitionUpdateManager implements EntityDefinitionUpdateManagerInterface {
  use StringTranslationTrait;
  use DeprecatedServicePropertyTrait;

  /**
   * {@inheritdoc}
   */
  protected $deprecatedProperties = [
    'entityManager' => 'entity.manager',
  ];

  /**
   * The entity field manager service.
   *
   * @var \Drupal\Core\Entity\EntityFieldManagerInterface
   */
  protected $entityFieldManager;

  /**
   * The entity type listener service.
   *
   * @var \Drupal\Core\Entity\EntityTypeListenerInterface
   */
  protected $entityTypeListener;

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

  /**
   * The field storage definition listener service.
   *
   * @var \Drupal\Core\Field\FieldStorageDefinitionListenerInterface
   */
  protected $fieldStorageDefinitionListener;

  /**
   * The last installed schema repository.
   *
   * @var \Drupal\Core\Entity\EntityLastInstalledSchemaRepositoryInterface
   */
  protected $entityLastInstalledSchemaRepository;

  /**
   * Constructs a new EntityDefinitionUpdateManager.
   *
   * @param \Drupal\Core\Entity\EntityTypeManagerInterface $entity_type_manager
   *   The entity type manager service.
   * @param \Drupal\Core\Entity\EntityLastInstalledSchemaRepositoryInterface $entity_last_installed_schema_repository
   *   The last installed schema repository service.
   * @param \Drupal\Core\Entity\EntityFieldManagerInterface $entity_field_manager
   *   The entity field manager service.
   * @param \Drupal\Core\Entity\EntityTypeListenerInterface $entity_type_listener
   *   The entity type listener interface.
   * @param \Drupal\Core\Field\FieldStorageDefinitionListenerInterface $field_storage_definition_listener
   *   The field storage definition listener service.
   */
  public function __construct(EntityTypeManagerInterface $entity_type_manager, EntityLastInstalledSchemaRepositoryInterface $entity_last_installed_schema_repository = NULL, EntityFieldManagerInterface $entity_field_manager = NULL, EntityTypeListenerInterface $entity_type_listener = NULL, FieldStorageDefinitionListenerInterface $field_storage_definition_listener = NULL) {
    if ($entity_type_manager instanceof EntityManagerInterface) {
      @trigger_error('Passing the entity.manager service to EntityDefinitionUpdateManager::__construct() is deprecated in Drupal 8.7.0 and will be removed before Drupal 9.0.0. Pass the new dependencies instead. See https://www.drupal.org/node/2549139.', E_USER_DEPRECATED);
      $this->entityTypeManager = \Drupal::entityTypeManager();
    }
    else {
      $this->entityTypeManager = $entity_type_manager;
    }
    if ($entity_last_installed_schema_repository) {
      $this->entityLastInstalledSchemaRepository = $entity_last_installed_schema_repository;
    }
    else {
      @trigger_error('The entity.last_installed_schema.repository service must be passed to EntityDefinitionUpdateManager::__construct(), it is required before Drupal 9.0.0. See https://www.drupal.org/node/2549139.', E_USER_DEPRECATED);
      $this->entityLastInstalledSchemaRepository = \Drupal::service('entity.last_installed_schema.repository');
    }
    if ($entity_field_manager) {
      $this->entityFieldManager = $entity_field_manager;
    }
    else {
      @trigger_error('The entity_field.manager service must be passed to EntityDefinitionUpdateManager::__construct(), it is required before Drupal 9.0.0. See https://www.drupal.org/node/2549139.', E_USER_DEPRECATED);
      $this->entityFieldManager = \Drupal::service('entity_field.manager');
    }
    if ($entity_type_listener) {
      $this->entityTypeListener = $entity_type_listener;
    }
    else {
      @trigger_error('The entity_type.listener service must be passed to EntityDefinitionUpdateManager::__construct(), it is required before Drupal 9.0.0. See https://www.drupal.org/node/2549139.', E_USER_DEPRECATED);
      $this->entityTypeListener = \Drupal::service('entity_type.listener');
    }
    if ($field_storage_definition_listener) {
      $this->fieldStorageDefinitionListener = $field_storage_definition_listener;
    }
    else {
      @trigger_error('The field_storage_definition.listener service must be passed to EntityDefinitionUpdateManager::__construct(), it is required before Drupal 9.0.0. See https://www.drupal.org/node/2549139.', E_USER_DEPRECATED);
      $this->fieldStorageDefinitionListener = \Drupal::service('field_storage_definition.listener');
    }
  }

  /**
   * {@inheritdoc}
   */
  public function needsUpdates() {
    return (bool) $this
      ->getChangeList();
  }

  /**
   * {@inheritdoc}
   */
  public function getChangeSummary() {
    $summary = [];
    foreach ($this
      ->getChangeList() as $entity_type_id => $change_list) {

      // Process entity type definition changes.
      if (!empty($change_list['entity_type'])) {
        $entity_type = $this->entityTypeManager
          ->getDefinition($entity_type_id);
        switch ($change_list['entity_type']) {
          case static::DEFINITION_CREATED:
            $summary[$entity_type_id][] = $this
              ->t('The %entity_type entity type needs to be installed.', [
              '%entity_type' => $entity_type
                ->getLabel(),
            ]);
            break;
          case static::DEFINITION_UPDATED:
            $summary[$entity_type_id][] = $this
              ->t('The %entity_type entity type needs to be updated.', [
              '%entity_type' => $entity_type
                ->getLabel(),
            ]);
            break;
        }
      }

      // Process field storage definition changes.
      if (!empty($change_list['field_storage_definitions'])) {
        $storage_definitions = $this->entityFieldManager
          ->getFieldStorageDefinitions($entity_type_id);
        $original_storage_definitions = $this->entityLastInstalledSchemaRepository
          ->getLastInstalledFieldStorageDefinitions($entity_type_id);
        foreach ($change_list['field_storage_definitions'] as $field_name => $change) {
          switch ($change) {
            case static::DEFINITION_CREATED:
              $summary[$entity_type_id][] = $this
                ->t('The %field_name field needs to be installed.', [
                '%field_name' => $storage_definitions[$field_name]
                  ->getLabel() ?: $field_name,
              ]);
              break;
            case static::DEFINITION_UPDATED:
              $summary[$entity_type_id][] = $this
                ->t('The %field_name field needs to be updated.', [
                '%field_name' => $storage_definitions[$field_name]
                  ->getLabel() ?: $field_name,
              ]);
              break;
            case static::DEFINITION_DELETED:
              $summary[$entity_type_id][] = $this
                ->t('The %field_name field needs to be uninstalled.', [
                '%field_name' => $original_storage_definitions[$field_name]
                  ->getLabel() ?: $field_name,
              ]);
              break;
          }
        }
      }
    }
    return $summary;
  }

  /**
   * {@inheritdoc}
   */
  public function applyUpdates() {
    trigger_error('EntityDefinitionUpdateManagerInterface::applyUpdates() is deprecated in 8.7.0 and will be removed before Drupal 9.0.0. Use \\Drupal\\Core\\Entity\\EntityDefinitionUpdateManagerInterface::getChangeList() and execute each entity type and field storage update manually instead. See https://www.drupal.org/node/3034742.', E_USER_DEPRECATED);
  }

  /**
   * {@inheritdoc}
   */
  public function getEntityType($entity_type_id) {
    $entity_type = $this->entityLastInstalledSchemaRepository
      ->getLastInstalledDefinition($entity_type_id);
    return $entity_type ? clone $entity_type : NULL;
  }

  /**
   * {@inheritdoc}
   */
  public function getEntityTypes() {
    return $this->entityLastInstalledSchemaRepository
      ->getLastInstalledDefinitions();
  }

  /**
   * {@inheritdoc}
   */
  public function installEntityType(EntityTypeInterface $entity_type) {
    $this
      ->clearCachedDefinitions();
    $this->entityTypeListener
      ->onEntityTypeCreate($entity_type);
  }

  /**
   * {@inheritdoc}
   */
  public function updateEntityType(EntityTypeInterface $entity_type) {
    $original = $this
      ->getEntityType($entity_type
      ->id());
    $this
      ->clearCachedDefinitions();
    $this->entityTypeListener
      ->onEntityTypeUpdate($entity_type, $original);
  }

  /**
   * {@inheritdoc}
   */
  public function uninstallEntityType(EntityTypeInterface $entity_type) {
    $this
      ->clearCachedDefinitions();
    $this->entityTypeListener
      ->onEntityTypeDelete($entity_type);
  }

  /**
   * {@inheritdoc}
   */
  public function installFieldableEntityType(EntityTypeInterface $entity_type, array $field_storage_definitions) {
    $this
      ->clearCachedDefinitions();
    foreach ($field_storage_definitions as $name => $field_storage_definition) {
      if ($field_storage_definition instanceof BaseFieldDefinition) {
        $field_storage_definition
          ->setName($name)
          ->setTargetEntityTypeId($entity_type
          ->id())
          ->setProvider($entity_type
          ->getProvider())
          ->setTargetBundle(NULL);
      }
    }
    $this->entityTypeListener
      ->onFieldableEntityTypeCreate($entity_type, $field_storage_definitions);
  }

  /**
   * {@inheritdoc}
   */
  public function updateFieldableEntityType(EntityTypeInterface $entity_type, array $field_storage_definitions, array &$sandbox = NULL) {
    $original = $this
      ->getEntityType($entity_type
      ->id());
    if ($this
      ->requiresEntityDataMigration($entity_type, $original) && $sandbox === NULL) {
      throw new \InvalidArgumentException('The entity schema update for the ' . $entity_type
        ->id() . ' entity type requires a data migration.');
    }
    $original_field_storage_definitions = $this->entityLastInstalledSchemaRepository
      ->getLastInstalledFieldStorageDefinitions($entity_type
      ->id());
    $this->entityTypeListener
      ->onFieldableEntityTypeUpdate($entity_type, $original, $field_storage_definitions, $original_field_storage_definitions, $sandbox);
    $this
      ->clearCachedDefinitions();
  }

  /**
   * {@inheritdoc}
   */
  public function installFieldStorageDefinition($name, $entity_type_id, $provider, FieldStorageDefinitionInterface $storage_definition) {

    // @todo Pass a mutable field definition interface when we have one. See
    //   https://www.drupal.org/node/2346329.
    if ($storage_definition instanceof BaseFieldDefinition) {
      $storage_definition
        ->setName($name)
        ->setTargetEntityTypeId($entity_type_id)
        ->setProvider($provider)
        ->setTargetBundle(NULL);
    }
    $this
      ->clearCachedDefinitions();
    $this->fieldStorageDefinitionListener
      ->onFieldStorageDefinitionCreate($storage_definition);
  }

  /**
   * {@inheritdoc}
   */
  public function getFieldStorageDefinition($name, $entity_type_id) {
    $storage_definitions = $this->entityLastInstalledSchemaRepository
      ->getLastInstalledFieldStorageDefinitions($entity_type_id);
    return isset($storage_definitions[$name]) ? clone $storage_definitions[$name] : NULL;
  }

  /**
   * {@inheritdoc}
   */
  public function updateFieldStorageDefinition(FieldStorageDefinitionInterface $storage_definition) {
    $original = $this
      ->getFieldStorageDefinition($storage_definition
      ->getName(), $storage_definition
      ->getTargetEntityTypeId());
    $this
      ->clearCachedDefinitions();
    $this->fieldStorageDefinitionListener
      ->onFieldStorageDefinitionUpdate($storage_definition, $original);
  }

  /**
   * {@inheritdoc}
   */
  public function uninstallFieldStorageDefinition(FieldStorageDefinitionInterface $storage_definition) {
    $this
      ->clearCachedDefinitions();
    $this->fieldStorageDefinitionListener
      ->onFieldStorageDefinitionDelete($storage_definition);
  }

  /**
   * {@inheritdoc}
   */
  public function getChangeList() {
    $this->entityTypeManager
      ->useCaches(FALSE);
    $this->entityFieldManager
      ->useCaches(FALSE);
    $change_list = [];
    foreach ($this->entityTypeManager
      ->getDefinitions() as $entity_type_id => $entity_type) {
      $original = $this->entityLastInstalledSchemaRepository
        ->getLastInstalledDefinition($entity_type_id);

      // @todo Support non-storage-schema-changing definition updates too:
      //   https://www.drupal.org/node/2336895.
      if (!$original) {
        $change_list[$entity_type_id]['entity_type'] = static::DEFINITION_CREATED;
      }
      else {
        if ($this
          ->requiresEntityStorageSchemaChanges($entity_type, $original)) {
          $change_list[$entity_type_id]['entity_type'] = static::DEFINITION_UPDATED;
        }
        if ($this->entityTypeManager
          ->getStorage($entity_type_id) instanceof DynamicallyFieldableEntityStorageInterface) {
          $field_changes = [];
          $storage_definitions = $this->entityFieldManager
            ->getFieldStorageDefinitions($entity_type_id);
          $original_storage_definitions = $this->entityLastInstalledSchemaRepository
            ->getLastInstalledFieldStorageDefinitions($entity_type_id);

          // Detect created field storage definitions.
          foreach (array_diff_key($storage_definitions, $original_storage_definitions) as $field_name => $storage_definition) {
            $field_changes[$field_name] = static::DEFINITION_CREATED;
          }

          // Detect deleted field storage definitions.
          foreach (array_diff_key($original_storage_definitions, $storage_definitions) as $field_name => $original_storage_definition) {
            $field_changes[$field_name] = static::DEFINITION_DELETED;
          }

          // Detect updated field storage definitions.
          foreach (array_intersect_key($storage_definitions, $original_storage_definitions) as $field_name => $storage_definition) {

            // @todo Support non-storage-schema-changing definition updates too:
            //   https://www.drupal.org/node/2336895. So long as we're checking
            //   based on schema change requirements rather than definition
            //   equality, skip the check if the entity type itself needs to be
            //   updated, since that can affect the schema of all fields, so we
            //   want to process that update first without reporting false
            //   positives here.
            if (!isset($change_list[$entity_type_id]['entity_type']) && $this
              ->requiresFieldStorageSchemaChanges($storage_definition, $original_storage_definitions[$field_name])) {
              $field_changes[$field_name] = static::DEFINITION_UPDATED;
            }
          }
          if ($field_changes) {
            $change_list[$entity_type_id]['field_storage_definitions'] = $field_changes;
          }
        }
      }
    }

    // @todo Support deleting entity definitions when we support base field
    //   purging.
    // @see https://www.drupal.org/node/2907779
    $this->entityTypeManager
      ->useCaches(TRUE);
    $this->entityFieldManager
      ->useCaches(TRUE);
    return array_filter($change_list);
  }

  /**
   * Checks if the changes to the entity type requires storage schema changes.
   *
   * @param \Drupal\Core\Entity\EntityTypeInterface $entity_type
   *   The updated entity type definition.
   * @param \Drupal\Core\Entity\EntityTypeInterface $original
   *   The original entity type definition.
   *
   * @return bool
   *   TRUE if storage schema changes are required, FALSE otherwise.
   */
  protected function requiresEntityStorageSchemaChanges(EntityTypeInterface $entity_type, EntityTypeInterface $original) {
    $storage = $this->entityTypeManager
      ->getStorage($entity_type
      ->id());
    return $storage instanceof EntityStorageSchemaInterface && $storage
      ->requiresEntityStorageSchemaChanges($entity_type, $original);
  }

  /**
   * Checks if the changes to the storage definition requires schema changes.
   *
   * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition
   *   The updated field storage definition.
   * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $original
   *   The original field storage definition.
   *
   * @return bool
   *   TRUE if storage schema changes are required, FALSE otherwise.
   */
  protected function requiresFieldStorageSchemaChanges(FieldStorageDefinitionInterface $storage_definition, FieldStorageDefinitionInterface $original) {
    $storage = $this->entityTypeManager
      ->getStorage($storage_definition
      ->getTargetEntityTypeId());
    return $storage instanceof DynamicallyFieldableEntityStorageSchemaInterface && $storage
      ->requiresFieldStorageSchemaChanges($storage_definition, $original);
  }

  /**
   * Checks if existing data would be lost if the schema changes were applied.
   *
   * @param \Drupal\Core\Entity\EntityTypeInterface $entity_type
   *   The updated entity type definition.
   * @param \Drupal\Core\Entity\EntityTypeInterface $original
   *   The original entity type definition.
   *
   * @return bool
   *   TRUE if data migration is required, FALSE otherwise.
   */
  protected function requiresEntityDataMigration(EntityTypeInterface $entity_type, EntityTypeInterface $original) {
    $storage = $this->entityTypeManager
      ->getStorage($entity_type
      ->id());
    return $storage instanceof EntityStorageSchemaInterface && $storage
      ->requiresEntityDataMigration($entity_type, $original);
  }

  /**
   * Clears necessary caches to apply entity/field definition updates.
   */
  protected function clearCachedDefinitions() {
    $this->entityTypeManager
      ->clearCachedDefinitions();
    $this->entityFieldManager
      ->clearCachedFieldDefinitions();
  }

}

Members

Namesort descending Modifiers Type Description Overrides
DeprecatedServicePropertyTrait::__get public function Allows to access deprecated/removed properties.
EntityDefinitionUpdateManager::$deprecatedProperties protected property
EntityDefinitionUpdateManager::$entityFieldManager protected property The entity field manager service.
EntityDefinitionUpdateManager::$entityLastInstalledSchemaRepository protected property The last installed schema repository.
EntityDefinitionUpdateManager::$entityTypeListener protected property The entity type listener service.
EntityDefinitionUpdateManager::$entityTypeManager protected property The entity type manager service.
EntityDefinitionUpdateManager::$fieldStorageDefinitionListener protected property The field storage definition listener service.
EntityDefinitionUpdateManager::applyUpdates public function Applies all the detected valid changes. Overrides EntityDefinitionUpdateManagerInterface::applyUpdates
EntityDefinitionUpdateManager::clearCachedDefinitions protected function Clears necessary caches to apply entity/field definition updates.
EntityDefinitionUpdateManager::getChangeList public function Gets a list of changes to entity type and field storage definitions. Overrides EntityDefinitionUpdateManagerInterface::getChangeList
EntityDefinitionUpdateManager::getChangeSummary public function Gets a human readable summary of the detected changes. Overrides EntityDefinitionUpdateManagerInterface::getChangeSummary
EntityDefinitionUpdateManager::getEntityType public function Returns an entity type definition ready to be manipulated. Overrides EntityDefinitionUpdateManagerInterface::getEntityType
EntityDefinitionUpdateManager::getEntityTypes public function Returns all the entity type definitions, ready to be manipulated. Overrides EntityDefinitionUpdateManagerInterface::getEntityTypes
EntityDefinitionUpdateManager::getFieldStorageDefinition public function Returns a field storage definition ready to be manipulated. Overrides EntityDefinitionUpdateManagerInterface::getFieldStorageDefinition
EntityDefinitionUpdateManager::installEntityType public function Installs a new entity type definition. Overrides EntityDefinitionUpdateManagerInterface::installEntityType
EntityDefinitionUpdateManager::installFieldableEntityType public function Installs a new fieldable entity type definition. Overrides EntityDefinitionUpdateManagerInterface::installFieldableEntityType
EntityDefinitionUpdateManager::installFieldStorageDefinition public function Installs a new field storage definition. Overrides EntityDefinitionUpdateManagerInterface::installFieldStorageDefinition
EntityDefinitionUpdateManager::needsUpdates public function Checks if there are any definition updates that need to be applied. Overrides EntityDefinitionUpdateManagerInterface::needsUpdates
EntityDefinitionUpdateManager::requiresEntityDataMigration protected function Checks if existing data would be lost if the schema changes were applied.
EntityDefinitionUpdateManager::requiresEntityStorageSchemaChanges protected function Checks if the changes to the entity type requires storage schema changes.
EntityDefinitionUpdateManager::requiresFieldStorageSchemaChanges protected function Checks if the changes to the storage definition requires schema changes.
EntityDefinitionUpdateManager::uninstallEntityType public function Uninstalls an entity type definition. Overrides EntityDefinitionUpdateManagerInterface::uninstallEntityType
EntityDefinitionUpdateManager::uninstallFieldStorageDefinition public function Uninstalls a field storage definition. Overrides EntityDefinitionUpdateManagerInterface::uninstallFieldStorageDefinition
EntityDefinitionUpdateManager::updateEntityType public function Applies any change performed to the passed entity type definition. Overrides EntityDefinitionUpdateManagerInterface::updateEntityType
EntityDefinitionUpdateManager::updateFieldableEntityType public function Applies any change performed to a fieldable entity type definition. Overrides EntityDefinitionUpdateManagerInterface::updateFieldableEntityType
EntityDefinitionUpdateManager::updateFieldStorageDefinition public function Applies any change performed to the passed field storage definition. Overrides EntityDefinitionUpdateManagerInterface::updateFieldStorageDefinition
EntityDefinitionUpdateManager::__construct public function Constructs a new EntityDefinitionUpdateManager.
EntityDefinitionUpdateManagerInterface::DEFINITION_CREATED constant Indicates that a definition has just been created.
EntityDefinitionUpdateManagerInterface::DEFINITION_DELETED constant Indicates that a definition has just been deleted.
EntityDefinitionUpdateManagerInterface::DEFINITION_UPDATED constant Indicates that a definition has changes.
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.