class EntityOperations in Drupal 8

Defines a class for reacting to entity events.

@internal

Hierarchy

• class \Drupal\workspaces\EntityOperations implements ContainerInjectionInterface uses StringTranslationTrait

1 file declares its use of EntityOperations

workspaces.module in core/modules/workspaces/workspaces.module

Provides full-site preview functionality for content staging.

File

core/modules/workspaces/src/EntityOperations.php, line 20

Namespace

Drupal\workspaces

class EntityOperations implements ContainerInjectionInterface {
  use StringTranslationTrait;

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

  /**
   * The workspace manager service.
   *
   * @var \Drupal\workspaces\WorkspaceManagerInterface
   */
  protected $workspaceManager;

  /**
   * The workspace association service.
   *
   * @var \Drupal\workspaces\WorkspaceAssociationInterface
   */
  protected $workspaceAssociation;

  /**
   * Constructs a new EntityOperations instance.
   *
   * @param \Drupal\Core\Entity\EntityTypeManagerInterface $entity_type_manager
   *   The entity type manager service.
   * @param \Drupal\workspaces\WorkspaceManagerInterface $workspace_manager
   *   The workspace manager service.
   * @param \Drupal\workspaces\WorkspaceAssociationInterface $workspace_association
   *   The workspace association service.
   */
  public function __construct(EntityTypeManagerInterface $entity_type_manager, WorkspaceManagerInterface $workspace_manager, WorkspaceAssociationInterface $workspace_association) {
    $this->entityTypeManager = $entity_type_manager;
    $this->workspaceManager = $workspace_manager;
    $this->workspaceAssociation = $workspace_association;
  }

  /**
   * {@inheritdoc}
   */
  public static function create(ContainerInterface $container) {
    return new static($container
      ->get('entity_type.manager'), $container
      ->get('workspaces.manager'), $container
      ->get('workspaces.association'));
  }

  /**
   * Acts on entity IDs before they are loaded.
   *
   * @see hook_entity_preload()
   */
  public function entityPreload(array $ids, $entity_type_id) {
    $entities = [];

    // Only run if the entity type can belong to a workspace and we are in a
    // non-default workspace.
    if (!$this->workspaceManager
      ->shouldAlterOperations($this->entityTypeManager
      ->getDefinition($entity_type_id))) {
      return $entities;
    }

    // Get a list of revision IDs for entities that have a revision set for the
    // current active workspace. If an entity has multiple revisions set for a
    // workspace, only the one with the highest ID is returned.
    if ($tracked_entities = $this->workspaceAssociation
      ->getTrackedEntities($this->workspaceManager
      ->getActiveWorkspace()
      ->id(), $entity_type_id, $ids)) {

      /** @var \Drupal\Core\Entity\RevisionableStorageInterface $storage */
      $storage = $this->entityTypeManager
        ->getStorage($entity_type_id);

      // Swap out every entity which has a revision set for the current active
      // workspace.
      foreach ($storage
        ->loadMultipleRevisions(array_keys($tracked_entities[$entity_type_id])) as $revision) {
        $entities[$revision
          ->id()] = $revision;
      }
    }
    return $entities;
  }

  /**
   * Acts on an entity before it is created or updated.
   *
   * @param \Drupal\Core\Entity\EntityInterface $entity
   *   The entity being saved.
   *
   * @see hook_entity_presave()
   */
  public function entityPresave(EntityInterface $entity) {
    $entity_type = $entity
      ->getEntityType();

    // Only run if we are not dealing with an entity type provided by the
    // Workspaces module, an internal entity type or if we are in a non-default
    // workspace.
    if ($this
      ->shouldSkipPreOperations($entity_type)) {
      return;
    }

    // Disallow any change to an unsupported entity when we are not in the
    // default workspace.
    if (!$this->workspaceManager
      ->isEntityTypeSupported($entity_type)) {
      throw new \RuntimeException('This entity can only be saved in the default workspace.');
    }

    /** @var \Drupal\Core\Entity\ContentEntityInterface|\Drupal\Core\Entity\EntityPublishedInterface $entity */
    if (!$entity
      ->isNew() && !$entity
      ->isSyncing()) {

      // Force a new revision if the entity is not replicating.
      $entity
        ->setNewRevision(TRUE);

      // All entities in the non-default workspace are pending revisions,
      // regardless of their publishing status. This means that when creating
      // a published pending revision in a non-default workspace it will also be
      // a published pending revision in the default workspace, however, it will
      // become the default revision only when it is replicated to the default
      // workspace.
      $entity
        ->isDefaultRevision(FALSE);

      // Track the workspaces in which the new revision was saved.
      $field_name = $entity_type
        ->getRevisionMetadataKey('workspace');
      $entity->{$field_name}->target_id = $this->workspaceManager
        ->getActiveWorkspace()
        ->id();
    }

    // When a new published entity is inserted in a non-default workspace, we
    // actually want two revisions to be saved:
    // - An unpublished default revision in the default ('live') workspace.
    // - A published pending revision in the current workspace.
    if ($entity
      ->isNew() && $entity
      ->isPublished()) {

      // Keep track of the publishing status in a dynamic property for
      // ::entityInsert(), then unpublish the default revision.
      // @todo Remove this dynamic property once we have an API for associating
      //   temporary data with an entity: https://www.drupal.org/node/2896474.
      $entity->_initialPublished = TRUE;
      $entity
        ->setUnpublished();
    }
  }

  /**
   * Responds to the creation of a new entity.
   *
   * @param \Drupal\Core\Entity\EntityInterface $entity
   *   The entity that was just saved.
   *
   * @see hook_entity_insert()
   */
  public function entityInsert(EntityInterface $entity) {

    /** @var \Drupal\Core\Entity\RevisionableInterface|\Drupal\Core\Entity\EntityPublishedInterface $entity */

    // Only run if the entity type can belong to a workspace and we are in a
    // non-default workspace.
    if (!$this->workspaceManager
      ->shouldAlterOperations($entity
      ->getEntityType())) {
      return;
    }
    $this->workspaceAssociation
      ->trackEntity($entity, $this->workspaceManager
      ->getActiveWorkspace());

    // When an entity is newly created in a workspace, it should be published in
    // that workspace, but not yet published on the live workspace. It is first
    // saved as unpublished for the default revision, then immediately a second
    // revision is created which is published and attached to the workspace.
    // This ensures that the published version of the entity does not 'leak'
    // into the live site. This differs from edits to existing entities where
    // there is already a valid default revision for the live workspace.
    if (isset($entity->_initialPublished)) {

      // Operate on a clone to avoid changing the entity prior to subsequent
      // hook_entity_insert() implementations.
      $pending_revision = clone $entity;
      $pending_revision
        ->setPublished();
      $pending_revision
        ->isDefaultRevision(FALSE);
      $pending_revision
        ->save();
    }
  }

  /**
   * Responds to updates to an entity.
   *
   * @param \Drupal\Core\Entity\EntityInterface $entity
   *   The entity that was just saved.
   *
   * @see hook_entity_update()
   */
  public function entityUpdate(EntityInterface $entity) {

    // Only run if the entity type can belong to a workspace and we are in a
    // non-default workspace.
    if (!$this->workspaceManager
      ->shouldAlterOperations($entity
      ->getEntityType())) {
      return;
    }

    // Only track new revisions.

    /** @var \Drupal\Core\Entity\RevisionableInterface $entity */
    if ($entity
      ->getLoadedRevisionId() != $entity
      ->getRevisionId()) {
      $this->workspaceAssociation
        ->trackEntity($entity, $this->workspaceManager
        ->getActiveWorkspace());
    }
  }

  /**
   * Acts on an entity before it is deleted.
   *
   * @param \Drupal\Core\Entity\EntityInterface $entity
   *   The entity being deleted.
   *
   * @see hook_entity_predelete()
   */
  public function entityPredelete(EntityInterface $entity) {
    $entity_type = $entity
      ->getEntityType();

    // Only run if we are not dealing with an entity type provided by the
    // Workspaces module, an internal entity type or if we are in a non-default
    // workspace.
    if ($this
      ->shouldSkipPreOperations($entity_type)) {
      return;
    }

    // Disallow any change to an unsupported entity when we are not in the
    // default workspace.
    if (!$this->workspaceManager
      ->isEntityTypeSupported($entity_type)) {
      throw new \RuntimeException('This entity can only be deleted in the default workspace.');
    }
  }

  /**
   * Alters entity forms to disallow concurrent editing in multiple workspaces.
   *
   * @param array $form
   *   An associative array containing the structure of the form.
   * @param \Drupal\Core\Form\FormStateInterface $form_state
   *   The current state of the form.
   * @param string $form_id
   *   The form ID.
   *
   * @see hook_form_alter()
   */
  public function entityFormAlter(array &$form, FormStateInterface $form_state, $form_id) {

    /** @var \Drupal\Core\Entity\RevisionableInterface $entity */
    $entity = $form_state
      ->getFormObject()
      ->getEntity();
    if (!$this->workspaceManager
      ->isEntityTypeSupported($entity
      ->getEntityType())) {
      return;
    }

    // For supported entity types, signal the fact that this form is safe to use
    // in a non-default workspace.
    // @see \Drupal\workspaces\FormOperations::validateForm()
    $form_state
      ->set('workspace_safe', TRUE);

    // Add an entity builder to the form which marks the edited entity object as
    // a pending revision. This is needed so validation constraints like
    // \Drupal\path\Plugin\Validation\Constraint\PathAliasConstraintValidator
    // know in advance (before hook_entity_presave()) that the new revision will
    // be a pending one.
    if ($this->workspaceManager
      ->hasActiveWorkspace()) {
      $form['#entity_builders'][] = [
        get_called_class(),
        'entityFormEntityBuild',
      ];
    }

    // Run the workspace conflict validation constraint when the entity form is
    // being built so we can "disable" it early and display a message to the
    // user, instead of allowing them to enter data that can never be saved.
    foreach ($entity
      ->validate()
      ->getEntityViolations() as $violation) {
      if ($violation
        ->getConstraint() instanceof EntityWorkspaceConflictConstraint) {
        $form['#markup'] = $violation
          ->getMessage();
        $form['#access'] = FALSE;
        continue;
      }
    }
  }

  /**
   * Entity builder that marks all supported entities as pending revisions.
   */
  public static function entityFormEntityBuild($entity_type_id, RevisionableInterface $entity, &$form, FormStateInterface &$form_state) {

    // Set the non-default revision flag so that validation constraints are also
    // aware that a pending revision is about to be created.
    $entity
      ->isDefaultRevision(FALSE);
  }

  /**
   * Determines whether we need to react on pre-save or pre-delete operations.
   *
   * @param \Drupal\Core\Entity\EntityTypeInterface $entity_type
   *   The entity type to check.
   *
   * @return bool
   *   Returns TRUE if the pre-save or pre-delete entity operations should not
   *   be altered in the current request, FALSE otherwise.
   */
  protected function shouldSkipPreOperations(EntityTypeInterface $entity_type) {

    // We should not react on pre-save and pre-delete entity operations if one
    // of the following conditions are met:
    // - the entity type is provided by the Workspaces module;
    // - the entity type is internal, which means that it should not affect
    //   anything in the default (Live) workspace;
    // - we are in the default workspace.
    return $entity_type
      ->getProvider() === 'workspaces' || $entity_type
      ->isInternal() || !$this->workspaceManager
      ->hasActiveWorkspace();
  }

}

Members

Name	Modifiers	Type	Description	Overrides
EntityOperations::$entityTypeManager	protected	property	The entity type manager service.
EntityOperations::$workspaceAssociation	protected	property	The workspace association service.
EntityOperations::$workspaceManager	protected	property	The workspace manager service.
EntityOperations::create	public static	function	Instantiates a new instance of this class. Overrides ContainerInjectionInterface::create
EntityOperations::entityFormAlter	public	function	Alters entity forms to disallow concurrent editing in multiple workspaces.
EntityOperations::entityFormEntityBuild	public static	function	Entity builder that marks all supported entities as pending revisions.
EntityOperations::entityInsert	public	function	Responds to the creation of a new entity.
EntityOperations::entityPredelete	public	function	Acts on an entity before it is deleted.
EntityOperations::entityPreload	public	function	Acts on entity IDs before they are loaded.
EntityOperations::entityPresave	public	function	Acts on an entity before it is created or updated.
EntityOperations::entityUpdate	public	function	Responds to updates to an entity.
EntityOperations::shouldSkipPreOperations	protected	function	Determines whether we need to react on pre-save or pre-delete operations.
EntityOperations::__construct	public	function	Constructs a new EntityOperations instance.
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.