NodeEntityHooks.php

<?php

declare (strict_types=1);
namespace Drupal\node\Hook;

use Drupal\Core\Access\AccessResultInterface;
use Drupal\Core\StringTranslation\StringTranslationTrait;
use Drupal\language\ConfigurableLanguageInterface;
use Drupal\Core\Access\AccessResult;
use Drupal\Core\Session\AccountInterface;
use Drupal\node\NodeInterface;
use Drupal\Core\Entity\Display\EntityViewDisplayInterface;
use Drupal\node\Entity\NodeType;
use Drupal\Core\Hook\Attribute\Hook;

/**
 * Entity hook implementations for node.
 */
class NodeEntityHooks {
  use StringTranslationTrait;
  
  /**
   * Implements hook_entity_view_display_alter().
   */
  public function entityViewDisplayAlter(EntityViewDisplayInterface $display, $context) : void {
    if ($context['entity_type'] == 'node') {
      // Hide field labels in search index.
      if ($context['view_mode'] == 'search_index') {
        foreach ($display->getComponents() as $name => $options) {
          if (isset($options['label'])) {
            $options['label'] = 'hidden';
            $display->setComponent($name, $options);
          }
        }
      }
    }
  }
  
  /**
   * Implements hook_entity_extra_field_info().
   */
  public function entityExtraFieldInfo() : array {
    $extra = [];
    $description = $this->t('Node module element');
    foreach (NodeType::loadMultiple() as $bundle) {
      $extra['node'][$bundle->id()]['display']['links'] = [
        'label' => $this->t('Links'),
        'description' => $description,
        'weight' => 100,
        'visible' => TRUE,
      ];
    }
    return $extra;
  }
  
  /**
   * Implements hook_ENTITY_TYPE_predelete() for user entities.
   */
  public function userPredelete($account) : void {
    // Delete nodes (current revisions).
    // @todo Introduce node_mass_delete() or make NodeBulkUpdate::process() more flexible.
    $nids = \Drupal::entityQuery('node')->condition('uid', $account->id())
      ->accessCheck(FALSE)
      ->execute();
    // Delete old revisions.
    $storage_controller = \Drupal::entityTypeManager()->getStorage('node');
    $nodes = $storage_controller->loadMultiple($nids);
    $storage_controller->delete($nodes);
    $revisions = $storage_controller->userRevisionIds($account);
    foreach ($revisions as $revision) {
      $storage_controller->deleteRevision($revision);
    }
  }
  
  /**
   * @defgroup node_access Node access rights
   * @{
   * The node access system determines who can do what to which nodes.
   *
   * In determining access rights for an existing node,
   * \Drupal\node\NodeAccessControlHandler first checks whether the user has the
   * "bypass node access" permission. Such users have unrestricted access to all
   * nodes. user 1 will always pass this check.
   *
   * Next, all implementations of hook_ENTITY_TYPE_access() for node will be
   * called. Each implementation may explicitly allow, explicitly forbid, or
   * ignore the access request. If at least one module says to forbid the
   * request, it will be rejected. If no modules deny the request and at least
   * one says to allow it, the request will be permitted.
   *
   * If all modules ignore the access request, then the node_access table is
   * used to determine access. All node access modules are queried using
   * hook_node_grants() to assemble a list of "grant IDs" for the user. This
   * list is compared against the table. If any row contains the node ID in
   * question (or 0, which stands for "all nodes"), one of the grant IDs
   * returned, and a value of TRUE for the operation in question, then access is
   * granted. Note that this table is a list of grants; any matching row is
   * sufficient to grant access to the node.
   *
   * In node listings (lists of nodes generated from a select query, such as the
   * default home page at path 'node', an RSS feed, a recent content block,
   * etc.), the process above is followed except that hook_ENTITY_TYPE_access()
   * is not called on each node for performance reasons and for proper
   * functioning of the pager system. When adding a node listing to your module,
   * be sure to use an entity query, which will add a tag of "node_access". This
   * will allow modules dealing with node access to ensure only nodes to which
   * the user has access are retrieved, through the use of
   * hook_query_TAG_alter(). See the @link entity_api Entity API topic @endlink
   * for more information on entity queries. Tagging a query with "node_access"
   * does not check the published/unpublished status of nodes, so the base query
   * is responsible for ensuring that unpublished nodes are not displayed to
   * inappropriate users.
   *
   * Note: Even a single module returning an AccessResultInterface object from
   * hook_ENTITY_TYPE_access() whose isForbidden() method equals TRUE will block
   * access to the node. Therefore, implementers should take care to not deny
   * access unless they really intend to. Unless a module wishes to actively
   * forbid access it should return an AccessResultInterface object whose
   * isAllowed() nor isForbidden() methods return TRUE, to allow other modules
   * or the node_access table to control access.
   *
   * Note also that access to create nodes is handled by
   * hook_ENTITY_TYPE_create_access().
   *
   * @see \Drupal\node\NodeAccessControlHandler
   */
  
  /**
   * Implements hook_ENTITY_TYPE_access().
   */
  public function nodeAccess(NodeInterface $node, $operation, AccountInterface $account) : AccessResultInterface {
    $type = $node->bundle();
    // Note create access is handled by hook_ENTITY_TYPE_create_access().
    switch ($operation) {
      case 'update':
        $access = AccessResult::allowedIfHasPermission($account, 'edit any ' . $type . ' content');
        if (!$access->isAllowed() && $account->hasPermission('edit own ' . $type . ' content')) {
          $access = $access->orIf(AccessResult::allowedIf($account->id() == $node->getOwnerId())
            ->cachePerUser()
            ->addCacheableDependency($node));
        }
        break;

      case 'delete':
        $access = AccessResult::allowedIfHasPermission($account, 'delete any ' . $type . ' content');
        if (!$access->isAllowed() && $account->hasPermission('delete own ' . $type . ' content')) {
          $access = $access->orIf(AccessResult::allowedIf($account->id() == $node->getOwnerId()))
            ->cachePerUser()
            ->addCacheableDependency($node);
        }
        break;

      default:
        $access = AccessResult::neutral();
    }
    return $access;
  }
  
  /**
   * Implements hook_ENTITY_TYPE_delete() for 'configurable_language'.
   */
  public function configurableLanguageDelete(ConfigurableLanguageInterface $language) : void {
    // On nodes with this language, unset the language.
    \Drupal::entityTypeManager()->getStorage('node')
      ->clearRevisionsLanguage($language);
  }

}