Same filename and directory in other branches
- 8.9.x core/lib/Drupal/Core/Entity/EntityDisplayBase.php
- 9 core/lib/Drupal/Core/Entity/EntityDisplayBase.php
Namespace
Drupal\Core\Entity
File
core/lib/Drupal/Core/Entity/EntityDisplayBase.php
View source
<?php
namespace Drupal\Core\Entity;
use Drupal\Core\Config\Entity\ConfigEntityBase;
use Drupal\Core\Config\Entity\ConfigEntityInterface;
use Drupal\Core\Field\FieldDefinitionInterface;
use Drupal\Core\Entity\Display\EntityDisplayInterface;
abstract class EntityDisplayBase extends ConfigEntityBase implements EntityDisplayInterface {
const CUSTOM_MODE = '_custom';
protected $id;
protected $targetEntityType;
protected $bundle;
protected $fieldDefinitions;
protected $mode = self::CUSTOM_MODE;
protected $status;
protected $content = [];
protected $hidden = [];
protected $originalMode;
protected $plugins = [];
protected $displayContext;
protected $pluginManager;
protected $renderer;
protected $initialized = FALSE;
public function __construct(array $values, $entity_type) {
if (!isset($values['targetEntityType']) || !isset($values['bundle'])) {
throw new \InvalidArgumentException('Missing required properties for an EntityDisplay entity.');
}
if (!$this
->entityTypeManager()
->getDefinition($values['targetEntityType'])
->entityClassImplements(FieldableEntityInterface::class)) {
throw new \InvalidArgumentException('EntityDisplay entities can only handle fieldable entity types.');
}
$this->renderer = \Drupal::service('renderer');
if (!isset($this->pluginManager)) {
throw new \RuntimeException('Missing plugin manager.');
}
if (!isset($this->displayContext)) {
throw new \RuntimeException('Missing display context type.');
}
parent::__construct($values, $entity_type);
$this->originalMode = $this->mode;
$this
->init();
}
protected function init() {
if (!$this->initialized && $this->mode !== static::CUSTOM_MODE) {
$this->initialized = TRUE;
$default_region = $this
->getDefaultRegion();
$context = $this->displayContext == 'view' ? 'display' : $this->displayContext;
$extra_fields = \Drupal::service('entity_field.manager')
->getExtraFields($this->targetEntityType, $this->bundle);
$extra_fields = $extra_fields[$context] ?? [];
foreach ($extra_fields as $name => $definition) {
if (!isset($this->content[$name]) && !isset($this->hidden[$name])) {
if (!isset($definition['visible']) || $definition['visible'] == TRUE) {
$this
->setComponent($name, [
'weight' => $definition['weight'],
]);
}
else {
$this
->removeComponent($name);
}
}
if (isset($this->content[$name])) {
$this->content[$name] += [
'region' => $default_region,
];
}
}
$fields = $this
->getFieldDefinitions();
foreach ($fields as $name => $definition) {
if (!$definition
->isDisplayConfigurable($this->displayContext) || !isset($this->content[$name]) && !isset($this->hidden[$name])) {
$options = $definition
->getDisplayOptions($this->displayContext);
if (!empty($options['region']) && $options['region'] === 'hidden') {
$this
->removeComponent($name);
}
elseif ($options) {
$options += [
'region' => $default_region,
];
$this
->setComponent($name, $options);
}
}
}
}
}
public function getTargetEntityTypeId() {
return $this->targetEntityType;
}
public function getMode() {
return $this
->get('mode');
}
public function getOriginalMode() {
return $this
->get('originalMode');
}
public function getTargetBundle() {
return $this->bundle;
}
public function setTargetBundle($bundle) {
$this
->set('bundle', $bundle);
return $this;
}
public function id() {
return $this->targetEntityType . '.' . $this->bundle . '.' . $this->mode;
}
public function preSave(EntityStorageInterface $storage) {
foreach ($this
->getComponents() as $name => $component) {
if (isset($this->content[$name]) && !isset($component['region'])) {
$this->content[$name]['region'] = $this
->getDefaultRegion();
}
}
ksort($this->content);
ksort($this->hidden);
parent::preSave($storage);
}
public function calculateDependencies() {
parent::calculateDependencies();
$target_entity_type = $this
->entityTypeManager()
->getDefinition($this->targetEntityType);
$bundle_config_dependency = $target_entity_type
->getBundleConfigDependency($this->bundle);
$this
->addDependency($bundle_config_dependency['type'], $bundle_config_dependency['name']);
if (\Drupal::moduleHandler()
->moduleExists('field')) {
$components = $this->content + $this->hidden;
$field_definitions = \Drupal::service('entity_field.manager')
->getFieldDefinitions($this->targetEntityType, $this->bundle);
foreach (array_intersect_key($field_definitions, $components) as $field_definition) {
if ($field_definition instanceof ConfigEntityInterface && $field_definition
->getEntityTypeId() == 'field_config') {
$this
->addDependency('config', $field_definition
->getConfigDependencyName());
}
}
}
if ($this->mode != 'default') {
$mode_entity = $this
->entityTypeManager()
->getStorage('entity_' . $this->displayContext . '_mode')
->load($target_entity_type
->id() . '.' . $this->mode);
$this
->addDependency('config', $mode_entity
->getConfigDependencyName());
}
return $this;
}
public function toArray() {
$properties = parent::toArray();
foreach ($this
->getFieldDefinitions() as $field_name => $definition) {
if (!$definition
->isDisplayConfigurable($this->displayContext)) {
unset($properties['content'][$field_name]);
unset($properties['hidden'][$field_name]);
}
}
return $properties;
}
public function createCopy($mode) {
$display = $this
->createDuplicate();
$display->mode = $display->originalMode = $mode;
return $display;
}
public function getComponents() {
return $this->content;
}
public function getComponent($name) {
return $this->content[$name] ?? NULL;
}
public function setComponent($name, array $options = []) {
if (!isset($options['weight'])) {
$max = $this
->getHighestWeight();
$options['weight'] = isset($max) ? $max + 1 : 0;
}
if ($field_definition = $this
->getFieldDefinition($name)) {
$options = $this->pluginManager
->prepareConfiguration($field_definition
->getType(), $options);
}
$options += [
'settings' => [],
'third_party_settings' => [],
];
$this->content[$name] = $options;
unset($this->hidden[$name]);
unset($this->plugins[$name]);
return $this;
}
public function removeComponent($name) {
$this->hidden[$name] = TRUE;
unset($this->content[$name]);
unset($this->plugins[$name]);
return $this;
}
public function getHighestWeight() {
$weights = [];
foreach ($this->content as $options) {
if (isset($options['weight'])) {
$weights[] = $options['weight'];
}
}
$weights = array_merge($weights, \Drupal::moduleHandler()
->invokeAll('field_info_max_weight', [
$this->targetEntityType,
$this->bundle,
$this->displayContext,
$this->mode,
]));
return $weights ? max($weights) : NULL;
}
protected function getFieldDefinition($field_name) {
$definitions = $this
->getFieldDefinitions();
return $definitions[$field_name] ?? NULL;
}
protected function getFieldDefinitions() {
if (!isset($this->fieldDefinitions)) {
$definitions = \Drupal::service('entity_field.manager')
->getFieldDefinitions($this->targetEntityType, $this->bundle);
if ($this->mode !== static::CUSTOM_MODE) {
$definitions = array_filter($definitions, [
$this,
'fieldHasDisplayOptions',
]);
}
$this->fieldDefinitions = $definitions;
}
return $this->fieldDefinitions;
}
private function fieldHasDisplayOptions(FieldDefinitionInterface $definition) {
return $definition
->getDisplayOptions($this->displayContext);
}
public function onDependencyRemoval(array $dependencies) {
$changed = parent::onDependencyRemoval($dependencies);
foreach ($dependencies['config'] as $entity) {
if ($entity
->getEntityTypeId() == 'field_config') {
$this
->removeComponent($entity
->getName());
unset($this->hidden[$entity
->getName()]);
$changed = TRUE;
}
}
foreach ($this
->getComponents() as $name => $component) {
if ($renderer = $this
->getRenderer($name)) {
if (in_array($renderer
->getPluginDefinition()['provider'], $dependencies['module'])) {
$this
->setComponent($name);
$changed = TRUE;
}
$component_removed_dependencies = $this
->getPluginRemovedDependencies($renderer
->calculateDependencies(), $dependencies);
if ($component_removed_dependencies) {
if ($renderer
->onDependencyRemoval($component_removed_dependencies)) {
$component['settings'] = $renderer
->getSettings();
$component['third_party_settings'] = [];
foreach ($renderer
->getThirdPartyProviders() as $module) {
$component['third_party_settings'][$module] = $renderer
->getThirdPartySettings($module);
}
$this
->setComponent($name, $component);
$changed = TRUE;
}
if ($this
->getPluginRemovedDependencies($renderer
->calculateDependencies(), $dependencies)) {
$this
->removeComponent($name);
$arguments = [
'@display' => (string) $this
->getEntityType()
->getLabel(),
'@id' => $this
->id(),
'@name' => $name,
];
$this
->getLogger()
->warning("@display '@id': Component '@name' was disabled because its settings depend on removed dependencies.", $arguments);
$changed = TRUE;
}
}
}
}
return $changed;
}
protected function getPluginRemovedDependencies(array $plugin_dependencies, array $removed_dependencies) {
$intersect = [];
foreach ($plugin_dependencies as $type => $dependencies) {
if ($removed_dependencies[$type]) {
if (in_array($type, [
'config',
'content',
])) {
$removed = array_intersect_key($removed_dependencies[$type], array_flip($dependencies));
}
else {
$removed = array_values(array_intersect($removed_dependencies[$type], $dependencies));
}
if ($removed) {
$intersect[$type] = $removed;
}
}
}
return $intersect;
}
protected function getDefaultRegion() {
return 'content';
}
public function __sleep() {
$keys = array_keys($this
->toArray());
$keys[] = 'entityTypeId';
$keys[] = 'enforceIsNew';
$keys[] = '_serializedKeys';
$keys[] = 'initialized';
$this->_serializedKeys = $keys;
return $keys;
}
public function __wakeup() {
$keys = $this->_serializedKeys;
unset($this->_serializedKeys);
$values = array_intersect_key(get_object_vars($this), array_flip($keys));
$this
->__construct($values, $this->entityTypeId);
}
protected function getLogger() {
return \Drupal::logger('system');
}
}
Classes