class EntityOperations in Drupal 10

Defines a class for reacting to entity events.

@internal

Hierarchy

• class \Drupal\content_moderation\EntityOperations implements ContainerInjectionInterface

1 file declares its use of EntityOperations

content_moderation.module in core/modules/content_moderation/content_moderation.module

Contains content_moderation.module.

File

core/modules/content_moderation/src/EntityOperations.php, line 25

Namespace

Drupal\content_moderation

class EntityOperations implements ContainerInjectionInterface {

  /**
   * The Moderation Information service.
   *
   * @var \Drupal\content_moderation\ModerationInformationInterface
   */
  protected $moderationInfo;

  /**
   * The Entity Type Manager service.
   *
   * @var \Drupal\Core\Entity\EntityTypeManagerInterface
   */
  protected $entityTypeManager;

  /**
   * The Form Builder service.
   *
   * @var \Drupal\Core\Form\FormBuilderInterface
   */
  protected $formBuilder;

  /**
   * The entity bundle information service.
   *
   * @var \Drupal\Core\Entity\EntityTypeBundleInfoInterface
   */
  protected $bundleInfo;

  /**
   * The router builder service.
   *
   * @var \Drupal\Core\Routing\RouteBuilderInterface
   */
  protected $routerBuilder;

  /**
   * Constructs a new EntityOperations object.
   *
   * @param \Drupal\content_moderation\ModerationInformationInterface $moderation_info
   *   Moderation information service.
   * @param \Drupal\Core\Entity\EntityTypeManagerInterface $entity_type_manager
   *   Entity type manager service.
   * @param \Drupal\Core\Form\FormBuilderInterface $form_builder
   *   The form builder.
   * @param \Drupal\Core\Entity\EntityTypeBundleInfoInterface $bundle_info
   *   The entity bundle information service.
   * @param \Drupal\Core\Routing\RouteBuilderInterface $router_builder
   *   The router builder service.
   */
  public function __construct(ModerationInformationInterface $moderation_info, EntityTypeManagerInterface $entity_type_manager, FormBuilderInterface $form_builder, EntityTypeBundleInfoInterface $bundle_info, RouteBuilderInterface $router_builder) {
    $this->moderationInfo = $moderation_info;
    $this->entityTypeManager = $entity_type_manager;
    $this->formBuilder = $form_builder;
    $this->bundleInfo = $bundle_info;
    $this->routerBuilder = $router_builder;
  }

  /**
   * {@inheritdoc}
   */
  public static function create(ContainerInterface $container) {
    return new static($container
      ->get('content_moderation.moderation_information'), $container
      ->get('entity_type.manager'), $container
      ->get('form_builder'), $container
      ->get('entity_type.bundle.info'), $container
      ->get('router.builder'));
  }

  /**
   * Acts on an entity and set published status based on the moderation state.
   *
   * @param \Drupal\Core\Entity\EntityInterface $entity
   *   The entity being saved.
   *
   * @see hook_entity_presave()
   */
  public function entityPresave(EntityInterface $entity) {
    if (!$this->moderationInfo
      ->isModeratedEntity($entity)) {
      return;
    }
    if ($entity->moderation_state->value) {
      $workflow = $this->moderationInfo
        ->getWorkflowForEntity($entity);

      /** @var \Drupal\content_moderation\ContentModerationState $current_state */
      $current_state = $workflow
        ->getTypePlugin()
        ->getState($entity->moderation_state->value);

      // This entity is default if it is new, the default revision, or the
      // default revision is not published.
      $update_default_revision = $entity
        ->isNew() || $current_state
        ->isDefaultRevisionState() || !$this->moderationInfo
        ->isDefaultRevisionPublished($entity);

      // Fire per-entity-type logic for handling the save process.
      $this->entityTypeManager
        ->getHandler($entity
        ->getEntityTypeId(), 'moderation')
        ->onPresave($entity, $update_default_revision, $current_state
        ->isPublishedState());
    }
  }

  /**
   * @param \Drupal\Core\Entity\EntityInterface $entity
   *   The entity that was just saved.
   *
   * @see hook_entity_insert()
   */
  public function entityInsert(EntityInterface $entity) {
    if ($this->moderationInfo
      ->isModeratedEntity($entity)) {
      $this
        ->updateOrCreateFromEntity($entity);
    }
  }

  /**
   * @param \Drupal\Core\Entity\EntityInterface $entity
   *   The entity that was just saved.
   *
   * @see hook_entity_update()
   */
  public function entityUpdate(EntityInterface $entity) {
    if ($this->moderationInfo
      ->isModeratedEntity($entity)) {
      $this
        ->updateOrCreateFromEntity($entity);
    }
    elseif ($entity instanceof Workflow && $entity
      ->getTypePlugin()
      ->getPluginId() == 'content_moderation') {
      $this->routerBuilder
        ->setRebuildNeeded();
    }
  }

  /**
   * Creates or updates the moderation state of an entity.
   *
   * @param \Drupal\Core\Entity\EntityInterface $entity
   *   The entity to update or create a moderation state for.
   */
  protected function updateOrCreateFromEntity(EntityInterface $entity) {

    /** @var \Drupal\Core\Entity\ContentEntityInterface $entity */
    $entity_revision_id = $entity
      ->getRevisionId();
    $workflow = $this->moderationInfo
      ->getWorkflowForEntity($entity);
    $content_moderation_state = ContentModerationStateEntity::loadFromModeratedEntity($entity);

    /** @var \Drupal\Core\Entity\ContentEntityStorageInterface $storage */
    $storage = $this->entityTypeManager
      ->getStorage('content_moderation_state');
    if (!$content_moderation_state instanceof ContentModerationStateInterface) {
      $content_moderation_state = $storage
        ->create([
        'content_entity_type_id' => $entity
          ->getEntityTypeId(),
        'content_entity_id' => $entity
          ->id(),
        // Make sure that the moderation state entity has the same language code
        // as the moderated entity.
        'langcode' => $entity
          ->language()
          ->getId(),
      ]);
      $content_moderation_state->workflow->target_id = $workflow
        ->id();
    }

    // Sync translations.
    if ($entity
      ->getEntityType()
      ->hasKey('langcode')) {
      $entity_langcode = $entity
        ->language()
        ->getId();
      if ($entity
        ->isDefaultTranslation()) {
        $content_moderation_state->langcode = $entity_langcode;
      }
      else {
        if (!$content_moderation_state
          ->hasTranslation($entity_langcode)) {
          $content_moderation_state
            ->addTranslation($entity_langcode);
        }
        if ($content_moderation_state
          ->language()
          ->getId() !== $entity_langcode) {
          $content_moderation_state = $content_moderation_state
            ->getTranslation($entity_langcode);
        }
      }
    }

    // If a new revision of the content has been created, add a new content
    // moderation state revision.
    if (!$content_moderation_state
      ->isNew() && $content_moderation_state->content_entity_revision_id->value != $entity_revision_id) {
      $content_moderation_state = $storage
        ->createRevision($content_moderation_state, $entity
        ->isDefaultRevision());
    }

    // Create the ContentModerationState entity for the inserted entity.
    $moderation_state = $entity->moderation_state->value;

    /** @var \Drupal\Core\Entity\ContentEntityInterface $entity */
    if (!$moderation_state) {
      $moderation_state = $workflow
        ->getTypePlugin()
        ->getInitialState($entity)
        ->id();
    }
    $content_moderation_state
      ->set('content_entity_revision_id', $entity_revision_id);
    $content_moderation_state
      ->set('moderation_state', $moderation_state);
    ContentModerationStateEntity::updateOrCreateFromEntity($content_moderation_state);
  }

  /**
   * @param \Drupal\Core\Entity\EntityInterface $entity
   *   The entity being deleted.
   *
   * @see hook_entity_delete()
   */
  public function entityDelete(EntityInterface $entity) {
    $content_moderation_state = ContentModerationStateEntity::loadFromModeratedEntity($entity);
    if ($content_moderation_state) {
      $content_moderation_state
        ->delete();
    }
  }

  /**
   * @param \Drupal\Core\Entity\EntityInterface $entity
   *   The entity revision being deleted.
   *
   * @see hook_entity_revision_delete()
   */
  public function entityRevisionDelete(EntityInterface $entity) {
    if ($content_moderation_state = ContentModerationStateEntity::loadFromModeratedEntity($entity)) {
      if ($content_moderation_state
        ->isDefaultRevision()) {
        $content_moderation_state
          ->delete();
      }
      else {
        $this->entityTypeManager
          ->getStorage('content_moderation_state')
          ->deleteRevision($content_moderation_state
          ->getRevisionId());
      }
    }
  }

  /**
   * @param \Drupal\Core\Entity\EntityInterface $translation
   *   The entity translation being deleted.
   *
   * @see hook_entity_translation_delete()
   */
  public function entityTranslationDelete(EntityInterface $translation) {

    /** @var \Drupal\Core\Entity\ContentEntityInterface $translation */
    if (!$translation
      ->isDefaultTranslation()) {
      $langcode = $translation
        ->language()
        ->getId();
      $content_moderation_state = ContentModerationStateEntity::loadFromModeratedEntity($translation);
      if ($content_moderation_state && $content_moderation_state
        ->hasTranslation($langcode)) {
        $content_moderation_state
          ->removeTranslation($langcode);
        ContentModerationStateEntity::updateOrCreateFromEntity($content_moderation_state);
      }
    }
  }

  /**
   * Act on entities being assembled before rendering.
   *
   * @see hook_entity_view()
   * @see EntityFieldManagerInterface::getExtraFields()
   */
  public function entityView(array &$build, EntityInterface $entity, EntityViewDisplayInterface $display, $view_mode) {

    /** @var \Drupal\Core\Entity\ContentEntityInterface $entity */
    if (!$this->moderationInfo
      ->isModeratedEntity($entity)) {
      return;
    }
    if (isset($entity->in_preview) && $entity->in_preview) {
      return;
    }

    // If the component is not defined for this display, we have nothing to do.
    if (!$display
      ->getComponent('content_moderation_control')) {
      return;
    }

    // The moderation form should be displayed only when viewing the latest
    // (translation-affecting) revision, unless it was created as published
    // default revision.
    if (($entity
      ->isDefaultRevision() || $entity
      ->wasDefaultRevision()) && $this
      ->isPublished($entity)) {
      return;
    }
    if (!$entity
      ->isLatestRevision() && !$entity
      ->isLatestTranslationAffectedRevision()) {
      return;
    }
    $build['content_moderation_control'] = $this->formBuilder
      ->getForm(EntityModerationForm::class, $entity);
  }

  /**
   * Checks if the entity is published.
   *
   * This method is optimized to not have to unnecessarily load the moderation
   * state and workflow if it is not required.
   *
   * @param \Drupal\Core\Entity\ContentEntityInterface $entity
   *   The entity to check.
   *
   * @return bool
   *   TRUE if the entity is published, FALSE otherwise.
   */
  protected function isPublished(ContentEntityInterface $entity) {

    // If the entity implements EntityPublishedInterface directly, check that
    // first, otherwise fall back to check through the workflow state.
    if ($entity instanceof EntityPublishedInterface) {
      return $entity
        ->isPublished();
    }
    if ($moderation_state = $entity
      ->get('moderation_state')->value) {
      $workflow = $this->moderationInfo
        ->getWorkflowForEntity($entity);
      return $workflow
        ->getTypePlugin()
        ->getState($moderation_state)
        ->isPublishedState();
    }
    return FALSE;
  }

}