View source
<?php
namespace Drupal\layout_builder\Entity;
use Drupal\Component\Plugin\ConfigurableInterface;
use Drupal\Component\Plugin\DerivativeInspectionInterface;
use Drupal\Component\Plugin\PluginBase;
use Drupal\Core\Cache\CacheableMetadata;
use Drupal\Core\Entity\Entity\EntityViewDisplay as BaseEntityViewDisplay;
use Drupal\Core\Entity\EntityStorageInterface;
use Drupal\Core\Entity\FieldableEntityInterface;
use Drupal\Core\Plugin\Context\Context;
use Drupal\Core\Plugin\Context\ContextDefinition;
use Drupal\Core\Plugin\Context\EntityContext;
use Drupal\Core\Render\Element;
use Drupal\Core\StringTranslation\TranslatableMarkup;
use Drupal\field\Entity\FieldConfig;
use Drupal\field\Entity\FieldStorageConfig;
use Drupal\layout_builder\LayoutEntityHelperTrait;
use Drupal\layout_builder\Plugin\SectionStorage\OverridesSectionStorage;
use Drupal\layout_builder\QuickEditIntegration;
use Drupal\layout_builder\Section;
use Drupal\layout_builder\SectionComponent;
use Drupal\layout_builder\SectionListTrait;
class LayoutBuilderEntityViewDisplay extends BaseEntityViewDisplay implements LayoutEntityDisplayInterface {
use LayoutEntityHelperTrait;
use SectionListTrait;
protected $entityFieldManager;
public function __construct(array $values, $entity_type) {
$this->entityFieldManager = \Drupal::service('entity_field.manager');
parent::__construct($values, $entity_type);
}
public function isOverridable() {
return $this
->isLayoutBuilderEnabled() && $this
->getThirdPartySetting('layout_builder', 'allow_custom', FALSE);
}
public function setOverridable($overridable = TRUE) {
$this
->setThirdPartySetting('layout_builder', 'allow_custom', $overridable);
if ($overridable && !$this
->isLayoutBuilderEnabled()) {
$this
->enableLayoutBuilder();
}
return $this;
}
public function isLayoutBuilderEnabled() {
if ($this
->isCustomMode()) {
return FALSE;
}
return (bool) $this
->getThirdPartySetting('layout_builder', 'enabled');
}
public function enableLayoutBuilder() {
$this
->setThirdPartySetting('layout_builder', 'enabled', TRUE);
return $this;
}
public function disableLayoutBuilder() {
$this
->setOverridable(FALSE);
$this
->setThirdPartySetting('layout_builder', 'enabled', FALSE);
return $this;
}
public function getSections() {
return $this
->getThirdPartySetting('layout_builder', 'sections', []);
}
protected function setSections(array $sections) {
if (!$sections) {
$this
->unsetThirdPartySetting('layout_builder', 'sections');
}
else {
$this
->setThirdPartySetting('layout_builder', 'sections', array_values($sections));
}
return $this;
}
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) {
$components = $this
->getComponents();
uasort($components, 'Drupal\\Component\\Utility\\SortArray::sortByWeightElement');
foreach ($components as $name => $component) {
$this
->setComponent($name, $component);
}
}
else {
$this
->removeAllSections();
}
}
}
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();
}
}
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();
}
}
public function createCopy($mode) {
return parent::createCopy($mode)
->setSections([])
->disableLayoutBuilder();
}
protected function getDefaultRegion() {
if ($this
->hasSection(0)) {
return $this
->getSection(0)
->getDefaultRegion();
}
return parent::getDefaultRegion();
}
protected function contextRepository() {
return \Drupal::service('context.repository');
}
protected function isCustomMode() {
return $this
->getOriginalMode() === static::CUSTOM_MODE;
}
public function buildMultiple(array $entities) {
$build_list = parent::buildMultiple($entities);
if ($this
->isCustomMode()) {
return $build_list;
}
foreach ($entities as $id => $entity) {
$build_list[$id]['_layout_builder'] = $this
->buildSections($entity);
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;
}
protected function buildSections(FieldableEntityInterface $entity) {
$contexts = $this
->getContextsForEntity($entity);
$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);
}
}
$cacheability
->applyTo($build);
return $build;
}
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);
}
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(),
]);
}
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;
}
public function onDependencyRemoval(array $dependencies) {
$changed = parent::onDependencyRemoval($dependencies);
foreach ($this
->getSections() as $delta => $section) {
$layout_dependencies = $this
->getPluginDependencies($section
->getLayout());
$layout_removed_dependencies = $this
->getPluginRemovedDependencies($layout_dependencies, $dependencies);
if ($layout_removed_dependencies) {
$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) {
$section
->removeComponent($uuid);
$changed = TRUE;
}
}
}
}
return $changed;
}
public function setComponent($name, array $options = []) {
parent::setComponent($name, $options);
if (!$this
->isLayoutBuilderEnabled()) {
return $this;
}
$options = $this->content[$name];
$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;
}
protected function getDefaultSection() {
if (!$this
->hasSection(0)) {
$this
->appendSection(new Section('layout_onecol'));
}
return $this
->getSection(0);
}
private function sectionStorageManager() {
return \Drupal::service('plugin.manager.layout_builder.section_storage');
}
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);
}
private function getQuickEditSectionComponent() {
if ($original_mode = $this
->getOriginalMode()) {
$parts = explode('-', $original_mode);
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();
if ($plugin instanceof DerivativeInspectionInterface && $plugin
->getBaseId() === 'field_block') {
return $component;
}
}
}
}
return NULL;
}
private function getSectionComponentForFieldName($field_name) {
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)) {
list(, , $field_block_field_name) = explode(PluginBase::DERIVATIVE_SEPARATOR, $plugin
->getDerivativeId());
if ($field_block_field_name === $field_name) {
return $component;
}
}
}
}
return NULL;
}
}