Skip to content
Snippets Groups Projects
Select Git revision
  • 4831e2ee7c9185a6f00b418ea4d88f8cf32f80b0
  • 11.x default protected
  • 11.2.x protected
  • 10.6.x protected
  • 10.5.x protected
  • 11.1.x protected
  • 10.4.x protected
  • 11.0.x protected
  • 10.3.x protected
  • 7.x protected
  • 10.2.x protected
  • 10.1.x protected
  • 9.5.x protected
  • 10.0.x protected
  • 9.4.x protected
  • 9.3.x protected
  • 9.2.x protected
  • 9.1.x protected
  • 8.9.x protected
  • 9.0.x protected
  • 8.8.x protected
  • 10.5.1 protected
  • 11.2.2 protected
  • 11.2.1 protected
  • 11.2.0 protected
  • 10.5.0 protected
  • 11.2.0-rc2 protected
  • 10.5.0-rc1 protected
  • 11.2.0-rc1 protected
  • 10.4.8 protected
  • 11.1.8 protected
  • 10.5.0-beta1 protected
  • 11.2.0-beta1 protected
  • 11.2.0-alpha1 protected
  • 10.4.7 protected
  • 11.1.7 protected
  • 10.4.6 protected
  • 11.1.6 protected
  • 10.3.14 protected
  • 10.4.5 protected
  • 11.0.13 protected
41 results

Node.php

Blame
  • Alex Pott's avatar
    Issue #2226267 by fago, xjm, Berdir: Improve default value handling of fields to be consistent.
    Alex Pott authored
    4831e2ee
    History
    Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    Node.php 13.15 KiB
    <?php
    
    /**
     * @file
     * Contains \Drupal\node\Entity\Node.
     */
    
    namespace Drupal\node\Entity;
    
    use Drupal\Core\Entity\ContentEntityBase;
    use Drupal\Core\Entity\EntityStorageInterface;
    use Drupal\Core\Entity\EntityTypeInterface;
    use Drupal\Core\Field\FieldDefinition;
    use Drupal\Core\Language\LanguageInterface;
    use Drupal\Core\Session\AccountInterface;
    use Drupal\node\NodeInterface;
    use Drupal\user\UserInterface;
    
    /**
     * Defines the node entity class.
     *
     * @ContentEntityType(
     *   id = "node",
     *   label = @Translation("Content"),
     *   bundle_label = @Translation("Content type"),
     *   controllers = {
     *     "storage" = "Drupal\node\NodeStorage",
     *     "view_builder" = "Drupal\node\NodeViewBuilder",
     *     "access" = "Drupal\node\NodeAccessController",
     *     "form" = {
     *       "default" = "Drupal\node\NodeForm",
     *       "delete" = "Drupal\node\Form\NodeDeleteForm",
     *       "edit" = "Drupal\node\NodeForm"
     *     },
     *     "list_builder" = "Drupal\node\NodeListBuilder",
     *     "translation" = "Drupal\node\NodeTranslationHandler"
     *   },
     *   base_table = "node",
     *   data_table = "node_field_data",
     *   revision_table = "node_revision",
     *   revision_data_table = "node_field_revision",
     *   uri_callback = "node_uri",
     *   fieldable = TRUE,
     *   translatable = TRUE,
     *   entity_keys = {
     *     "id" = "nid",
     *     "revision" = "vid",
     *     "bundle" = "type",
     *     "label" = "title",
     *     "uuid" = "uuid"
     *   },
     *   bundle_entity_type = "node_type",
     *   permission_granularity = "bundle",
     *   links = {
     *     "canonical" = "node.view",
     *     "delete-form" = "node.delete_confirm",
     *     "edit-form" = "node.page_edit",
     *     "version-history" = "node.revision_overview",
     *     "admin-form" = "node.type_edit"
     *   }
     * )
     */
    class Node extends ContentEntityBase implements NodeInterface {
    
      /**
       * {@inheritdoc}
       */
      public function preSave(EntityStorageInterface $storage) {
        parent::preSave($storage);
    
        // If no owner has been set explicitly, make the current user the owner.
        if (!$this->getOwner()) {
          $this->setOwnerId(\Drupal::currentUser()->id());
        }
        // If no revision author has been set explicitly, make the node owner the
        // revision author.
        if (!$this->getRevisionAuthor()) {
          $this->setRevisionAuthorId($this->getOwnerId());
        }
      }
    
      /**
       * {@inheritdoc}
       */
      public function preSaveRevision(EntityStorageInterface $storage, \stdClass $record) {
        parent::preSaveRevision($storage, $record);
    
        if (!$this->isNewRevision() && isset($this->original) && (!isset($record->revision_log) || $record->revision_log === '')) {
          // If we are updating an existing node without adding a new revision, we
          // need to make sure $entity->revision_log is reset whenever it is empty.
          // Therefore, this code allows us to avoid clobbering an existing log
          // entry with an empty one.
          $record->revision_log = $this->original->revision_log->value;
        }
      }
    
      /**
       * {@inheritdoc}
       */
      public function postSave(EntityStorageInterface $storage, $update = TRUE) {
        parent::postSave($storage, $update);
    
        // Update the node access table for this node, but only if it is the
        // default revision. There's no need to delete existing records if the node
        // is new.
        if ($this->isDefaultRevision()) {
          \Drupal::entityManager()->getAccessController('node')->writeGrants($this, $update);
        }
    
        // Reindex the node when it is updated. The node is automatically indexed
        // when it is added, simply by being added to the node table.
        if ($update) {
          node_reindex_node_search($this->id());
        }
      }
    
      /**
       * {@inheritdoc}
       */
      public static function preDelete(EntityStorageInterface $storage, array $entities) {
        parent::preDelete($storage, $entities);
    
        // Assure that all nodes deleted are removed from the search index.
        if (\Drupal::moduleHandler()->moduleExists('search')) {
          foreach ($entities as $entity) {
            search_reindex($entity->nid->value, 'node_search');
          }
        }
      }
    
      /**
       * {@inheritdoc}
       */
      public static function postDelete(EntityStorageInterface $storage, array $nodes) {
        parent::postDelete($storage, $nodes);
        \Drupal::service('node.grant_storage')->deleteNodeRecords(array_keys($nodes));
      }
    
      /**
       * {@inheritdoc}
       */
      public function getType() {
        return $this->bundle();
      }
    
      /**
       * {@inheritdoc}
       */
      public function access($operation = 'view', AccountInterface $account = NULL) {
        if ($operation == 'create') {
          return parent::access($operation, $account);
        }
    
        return \Drupal::entityManager()
          ->getAccessController($this->entityTypeId)
          ->access($this, $operation, $this->prepareLangcode(), $account);
      }
    
      /**
       * {@inheritdoc}
       */
      public function prepareLangcode() {
        $langcode = $this->language()->id;
        // If the Language module is enabled, try to use the language from content
        // negotiation.
        if (\Drupal::moduleHandler()->moduleExists('language')) {
          // Load languages the node exists in.
          $node_translations = $this->getTranslationLanguages();
          // Load the language from content negotiation.
          $content_negotiation_langcode = \Drupal::languageManager()->getCurrentLanguage(LanguageInterface::TYPE_CONTENT)->id;
          // If there is a translation available, use it.
          if (isset($node_translations[$content_negotiation_langcode])) {
            $langcode = $content_negotiation_langcode;
          }
        }
        return $langcode;
      }
    
    
      /**
       * {@inheritdoc}
       */
      public function getTitle() {
        return $this->get('title')->value;
      }
    
      /**
       * {@inheritdoc}
       */
      public function setTitle($title) {
        $this->set('title', $title);
        return $this;
      }
    
      /**
       * {@inheritdoc}
       */
      public function getCreatedTime() {
        return $this->get('created')->value;
      }
    
    
      /**
       * {@inheritdoc}
       */
      public function setCreatedTime($timestamp) {
        $this->set('created', $timestamp);
        return $this;
      }
    
      /**
       * {@inheritdoc}
       */
      public function getChangedTime() {
        return $this->get('changed')->value;
      }
    
      /**
       * {@inheritdoc}
       */
      public function isPromoted() {
        return (bool) $this->get('promote')->value;
      }
    
      /**
       * {@inheritdoc}
       */
      public function setPromoted($promoted) {
        $this->set('promote', $promoted ? NODE_PROMOTED : NODE_NOT_PROMOTED);
        return $this;
      }
    
      /**
       * {@inheritdoc}
       */
      public function isSticky() {
        return (bool) $this->get('sticky')->value;
      }
    
      /**
       * {@inheritdoc}
       */
      public function setSticky($sticky) {
        $this->set('sticky', $sticky ? NODE_STICKY : NODE_NOT_STICKY);
        return $this;
      }
      /**
       * {@inheritdoc}
       */
      public function isPublished() {
        return (bool) $this->get('status')->value;
      }
    
      /**
       * {@inheritdoc}
       */
      public function setPublished($published) {
        $this->set('status', $published ? NODE_PUBLISHED : NODE_NOT_PUBLISHED);
        return $this;
      }
    
      /**
       * {@inheritdoc}
       */
      public function getOwner() {
        return $this->get('uid')->entity;
      }
    
      /**
       * {@inheritdoc}
       */
      public function getOwnerId() {
        return $this->get('uid')->target_id;
      }
    
      /**
       * {@inheritdoc}
       */
      public function setOwnerId($uid) {
        $this->set('uid', $uid);
        return $this;
      }
    
      /**
       * {@inheritdoc}
       */
      public function setOwner(UserInterface $account) {
        $this->set('uid', $account->id());
        return $this;
      }
    
      /**
       * {@inheritdoc}
       */
      public function getRevisionCreationTime() {
        return $this->get('revision_timestamp')->value;
      }
    
      /**
       * {@inheritdoc}
       */
      public function setRevisionCreationTime($timestamp) {
        $this->set('revision_timestamp', $timestamp);
        return $this;
      }
    
      /**
       * {@inheritdoc}
       */
      public function getRevisionAuthor() {
        return $this->get('revision_uid')->entity;
      }
    
      /**
       * {@inheritdoc}
       */
      public function setRevisionAuthorId($uid) {
        $this->set('revision_uid', $uid);
        return $this;
      }
    
      /**
       * {@inheritdoc}
       */
      public static function baseFieldDefinitions(EntityTypeInterface $entity_type) {
        $fields['nid'] = FieldDefinition::create('integer')
          ->setLabel(t('Node ID'))
          ->setDescription(t('The node ID.'))
          ->setReadOnly(TRUE)
          ->setSetting('unsigned', TRUE);
    
        $fields['uuid'] = FieldDefinition::create('uuid')
          ->setLabel(t('UUID'))
          ->setDescription(t('The node UUID.'))
          ->setReadOnly(TRUE);
    
        $fields['vid'] = FieldDefinition::create('integer')
          ->setLabel(t('Revision ID'))
          ->setDescription(t('The node revision ID.'))
          ->setReadOnly(TRUE)
          ->setSetting('unsigned', TRUE);
    
        $fields['type'] = FieldDefinition::create('entity_reference')
          ->setLabel(t('Type'))
          ->setDescription(t('The node type.'))
          ->setSetting('target_type', 'node_type')
          ->setReadOnly(TRUE);
    
        $fields['langcode'] = FieldDefinition::create('language')
          ->setLabel(t('Language code'))
          ->setDescription(t('The node language code.'))
          ->setRevisionable(TRUE);
    
        $fields['title'] = FieldDefinition::create('string')
          ->setLabel(t('Title'))
          ->setDescription(t('The title of this node, always treated as non-markup plain text.'))
          ->setRequired(TRUE)
          ->setTranslatable(TRUE)
          ->setRevisionable(TRUE)
          ->setDefaultValue('')
          ->setSetting('max_length', 255)
          ->setDisplayOptions('view', array(
            'label' => 'hidden',
            'type' => 'string',
            'weight' => -5,
          ))
          ->setDisplayOptions('form', array(
            'type' => 'string',
            'weight' => -5,
          ))
          ->setDisplayConfigurable('form', TRUE);
    
        $fields['uid'] = FieldDefinition::create('entity_reference')
          ->setLabel(t('Author'))
          ->setDescription(t('The user that is the node author.'))
          ->setRevisionable(TRUE)
          ->setSetting('target_type', 'user')
          ->setTranslatable(TRUE);
    
        $fields['status'] = FieldDefinition::create('boolean')
          ->setLabel(t('Publishing status'))
          ->setDescription(t('A boolean indicating whether the node is published.'))
          ->setRevisionable(TRUE)
          ->setTranslatable(TRUE);
    
        $fields['created'] = FieldDefinition::create('created')
          ->setLabel(t('Created'))
          ->setDescription(t('The time that the node was created.'))
          ->setRevisionable(TRUE)
          ->setTranslatable(TRUE);
    
        $fields['changed'] = FieldDefinition::create('changed')
          ->setLabel(t('Changed'))
          ->setDescription(t('The time that the node was last edited.'))
          ->setRevisionable(TRUE)
          ->setTranslatable(TRUE);
    
        $fields['promote'] = FieldDefinition::create('boolean')
          ->setLabel(t('Promote'))
          ->setDescription(t('A boolean indicating whether the node should be displayed on the front page.'))
          ->setRevisionable(TRUE)
          ->setTranslatable(TRUE);
    
        $fields['sticky'] = FieldDefinition::create('boolean')
          ->setLabel(t('Sticky'))
          ->setDescription(t('A boolean indicating whether the node should be displayed at the top of lists in which it appears.'))
          ->setRevisionable(TRUE)
          ->setTranslatable(TRUE);
    
        $fields['revision_timestamp'] = FieldDefinition::create('created')
          ->setLabel(t('Revision timestamp'))
          ->setDescription(t('The time that the current revision was created.'))
          ->setQueryable(FALSE)
          ->setRevisionable(TRUE);
    
        $fields['revision_uid'] = FieldDefinition::create('entity_reference')
          ->setLabel(t('Revision user ID'))
          ->setDescription(t('The user ID of the author of the current revision.'))
          ->setSetting('target_type', 'user')
          ->setQueryable(FALSE)
          ->setRevisionable(TRUE);
    
        $fields['revision_log'] = FieldDefinition::create('string_long')
          ->setLabel(t('Revision log message'))
          ->setDescription(t('The log entry explaining the changes in this revision.'))
          ->setRevisionable(TRUE)
          ->setTranslatable(TRUE);
    
        return $fields;
      }
    
      /**
       * {@inheritdoc}
       */
      public static function bundleFieldDefinitions(EntityTypeInterface $entity_type, $bundle, array $base_field_definitions) {
        $node_type = node_type_load($bundle);
        $fields = array();
    
        // When deleting a node type the corresponding node displays are deleted as
        // well. In order to be deleted, they need to be loaded first. Entity
        // displays, however, fetch the field definitions of the respective entity
        // type to fill in their defaults. Therefore this function ends up being
        // called with a non-existing bundle.
        // @todo Fix this in https://drupal.org/node/2248795
        if (!$node_type) {
          return $fields;
        }
    
        if (isset($node_type->title_label)) {
          $fields['title'] = clone $base_field_definitions['title'];
          $fields['title']->setLabel($node_type->title_label);
        }
    
        $options = $node_type->getModuleSettings('node')['options'];
        $fields['status'] = clone $base_field_definitions['status'];
        $fields['status']->setDefaultValue(!empty($options['status']) ? NODE_PUBLISHED : NODE_NOT_PUBLISHED);
        $fields['promote'] = clone $base_field_definitions['promote'];
        $fields['promote']->setDefaultValue(!empty($options['promote']) ? NODE_PROMOTED : NODE_NOT_PROMOTED);
        $fields['sticky'] = clone $base_field_definitions['sticky'];
        $fields['sticky']->setDefaultValue(!empty($options['sticky']) ? NODE_STICKY : NODE_NOT_STICKY);
    
        return $fields;
      }
    
    }