You are here

class LayoutBuilderEntityViewDisplay in Drupal 9

Same name and namespace in other branches
  1. 8 core/modules/layout_builder/src/Entity/LayoutBuilderEntityViewDisplay.php \Drupal\layout_builder\Entity\LayoutBuilderEntityViewDisplay

Provides an entity view display entity that has a layout.

Hierarchy

Expanded class hierarchy of LayoutBuilderEntityViewDisplay

15 files declare their use of LayoutBuilderEntityViewDisplay
DefaultsSectionStorageTest.php in core/modules/layout_builder/tests/src/Kernel/DefaultsSectionStorageTest.php
InlineBlockTest.php in core/modules/layout_builder/tests/src/FunctionalJavascript/InlineBlockTest.php
LayoutBuilderAccessTest.php in core/modules/layout_builder/tests/src/Functional/LayoutBuilderAccessTest.php
LayoutBuilderContentModerationIntegrationTest.php in core/modules/content_moderation/tests/src/Functional/LayoutBuilderContentModerationIntegrationTest.php
LayoutBuilderEntityViewDisplayTest.php in core/modules/layout_builder/tests/src/Kernel/LayoutBuilderEntityViewDisplayTest.php

... See full list

File

core/modules/layout_builder/src/Entity/LayoutBuilderEntityViewDisplay.php, line 29

Namespace

Drupal\layout_builder\Entity
View source
class LayoutBuilderEntityViewDisplay extends BaseEntityViewDisplay implements LayoutEntityDisplayInterface {
  use LayoutEntityHelperTrait;
  use SectionListTrait;

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

  /**
   * {@inheritdoc}
   */
  public function __construct(array $values, $entity_type) {

    // Set $entityFieldManager before calling the parent constructor because the
    // constructor will call init() which then calls setComponent() which needs
    // $entityFieldManager.
    $this->entityFieldManager = \Drupal::service('entity_field.manager');
    parent::__construct($values, $entity_type);
  }

  /**
   * {@inheritdoc}
   */
  public function isOverridable() {
    return $this
      ->isLayoutBuilderEnabled() && $this
      ->getThirdPartySetting('layout_builder', 'allow_custom', FALSE);
  }

  /**
   * {@inheritdoc}
   */
  public function setOverridable($overridable = TRUE) {
    $this
      ->setThirdPartySetting('layout_builder', 'allow_custom', $overridable);

    // Enable Layout Builder if it's not already enabled and overriding.
    if ($overridable && !$this
      ->isLayoutBuilderEnabled()) {
      $this
        ->enableLayoutBuilder();
    }
    return $this;
  }

  /**
   * {@inheritdoc}
   */
  public function isLayoutBuilderEnabled() {

    // Layout Builder must not be enabled for the '_custom' view mode that is
    // used for on-the-fly rendering of fields in isolation from the entity.
    if ($this
      ->isCustomMode()) {
      return FALSE;
    }
    return (bool) $this
      ->getThirdPartySetting('layout_builder', 'enabled');
  }

  /**
   * {@inheritdoc}
   */
  public function enableLayoutBuilder() {
    $this
      ->setThirdPartySetting('layout_builder', 'enabled', TRUE);
    return $this;
  }

  /**
   * {@inheritdoc}
   */
  public function disableLayoutBuilder() {
    $this
      ->setOverridable(FALSE);
    $this
      ->setThirdPartySetting('layout_builder', 'enabled', FALSE);
    return $this;
  }

  /**
   * {@inheritdoc}
   */
  public function getSections() {
    return $this
      ->getThirdPartySetting('layout_builder', 'sections', []);
  }

  /**
   * {@inheritdoc}
   */
  protected function setSections(array $sections) {

    // Third-party settings must be completely unset instead of stored as an
    // empty array.
    if (!$sections) {
      $this
        ->unsetThirdPartySetting('layout_builder', 'sections');
    }
    else {
      $this
        ->setThirdPartySetting('layout_builder', 'sections', array_values($sections));
    }
    return $this;
  }

  /**
   * {@inheritdoc}
   */
  public function preSave(EntityStorageInterface $storage) {
    parent::preSave($storage);
    $original_value = isset($this->original) ? $this->original
      ->isOverridable() : FALSE;
    $new_value = $this
      ->isOverridable();
    if ($original_value !== $new_value) {
      $entity_type_id = $this
        ->getTargetEntityTypeId();
      $bundle = $this
        ->getTargetBundle();
      if ($new_value) {
        $this
          ->addSectionField($entity_type_id, $bundle, OverridesSectionStorage::FIELD_NAME);
      }
      else {
        $this
          ->removeSectionField($entity_type_id, $bundle, OverridesSectionStorage::FIELD_NAME);
      }
    }
    $already_enabled = isset($this->original) ? $this->original
      ->isLayoutBuilderEnabled() : FALSE;
    $set_enabled = $this
      ->isLayoutBuilderEnabled();
    if ($already_enabled !== $set_enabled) {
      if ($set_enabled) {

        // Loop through all existing field-based components and add them as
        // section-based components.
        $components = $this
          ->getComponents();

        // Sort the components by weight.
        uasort($components, 'Drupal\\Component\\Utility\\SortArray::sortByWeightElement');
        foreach ($components as $name => $component) {
          $this
            ->setComponent($name, $component);
        }
      }
      else {

        // When being disabled, remove all existing section data.
        $this
          ->removeAllSections();
      }
    }
  }

  /**
   * Removes a layout section field if it is no longer needed.
   *
   * Because the field is shared across all view modes, the field will only be
   * removed if no other view modes are using it.
   *
   * @param string $entity_type_id
   *   The entity type ID.
   * @param string $bundle
   *   The bundle.
   * @param string $field_name
   *   The name for the layout section field.
   */
  protected function removeSectionField($entity_type_id, $bundle, $field_name) {
    $query = $this
      ->entityTypeManager()
      ->getStorage($this
      ->getEntityTypeId())
      ->getQuery()
      ->condition('targetEntityType', $this
      ->getTargetEntityTypeId())
      ->condition('bundle', $this
      ->getTargetBundle())
      ->condition('mode', $this
      ->getMode(), '<>')
      ->condition('third_party_settings.layout_builder.allow_custom', TRUE);
    $enabled = (bool) $query
      ->count()
      ->execute();
    if (!$enabled && ($field = FieldConfig::loadByName($entity_type_id, $bundle, $field_name))) {
      $field
        ->delete();
    }
  }

  /**
   * Adds a layout section field to a given bundle.
   *
   * @param string $entity_type_id
   *   The entity type ID.
   * @param string $bundle
   *   The bundle.
   * @param string $field_name
   *   The name for the layout section field.
   */
  protected function addSectionField($entity_type_id, $bundle, $field_name) {
    $field = FieldConfig::loadByName($entity_type_id, $bundle, $field_name);
    if (!$field) {
      $field_storage = FieldStorageConfig::loadByName($entity_type_id, $field_name);
      if (!$field_storage) {
        $field_storage = FieldStorageConfig::create([
          'entity_type' => $entity_type_id,
          'field_name' => $field_name,
          'type' => 'layout_section',
          'locked' => TRUE,
        ]);
        $field_storage
          ->setTranslatable(FALSE);
        $field_storage
          ->save();
      }
      $field = FieldConfig::create([
        'field_storage' => $field_storage,
        'bundle' => $bundle,
        'label' => t('Layout'),
      ]);
      $field
        ->setTranslatable(FALSE);
      $field
        ->save();
    }
  }

  /**
   * {@inheritdoc}
   */
  public function createCopy($mode) {

    // Disable Layout Builder and remove any sections copied from the original.
    return parent::createCopy($mode)
      ->setSections([])
      ->disableLayoutBuilder();
  }

  /**
   * {@inheritdoc}
   */
  protected function getDefaultRegion() {
    if ($this
      ->hasSection(0)) {
      return $this
        ->getSection(0)
        ->getDefaultRegion();
    }
    return parent::getDefaultRegion();
  }

  /**
   * Wraps the context repository service.
   *
   * @return \Drupal\Core\Plugin\Context\ContextRepositoryInterface
   *   The context repository service.
   */
  protected function contextRepository() {
    return \Drupal::service('context.repository');
  }

  /**
   * Indicates if this display is using the '_custom' view mode.
   *
   * @return bool
   *   TRUE if this display is using the '_custom' view mode, FALSE otherwise.
   */
  protected function isCustomMode() {
    return $this
      ->getOriginalMode() === static::CUSTOM_MODE;
  }

  /**
   * {@inheritdoc}
   */
  public function buildMultiple(array $entities) {
    $build_list = parent::buildMultiple($entities);

    // Layout Builder can not be enabled for the '_custom' view mode that is
    // used for on-the-fly rendering of fields in isolation from the entity.
    if ($this
      ->isCustomMode()) {
      return $build_list;
    }
    foreach ($entities as $id => $entity) {
      $build_list[$id]['_layout_builder'] = $this
        ->buildSections($entity);

      // If there are any sections, remove all fields with configurable display
      // from the existing build. These fields are replicated within sections as
      // field blocks by ::setComponent().
      if (!Element::isEmpty($build_list[$id]['_layout_builder'])) {
        foreach ($build_list[$id] as $name => $build_part) {
          $field_definition = $this
            ->getFieldDefinition($name);
          if ($field_definition && $field_definition
            ->isDisplayConfigurable($this->displayContext)) {
            unset($build_list[$id][$name]);
          }
        }
      }
    }
    return $build_list;
  }

  /**
   * Builds the render array for the sections of a given entity.
   *
   * @param \Drupal\Core\Entity\FieldableEntityInterface $entity
   *   The entity.
   *
   * @return array
   *   The render array representing the sections of the entity.
   */
  protected function buildSections(FieldableEntityInterface $entity) {
    $contexts = $this
      ->getContextsForEntity($entity);

    // @todo Remove in https://www.drupal.org/project/drupal/issues/3018782.
    $label = new TranslatableMarkup('@entity being viewed', [
      '@entity' => $entity
        ->getEntityType()
        ->getSingularLabel(),
    ]);
    $contexts['layout_builder.entity'] = EntityContext::fromEntity($entity, $label);
    $cacheability = new CacheableMetadata();
    $storage = $this
      ->sectionStorageManager()
      ->findByContext($contexts, $cacheability);
    $build = [];
    if ($storage) {
      foreach ($storage
        ->getSections() as $delta => $section) {
        $build[$delta] = $section
          ->toRenderArray($contexts);
      }
    }

    // The render array is built based on decisions made by @SectionStorage
    // plugins and therefore it needs to depend on the accumulated
    // cacheability of those decisions.
    $cacheability
      ->applyTo($build);
    return $build;
  }

  /**
   * Gets the available contexts for a given entity.
   *
   * @param \Drupal\Core\Entity\FieldableEntityInterface $entity
   *   The entity.
   *
   * @return \Drupal\Core\Plugin\Context\ContextInterface[]
   *   An array of context objects for a given entity.
   */
  protected function getContextsForEntity(FieldableEntityInterface $entity) {
    $available_context_ids = array_keys($this
      ->contextRepository()
      ->getAvailableContexts());
    return [
      'view_mode' => new Context(ContextDefinition::create('string'), $this
        ->getMode()),
      'entity' => EntityContext::fromEntity($entity),
      'display' => EntityContext::fromEntity($this),
    ] + $this
      ->contextRepository()
      ->getRuntimeContexts($available_context_ids);
  }

  /**
   * {@inheritdoc}
   *
   * @todo Move this upstream in https://www.drupal.org/node/2939931.
   */
  public function label() {
    $bundle_info = \Drupal::service('entity_type.bundle.info')
      ->getBundleInfo($this
      ->getTargetEntityTypeId());
    $bundle_label = $bundle_info[$this
      ->getTargetBundle()]['label'];
    $target_entity_type = $this
      ->entityTypeManager()
      ->getDefinition($this
      ->getTargetEntityTypeId());
    return new TranslatableMarkup('@bundle @label', [
      '@bundle' => $bundle_label,
      '@label' => $target_entity_type
        ->getPluralLabel(),
    ]);
  }

  /**
   * {@inheritdoc}
   */
  public function calculateDependencies() {
    parent::calculateDependencies();
    foreach ($this
      ->getSections() as $delta => $section) {
      $this
        ->calculatePluginDependencies($section
        ->getLayout());
      foreach ($section
        ->getComponents() as $uuid => $component) {
        $this
          ->calculatePluginDependencies($component
          ->getPlugin());
      }
    }
    return $this;
  }

  /**
   * {@inheritdoc}
   */
  public function onDependencyRemoval(array $dependencies) {
    $changed = parent::onDependencyRemoval($dependencies);

    // Loop through all sections and determine if the removed dependencies are
    // used by their layout plugins.
    foreach ($this
      ->getSections() as $delta => $section) {
      $layout_dependencies = $this
        ->getPluginDependencies($section
        ->getLayout());
      $layout_removed_dependencies = $this
        ->getPluginRemovedDependencies($layout_dependencies, $dependencies);
      if ($layout_removed_dependencies) {

        // @todo Allow the plugins to react to their dependency removal in
        //   https://www.drupal.org/project/drupal/issues/2579743.
        $this
          ->removeSection($delta);
        $changed = TRUE;
      }
      else {
        foreach ($section
          ->getComponents() as $uuid => $component) {
          $plugin_dependencies = $this
            ->getPluginDependencies($component
            ->getPlugin());
          $component_removed_dependencies = $this
            ->getPluginRemovedDependencies($plugin_dependencies, $dependencies);
          if ($component_removed_dependencies) {

            // @todo Allow the plugins to react to their dependency removal in
            //   https://www.drupal.org/project/drupal/issues/2579743.
            $section
              ->removeComponent($uuid);
            $changed = TRUE;
          }
        }
      }
    }
    return $changed;
  }

  /**
   * {@inheritdoc}
   */
  public function setComponent($name, array $options = []) {
    parent::setComponent($name, $options);

    // Only continue if Layout Builder is enabled.
    if (!$this
      ->isLayoutBuilderEnabled()) {
      return $this;
    }

    // Retrieve the updated options after the parent:: call.
    $options = $this->content[$name];

    // Provide backwards compatibility by converting to a section component.
    $field_definition = $this
      ->getFieldDefinition($name);
    $extra_fields = $this->entityFieldManager
      ->getExtraFields($this
      ->getTargetEntityTypeId(), $this
      ->getTargetBundle());
    $is_view_configurable_non_extra_field = $field_definition && $field_definition
      ->isDisplayConfigurable('view') && isset($options['type']);
    if ($is_view_configurable_non_extra_field || isset($extra_fields['display'][$name])) {
      $configuration = [
        'label_display' => '0',
        'context_mapping' => [
          'entity' => 'layout_builder.entity',
        ],
      ];
      if ($is_view_configurable_non_extra_field) {
        $configuration['id'] = 'field_block:' . $this
          ->getTargetEntityTypeId() . ':' . $this
          ->getTargetBundle() . ':' . $name;
        $keys = array_flip([
          'type',
          'label',
          'settings',
          'third_party_settings',
        ]);
        $configuration['formatter'] = array_intersect_key($options, $keys);
      }
      else {
        $configuration['id'] = 'extra_field_block:' . $this
          ->getTargetEntityTypeId() . ':' . $this
          ->getTargetBundle() . ':' . $name;
      }
      $section = $this
        ->getDefaultSection();
      $region = isset($options['region']) ? $options['region'] : $section
        ->getDefaultRegion();
      $new_component = new SectionComponent(\Drupal::service('uuid')
        ->generate(), $region, $configuration);
      $section
        ->appendComponent($new_component);
    }
    return $this;
  }

  /**
   * Gets a default section.
   *
   * @return \Drupal\layout_builder\Section
   *   The default section.
   */
  protected function getDefaultSection() {

    // If no section exists, append a new one.
    if (!$this
      ->hasSection(0)) {
      $this
        ->appendSection(new Section('layout_onecol'));
    }

    // Return the first section.
    return $this
      ->getSection(0);
  }

  /**
   * Gets the section storage manager.
   *
   * @return \Drupal\layout_builder\SectionStorage\SectionStorageManagerInterface
   *   The section storage manager.
   */
  private function sectionStorageManager() {
    return \Drupal::service('plugin.manager.layout_builder.section_storage');
  }

  /**
   * {@inheritdoc}
   */
  public function getComponent($name) {
    if ($this
      ->isLayoutBuilderEnabled() && ($section_component = $this
      ->getQuickEditSectionComponent() ?: $this
      ->getSectionComponentForFieldName($name))) {
      $plugin = $section_component
        ->getPlugin();
      if ($plugin instanceof ConfigurableInterface) {
        $configuration = $plugin
          ->getConfiguration();
        if (isset($configuration['formatter'])) {
          return $configuration['formatter'];
        }
      }
    }
    return parent::getComponent($name);
  }

  /**
   * Returns the Quick Edit formatter settings.
   *
   * @return \Drupal\layout_builder\SectionComponent|null
   *   The section component if it is available.
   *
   * @see \Drupal\layout_builder\QuickEditIntegration::entityViewAlter()
   * @see \Drupal\quickedit\MetadataGenerator::generateFieldMetadata()
   */
  private function getQuickEditSectionComponent() {

    // To determine the Quick Edit view_mode ID we need an originalMode set.
    if ($original_mode = $this
      ->getOriginalMode()) {
      $parts = explode('-', $original_mode);

      // The Quick Edit view mode ID is created by
      // \Drupal\layout_builder\QuickEditIntegration::entityViewAlter()
      // concatenating together the information we need to retrieve the Layout
      // Builder component. It follows the structure prescribed by the
      // documentation of hook_quickedit_render_field().
      if (count($parts) === 6 && $parts[0] === 'layout_builder') {
        list(, $delta, $component_uuid, $entity_id) = QuickEditIntegration::deconstructViewModeId($original_mode);
        $entity = $this
          ->entityTypeManager()
          ->getStorage($this
          ->getTargetEntityTypeId())
          ->load($entity_id);
        $sections = $this
          ->getEntitySections($entity);
        if (isset($sections[$delta])) {
          $component = $sections[$delta]
            ->getComponent($component_uuid);
          $plugin = $component
            ->getPlugin();

          // We only care about FieldBlock because these are only components
          // that provide Quick Edit integration: Quick Edit enables in-place
          // editing of fields of entities, not of anything else.
          if ($plugin instanceof DerivativeInspectionInterface && $plugin
            ->getBaseId() === 'field_block') {
            return $component;
          }
        }
      }
    }
    return NULL;
  }

  /**
   * Gets the component for a given field name if any.
   *
   * @param string $field_name
   *   The field name.
   *
   * @return \Drupal\layout_builder\SectionComponent|null
   *   The section component if it is available.
   */
  private function getSectionComponentForFieldName($field_name) {

    // Loop through every component until the first match is found.
    foreach ($this
      ->getSections() as $section) {
      foreach ($section
        ->getComponents() as $component) {
        $plugin = $component
          ->getPlugin();
        if ($plugin instanceof DerivativeInspectionInterface && in_array($plugin
          ->getBaseId(), [
          'field_block',
          'extra_field_block',
        ], TRUE)) {

          // FieldBlock derivative IDs are in the format
          // [entity_type]:[bundle]:[field].
          list(, , $field_block_field_name) = explode(PluginBase::DERIVATIVE_SEPARATOR, $plugin
            ->getDerivativeId());
          if ($field_block_field_name === $field_name) {
            return $component;
          }
        }
      }
    }
    return NULL;
  }

}

Members

Namesort descending Modifiers Type Description Overrides
CacheableDependencyTrait::$cacheContexts protected property Cache contexts.
CacheableDependencyTrait::$cacheMaxAge protected property Cache max-age.
CacheableDependencyTrait::$cacheTags protected property Cache tags.
CacheableDependencyTrait::setCacheability protected function Sets cacheability; useful for value object constructors.
ConfigEntityBase::$isUninstalling private property Whether the config is being deleted by the uninstall process.
ConfigEntityBase::$langcode protected property The language code of the entity's default language.
ConfigEntityBase::$originalId protected property The original ID of the configuration entity.
ConfigEntityBase::$third_party_settings protected property Third party entity settings.
ConfigEntityBase::$trustedData protected property Trust supplied data and not use configuration schema on save.
ConfigEntityBase::$uuid protected property The UUID for this entity.
ConfigEntityBase::$_core protected property
ConfigEntityBase::addDependency protected function Overrides \Drupal\Core\Entity\DependencyTrait:addDependency().
ConfigEntityBase::createDuplicate public function Creates a duplicate of the entity. Overrides EntityBase::createDuplicate 1
ConfigEntityBase::disable public function Disables the configuration entity. Overrides ConfigEntityInterface::disable 1
ConfigEntityBase::enable public function Enables the configuration entity. Overrides ConfigEntityInterface::enable
ConfigEntityBase::get public function Returns the value of a property. Overrides ConfigEntityInterface::get
ConfigEntityBase::getCacheTagsToInvalidate public function Returns the cache tags that should be used to invalidate caches. Overrides EntityBase::getCacheTagsToInvalidate 1
ConfigEntityBase::getConfigDependencyName public function Gets the configuration dependency name. Overrides EntityBase::getConfigDependencyName
ConfigEntityBase::getConfigManager protected static function Gets the configuration manager.
ConfigEntityBase::getConfigTarget public function Gets the configuration target identifier for the entity. Overrides EntityBase::getConfigTarget
ConfigEntityBase::getDependencies public function Gets the configuration dependencies. Overrides ConfigEntityInterface::getDependencies
ConfigEntityBase::getOriginalId public function Gets the original ID. Overrides EntityBase::getOriginalId
ConfigEntityBase::getThirdPartyProviders public function Gets the list of third parties that store information. Overrides ThirdPartySettingsInterface::getThirdPartyProviders
ConfigEntityBase::getThirdPartySetting public function Gets the value of a third-party setting. Overrides ThirdPartySettingsInterface::getThirdPartySetting
ConfigEntityBase::getThirdPartySettings public function Gets all third-party settings of a given module. Overrides ThirdPartySettingsInterface::getThirdPartySettings
ConfigEntityBase::getTypedConfig protected function Gets the typed config manager.
ConfigEntityBase::hasTrustedData public function Gets whether on not the data is trusted. Overrides ConfigEntityInterface::hasTrustedData
ConfigEntityBase::invalidateTagsOnDelete protected static function Override to never invalidate the individual entities' cache tags; the config system already invalidates them. Overrides EntityBase::invalidateTagsOnDelete
ConfigEntityBase::invalidateTagsOnSave protected function Override to never invalidate the entity's cache tag; the config system already invalidates it. Overrides EntityBase::invalidateTagsOnSave
ConfigEntityBase::isInstallable public function Checks whether this entity is installable. Overrides ConfigEntityInterface::isInstallable 2
ConfigEntityBase::isNew public function Overrides Entity::isNew(). Overrides EntityBase::isNew
ConfigEntityBase::isUninstalling public function Returns whether this entity is being changed during the uninstall process. Overrides ConfigEntityInterface::isUninstalling
ConfigEntityBase::preDelete public static function Acts on entities before they are deleted and before hooks are invoked. Overrides EntityBase::preDelete 8
ConfigEntityBase::save public function Saves an entity permanently. Overrides EntityBase::save 1
ConfigEntityBase::set public function Sets the value of a property. Overrides ConfigEntityInterface::set
ConfigEntityBase::setOriginalId public function Sets the original ID. Overrides EntityBase::setOriginalId
ConfigEntityBase::setStatus public function Sets the status of the configuration entity. Overrides ConfigEntityInterface::setStatus
ConfigEntityBase::setThirdPartySetting public function Sets the value of a third-party setting. Overrides ThirdPartySettingsInterface::setThirdPartySetting
ConfigEntityBase::setUninstalling public function
ConfigEntityBase::sort public static function Helper callback for uasort() to sort configuration entities by weight and label. 6
ConfigEntityBase::status public function Returns whether the configuration entity is enabled. Overrides ConfigEntityInterface::status 4
ConfigEntityBase::toUrl public function Gets the URL object for the entity. Overrides EntityBase::toUrl
ConfigEntityBase::trustData public function Sets that the data should be trusted. Overrides ConfigEntityInterface::trustData
ConfigEntityBase::unsetThirdPartySetting public function Unsets a third-party setting. Overrides ThirdPartySettingsInterface::unsetThirdPartySetting
DependencySerializationTrait::$_entityStorages protected property
DependencySerializationTrait::$_serviceIds protected property
DependencySerializationTrait::__sleep public function Aliased as: traitSleep 2
DependencyTrait::$dependencies protected property The object's dependencies.
DependencyTrait::addDependencies protected function Adds multiple dependencies.
DependencyTrait::addDependency protected function Adds a dependency. Aliased as: addDependencyTrait
EntityBase::$enforceIsNew protected property Boolean indicating whether the entity should be forced to be new.
EntityBase::$entityTypeId protected property The entity type.
EntityBase::$typedData protected property A typed data object wrapping this entity.
EntityBase::access public function Checks data value access. Overrides AccessibleInterface::access 1
EntityBase::bundle public function Gets the bundle of the entity. Overrides EntityInterface::bundle 1
EntityBase::create public static function Constructs a new entity object, without permanently saving it. Overrides EntityInterface::create
EntityBase::delete public function Deletes an entity permanently. Overrides EntityInterface::delete 2
EntityBase::enforceIsNew public function Enforces an entity to be new. Overrides EntityInterface::enforceIsNew
EntityBase::entityTypeBundleInfo protected function Gets the entity type bundle info service.
EntityBase::entityTypeManager protected function Gets the entity type manager.
EntityBase::getCacheContexts public function The cache contexts associated with this object. Overrides CacheableDependencyTrait::getCacheContexts
EntityBase::getCacheMaxAge public function The maximum age for which this object may be cached. Overrides CacheableDependencyTrait::getCacheMaxAge
EntityBase::getCacheTags public function The cache tags associated with this object. Overrides CacheableDependencyTrait::getCacheTags
EntityBase::getConfigDependencyKey public function Gets the key that is used to store configuration dependencies. Overrides EntityInterface::getConfigDependencyKey
EntityBase::getEntityType public function Gets the entity type definition. Overrides EntityInterface::getEntityType
EntityBase::getEntityTypeId public function Gets the ID of the type of the entity. Overrides EntityInterface::getEntityTypeId
EntityBase::getListCacheTagsToInvalidate protected function The list cache tags to invalidate for this entity.
EntityBase::getTypedData public function Gets a typed data object for this entity object. Overrides EntityInterface::getTypedData
EntityBase::hasLinkTemplate public function Indicates if a link template exists for a given key. Overrides EntityInterface::hasLinkTemplate
EntityBase::language public function Gets the language of the entity. Overrides EntityInterface::language 1
EntityBase::languageManager protected function Gets the language manager.
EntityBase::linkTemplates protected function Gets an array link templates. 1
EntityBase::load public static function Loads an entity. Overrides EntityInterface::load
EntityBase::loadMultiple public static function Loads one or more entities. Overrides EntityInterface::loadMultiple
EntityBase::postCreate public function Acts on a created entity before hooks are invoked. Overrides EntityInterface::postCreate 4
EntityBase::postDelete public static function Acts on deleted entities before the delete hook is invoked. Overrides EntityInterface::postDelete 18
EntityBase::postLoad public static function Acts on loaded entities. Overrides EntityInterface::postLoad 2
EntityBase::preCreate public static function Changes the values of an entity before it is created. Overrides EntityInterface::preCreate 7
EntityBase::referencedEntities public function Gets a list of entities referenced by this entity. Overrides EntityInterface::referencedEntities 1
EntityBase::toLink public function Generates the HTML for a link to this entity. Overrides EntityInterface::toLink
EntityBase::uriRelationships public function Gets a list of URI relationships supported by this entity. Overrides EntityInterface::uriRelationships
EntityBase::urlRouteParameters protected function Gets an array of placeholders for this entity. 2
EntityBase::uuid public function Gets the entity UUID (Universally Unique Identifier). Overrides EntityInterface::uuid 1
EntityBase::uuidGenerator protected function Gets the UUID generator.
EntityDisplayBase::$bundle protected property Bundle to be displayed.
EntityDisplayBase::$content protected property List of component display options, keyed by component name.
EntityDisplayBase::$fieldDefinitions protected property A list of field definitions eligible for configuration in this display.
EntityDisplayBase::$hidden protected property List of components that are set to be hidden.
EntityDisplayBase::$id protected property Unique ID for the config entity.
EntityDisplayBase::$mode protected property View or form mode to be displayed.
EntityDisplayBase::$originalMode protected property The original view or form mode that was requested (case of view/form modes being configured to fall back to the 'default' display).
EntityDisplayBase::$pluginManager protected property The plugin manager used by this entity type.
EntityDisplayBase::$plugins protected property The plugin objects used for this display, keyed by field name.
EntityDisplayBase::$renderer protected property The renderer.
EntityDisplayBase::$status protected property Whether this display is enabled or not. If the entity (form) display is disabled, we'll fall back to the 'default' display. Overrides ConfigEntityBase::$status
EntityDisplayBase::$targetEntityType protected property Entity type to be displayed.
EntityDisplayBase::CUSTOM_MODE constant The 'mode' for runtime EntityDisplay objects used to render entities with arbitrary display options rather than a configured view mode or form mode.
EntityDisplayBase::fieldHasDisplayOptions private function Determines if a field has options for a given display.
EntityDisplayBase::getComponents public function Gets the display options for all components. Overrides EntityDisplayInterface::getComponents
EntityDisplayBase::getFieldDefinition protected function Gets the field definition of a field.
EntityDisplayBase::getFieldDefinitions protected function Gets the definitions of the fields that are candidate for display.
EntityDisplayBase::getHighestWeight public function Gets the highest weight of the components in the display. Overrides EntityDisplayInterface::getHighestWeight
EntityDisplayBase::getLogger protected function Provides the 'system' channel logger service.
EntityDisplayBase::getMode public function Gets the view or form mode to be displayed. Overrides EntityDisplayInterface::getMode
EntityDisplayBase::getOriginalMode public function Gets the original view or form mode that was requested. Overrides EntityDisplayInterface::getOriginalMode
EntityDisplayBase::getPluginRemovedDependencies protected function Returns the plugin dependencies being removed.
EntityDisplayBase::getTargetBundle public function Gets the bundle to be displayed. Overrides EntityDisplayInterface::getTargetBundle
EntityDisplayBase::getTargetEntityTypeId public function Gets the entity type for which this display is used. Overrides EntityDisplayInterface::getTargetEntityTypeId
EntityDisplayBase::id public function Gets the identifier. Overrides EntityBase::id
EntityDisplayBase::init protected function Initializes the display.
EntityDisplayBase::removeComponent public function Sets a component to be hidden. Overrides EntityDisplayInterface::removeComponent
EntityDisplayBase::setTargetBundle public function Sets the bundle to be displayed. Overrides EntityDisplayInterface::setTargetBundle
EntityDisplayBase::toArray public function Gets an array of all property values. Overrides ConfigEntityBase::toArray
EntityDisplayBase::__sleep public function Overrides ConfigEntityBase::__sleep
EntityDisplayBase::__wakeup public function Overrides DependencySerializationTrait::__wakeup
EntityViewDisplay::$displayContext protected property Context in which this entity will be used (e.g. 'view', 'form'). Overrides EntityDisplayBase::$displayContext
EntityViewDisplay::build public function Builds a renderable array for the components of an entity. Overrides EntityViewDisplayInterface::build
EntityViewDisplay::collectRenderDisplay public static function Returns the display object used to render an entity.
EntityViewDisplay::collectRenderDisplays public static function Returns the display objects used to render a set of entities.
EntityViewDisplay::getPluginCollections public function Gets the plugin collections used by this object. Overrides ObjectWithPluginCollectionInterface::getPluginCollections
EntityViewDisplay::getRenderer public function Gets the renderer plugin for a field (e.g. widget, formatter). Overrides EntityDisplayInterface::getRenderer
EntityViewDisplay::postSave public function Acts on a saved entity before the insert or update hook is invoked. Overrides EntityBase::postSave
LayoutBuilderEntityViewDisplay::$entityFieldManager protected property The entity field manager.
LayoutBuilderEntityViewDisplay::addSectionField protected function Adds a layout section field to a given bundle.
LayoutBuilderEntityViewDisplay::buildMultiple public function Builds a renderable array for the components of a set of entities. Overrides EntityViewDisplay::buildMultiple
LayoutBuilderEntityViewDisplay::buildSections protected function Builds the render array for the sections of a given entity.
LayoutBuilderEntityViewDisplay::calculateDependencies public function Calculates dependencies and stores them in the dependency property. Overrides EntityDisplayBase::calculateDependencies
LayoutBuilderEntityViewDisplay::contextRepository protected function Wraps the context repository service.
LayoutBuilderEntityViewDisplay::createCopy public function Creates a duplicate of the entity display object on a different view mode. Overrides EntityDisplayBase::createCopy
LayoutBuilderEntityViewDisplay::disableLayoutBuilder public function Disables the Layout Builder. Overrides LayoutBuilderEnabledInterface::disableLayoutBuilder
LayoutBuilderEntityViewDisplay::enableLayoutBuilder public function Enables the Layout Builder. Overrides LayoutBuilderEnabledInterface::enableLayoutBuilder
LayoutBuilderEntityViewDisplay::getComponent public function Gets the display options set for a component. Overrides EntityDisplayBase::getComponent
LayoutBuilderEntityViewDisplay::getContextsForEntity protected function Gets the available contexts for a given entity.
LayoutBuilderEntityViewDisplay::getDefaultRegion protected function Gets the default region. Overrides EntityDisplayBase::getDefaultRegion
LayoutBuilderEntityViewDisplay::getDefaultSection protected function Gets a default section.
LayoutBuilderEntityViewDisplay::getQuickEditSectionComponent private function Returns the Quick Edit formatter settings.
LayoutBuilderEntityViewDisplay::getSectionComponentForFieldName private function Gets the component for a given field name if any.
LayoutBuilderEntityViewDisplay::getSections public function Gets the layout sections. Overrides SectionListInterface::getSections
LayoutBuilderEntityViewDisplay::isCustomMode protected function Indicates if this display is using the '_custom' view mode.
LayoutBuilderEntityViewDisplay::isLayoutBuilderEnabled public function Determines if Layout Builder is enabled. Overrides LayoutBuilderEnabledInterface::isLayoutBuilderEnabled
LayoutBuilderEntityViewDisplay::isOverridable public function Determines if the display allows custom overrides. Overrides LayoutEntityDisplayInterface::isOverridable
LayoutBuilderEntityViewDisplay::label public function @todo Move this upstream in https://www.drupal.org/node/2939931. Overrides EntityBase::label
LayoutBuilderEntityViewDisplay::onDependencyRemoval public function Informs the entity that entities it depends on will be deleted. Overrides EntityDisplayBase::onDependencyRemoval
LayoutBuilderEntityViewDisplay::preSave public function Acts on an entity before the presave hook is invoked. Overrides EntityDisplayBase::preSave
LayoutBuilderEntityViewDisplay::removeSectionField protected function Removes a layout section field if it is no longer needed.
LayoutBuilderEntityViewDisplay::sectionStorageManager private function Gets the section storage manager. Overrides LayoutEntityHelperTrait::sectionStorageManager
LayoutBuilderEntityViewDisplay::setComponent public function Sets the display options for a component. Overrides EntityDisplayBase::setComponent
LayoutBuilderEntityViewDisplay::setOverridable public function Sets the display to allow or disallow overrides. Overrides LayoutEntityDisplayInterface::setOverridable
LayoutBuilderEntityViewDisplay::setSections protected function Stores the information for all sections. Overrides SectionListTrait::setSections
LayoutBuilderEntityViewDisplay::__construct public function Constructs an Entity object. Overrides EntityViewDisplay::__construct
LayoutEntityHelperTrait::$sectionStorageManager protected property The section storage manager. 1
LayoutEntityHelperTrait::getEntitySections protected function Gets the sections for an entity if any.
LayoutEntityHelperTrait::getInlineBlockComponents protected function Gets components that have Inline Block plugins.
LayoutEntityHelperTrait::getInlineBlockRevisionIdsInSections protected function Gets revision IDs for layout sections.
LayoutEntityHelperTrait::getSectionStorageForEntity protected function Gets the section storage for an entity.
LayoutEntityHelperTrait::isLayoutCompatibleEntity protected function Determines if an entity can have a layout.
LayoutEntityHelperTrait::originalEntityUsesDefaultStorage protected function Determines if the original entity used the default section storage.
PluginDependencyTrait::calculatePluginDependencies protected function Calculates and adds dependencies of a specific plugin instance. 1
PluginDependencyTrait::getPluginDependencies protected function Calculates and returns dependencies of a specific plugin instance.
PluginDependencyTrait::moduleHandler protected function Wraps the module handler. 1
PluginDependencyTrait::themeHandler protected function Wraps the theme handler. 1
RefinableCacheableDependencyTrait::addCacheableDependency public function 1
RefinableCacheableDependencyTrait::addCacheContexts public function
RefinableCacheableDependencyTrait::addCacheTags public function
RefinableCacheableDependencyTrait::mergeCacheMaxAge public function
SectionListTrait::addBlankSection protected function Adds a blank section to the list.
SectionListTrait::appendSection public function
SectionListTrait::count public function
SectionListTrait::getSection public function
SectionListTrait::hasBlankSection protected function Indicates if this section list contains a blank section.
SectionListTrait::hasSection protected function Indicates if there is a section at the specified delta.
SectionListTrait::insertSection public function
SectionListTrait::removeAllSections public function
SectionListTrait::removeSection public function
SectionListTrait::setSection protected function Sets the section for the given delta on the display.
SectionListTrait::__clone public function Magic method: Implements a deep clone.
SynchronizableEntityTrait::$isSyncing protected property Whether this entity is being created, updated or deleted through a synchronization process.
SynchronizableEntityTrait::isSyncing public function
SynchronizableEntityTrait::setSyncing public function