Code Coverage |
||||||||||
Classes and Traits |
Functions and Methods |
Lines |
||||||||
| Total | |
0.00% |
0 / 1 |
|
60.78% |
31 / 51 |
CRAP | |
65.33% |
98 / 150 |
| Entity | |
0.00% |
0 / 1 |
|
61.54% |
32 / 52 |
427.46 | |
65.33% |
98 / 150 |
| __construct | |
100.00% |
1 / 1 |
2 | |
100.00% |
4 / 4 |
|||
| entityManager | |
100.00% |
1 / 1 |
1 | |
100.00% |
0 / 0 |
|||
| entityTypeManager | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 1 |
|||
| languageManager | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 1 |
|||
| uuidGenerator | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 1 |
|||
| id | |
100.00% |
1 / 1 |
2 | |
100.00% |
1 / 1 |
|||
| uuid | |
100.00% |
1 / 1 |
2 | |
100.00% |
1 / 1 |
|||
| isNew | |
100.00% |
1 / 1 |
2 | |
100.00% |
1 / 1 |
|||
| enforceIsNew | |
100.00% |
1 / 1 |
1 | |
100.00% |
2 / 2 |
|||
| getEntityTypeId | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| bundle | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| label | |
100.00% |
1 / 1 |
5 | |
100.00% |
7 / 7 |
|||
| urlInfo | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| toUrl | |
0.00% |
0 / 1 |
11.50 | |
84.00% |
21 / 25 |
|||
| hasLinkTemplate | |
100.00% |
1 / 1 |
1 | |
100.00% |
2 / 2 |
|||
| linkTemplates | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 1 |
|||
| link | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| toLink | |
100.00% |
1 / 1 |
2 | |
100.00% |
6 / 6 |
|||
| url | |
100.00% |
1 / 1 |
3 | |
100.00% |
6 / 6 |
|||
| urlRouteParameters | |
0.00% |
0 / 1 |
12 | |
0.00% |
0 / 6 |
|||
| uriRelationships | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 1 |
|||
| access | |
100.00% |
1 / 1 |
2 | |
100.00% |
7 / 7 |
|||
| language | |
0.00% |
0 / 1 |
4.84 | |
62.50% |
5 / 8 |
|||
| save | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| delete | |
100.00% |
1 / 1 |
2 | |
100.00% |
3 / 3 |
|||
| createDuplicate | |
0.00% |
0 / 1 |
6 | |
0.00% |
0 / 7 |
|||
| getEntityType | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| preSave | |
0.00% |
0 / 1 |
4.12 | |
50.00% |
2 / 4 |
|||
| postSave | |
100.00% |
1 / 1 |
1 | |
100.00% |
2 / 2 |
|||
| preCreate | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| postCreate | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| preDelete | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| postDelete | |
100.00% |
1 / 1 |
1 | |
100.00% |
2 / 2 |
|||
| postLoad | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| referencedEntities | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| getCacheContexts | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| getCacheTagsToInvalidate | |
0.00% |
0 / 1 |
2.15 | |
66.67% |
2 / 3 |
|||
| getCacheTags | |
100.00% |
1 / 1 |
2 | |
100.00% |
3 / 3 |
|||
| getCacheMaxAge | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| load | |
100.00% |
1 / 1 |
1 | |
100.00% |
2 / 2 |
|||
| loadMultiple | |
100.00% |
1 / 1 |
1 | |
100.00% |
2 / 2 |
|||
| create | |
100.00% |
1 / 1 |
1 | |
100.00% |
2 / 2 |
|||
| invalidateTagsOnSave | |
0.00% |
0 / 1 |
12 | |
0.00% |
0 / 7 |
|||
| invalidateTagsOnDelete | |
0.00% |
0 / 1 |
6 | |
0.00% |
0 / 5 |
|||
| getOriginalId | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 1 |
|||
| setOriginalId | |
0.00% |
0 / 1 |
6 | |
0.00% |
0 / 3 |
|||
| toArray | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 1 |
|||
| getTypedData | |
0.00% |
0 / 1 |
6 | |
0.00% |
0 / 4 |
|||
| __sleep | |
100.00% |
1 / 1 |
1 | |
100.00% |
2 / 2 |
|||
| getConfigDependencyKey | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 1 |
|||
| getConfigDependencyName | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 1 |
|||
| getConfigTarget | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 1 |
|||
| <?php | |
| /** | |
| * @file | |
| * Contains \Drupal\Core\Entity\Entity. | |
| */ | |
| namespace Drupal\Core\Entity; | |
| use Drupal\Core\Cache\Cache; | |
| use Drupal\Core\Cache\RefinableCacheableDependencyTrait; | |
| use Drupal\Core\DependencyInjection\DependencySerializationTrait; | |
| use Drupal\Component\Utility\Unicode; | |
| use Drupal\Core\Config\Entity\Exception\ConfigEntityIdLengthException; | |
| use Drupal\Core\Entity\Exception\UndefinedLinkTemplateException; | |
| use Drupal\Core\Language\Language; | |
| use Drupal\Core\Language\LanguageInterface; | |
| use Drupal\Core\Link; | |
| use Drupal\Core\Session\AccountInterface; | |
| use Drupal\Core\Url; | |
| /** | |
| * Defines a base entity class. | |
| */ | |
| abstract class Entity implements EntityInterface { | |
| use RefinableCacheableDependencyTrait; | |
| use DependencySerializationTrait { | |
| __sleep as traitSleep; | |
| } | |
| /** | |
| * The entity type. | |
| * | |
| * @var string | |
| */ | |
| protected $entityTypeId; | |
| /** | |
| * Boolean indicating whether the entity should be forced to be new. | |
| * | |
| * @var bool | |
| */ | |
| protected $enforceIsNew; | |
| /** | |
| * A typed data object wrapping this entity. | |
| * | |
| * @var \Drupal\Core\TypedData\ComplexDataInterface | |
| */ | |
| protected $typedData; | |
| /** | |
| * Constructs an Entity object. | |
| * | |
| * @param array $values | |
| * An array of values to set, keyed by property name. If the entity type | |
| * has bundles, the bundle key has to be specified. | |
| * @param string $entity_type | |
| * The type of the entity to create. | |
| */ | |
| public function __construct(array $values, $entity_type) { | |
| $this->entityTypeId = $entity_type; | |
| // Set initial values. | |
| foreach ($values as $key => $value) { | |
| $this->$key = $value; | |
| } | |
| } | |
| /** | |
| * Gets the entity manager. | |
| * | |
| * @return \Drupal\Core\Entity\EntityManagerInterface | |
| * | |
| * @deprecated in Drupal 8.0.0 and will be removed before Drupal 9.0.0. | |
| * Use \Drupal::entityTypeManager() instead in most cases. If the needed | |
| * method is not on \Drupal\Core\Entity\EntityTypeManagerInterface, see the | |
| * deprecated \Drupal\Core\Entity\EntityManager to find the | |
| * correct interface or service. | |
| */ | |
| protected function entityManager() { | |
| return \Drupal::entityManager(); | |
| } | |
| /** | |
| * Gets the entity type manager. | |
| * | |
| * @return \Drupal\Core\Entity\EntityTypeManagerInterface | |
| */ | |
| protected function entityTypeManager() { | |
| return \Drupal::entityTypeManager(); | |
| } | |
| /** | |
| * Gets the language manager. | |
| * | |
| * @return \Drupal\Core\Language\LanguageManagerInterface | |
| */ | |
| protected function languageManager() { | |
| return \Drupal::languageManager(); | |
| } | |
| /** | |
| * Gets the UUID generator. | |
| * | |
| * @return \Drupal\Component\Uuid\UuidInterface | |
| */ | |
| protected function uuidGenerator() { | |
| return \Drupal::service('uuid'); | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function id() { | |
| return isset($this->id) ? $this->id : NULL; | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function uuid() { | |
| return isset($this->uuid) ? $this->uuid : NULL; | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function isNew() { | |
| return !empty($this->enforceIsNew) || !$this->id(); | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function enforceIsNew($value = TRUE) { | |
| $this->enforceIsNew = $value; | |
| return $this; | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function getEntityTypeId() { | |
| return $this->entityTypeId; | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function bundle() { | |
| return $this->entityTypeId; | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function label() { | |
| $label = NULL; | |
| $entity_type = $this->getEntityType(); | |
| if (($label_callback = $entity_type->getLabelCallback()) && is_callable($label_callback)) { | |
| $label = call_user_func($label_callback, $this); | |
| } | |
| elseif (($label_key = $entity_type->getKey('label')) && isset($this->{$label_key})) { | |
| $label = $this->{$label_key}; | |
| } | |
| return $label; | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function urlInfo($rel = 'canonical', array $options = []) { | |
| return $this->toUrl($rel, $options); | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function toUrl($rel = 'canonical', array $options = []) { | |
| if ($this->id() === NULL) { | |
| throw new EntityMalformedException(sprintf('The "%s" entity cannot have a URI as it does not have an ID', $this->getEntityTypeId())); | |
| } | |
| // The links array might contain URI templates set in annotations. | |
| $link_templates = $this->linkTemplates(); | |
| // Links pointing to the current revision point to the actual entity. So | |
| // instead of using the 'revision' link, use the 'canonical' link. | |
| if ($rel === 'revision' && $this instanceof RevisionableInterface && $this->isDefaultRevision()) { | |
| $rel = 'canonical'; | |
| } | |
| if (isset($link_templates[$rel])) { | |
| $route_parameters = $this->urlRouteParameters($rel); | |
| $route_name = "entity.{$this->entityTypeId}." . str_replace(array('-', 'drupal:'), array('_', ''), $rel); | |
| $uri = new Url($route_name, $route_parameters); | |
| } | |
| else { | |
| $bundle = $this->bundle(); | |
| // A bundle-specific callback takes precedence over the generic one for | |
| // the entity type. | |
| $bundles = $this->entityManager()->getBundleInfo($this->getEntityTypeId()); | |
| if (isset($bundles[$bundle]['uri_callback'])) { | |
| $uri_callback = $bundles[$bundle]['uri_callback']; | |
| } | |
| elseif ($entity_uri_callback = $this->getEntityType()->getUriCallback()) { | |
| $uri_callback = $entity_uri_callback; | |
| } | |
| // Invoke the callback to get the URI. If there is no callback, use the | |
| // default URI format. | |
| if (isset($uri_callback) && is_callable($uri_callback)) { | |
| $uri = call_user_func($uri_callback, $this); | |
| } | |
| else { | |
| throw new UndefinedLinkTemplateException("No link template '$rel' found for the '{$this->getEntityTypeId()}' entity type"); | |
| } | |
| } | |
| // Pass the entity data through as options, so that alter functions do not | |
| // need to look up this entity again. | |
| $uri | |
| ->setOption('entity_type', $this->getEntityTypeId()) | |
| ->setOption('entity', $this); | |
| // Display links by default based on the current language. | |
| if ($rel !== 'collection') { | |
| $options += ['language' => $this->language()]; | |
| } | |
| $uri_options = $uri->getOptions(); | |
| $uri_options += $options; | |
| return $uri->setOptions($uri_options); | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function hasLinkTemplate($rel) { | |
| $link_templates = $this->linkTemplates(); | |
| return isset($link_templates[$rel]); | |
| } | |
| /** | |
| * Gets an array link templates. | |
| * | |
| * @return array | |
| * An array of link templates containing paths. | |
| */ | |
| protected function linkTemplates() { | |
| return $this->getEntityType()->getLinkTemplates(); | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function link($text = NULL, $rel = 'canonical', array $options = []) { | |
| return $this->toLink($text, $rel, $options)->toString(); | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function toLink($text = NULL, $rel = 'canonical', array $options = []) { | |
| if (!isset($text)) { | |
| $text = $this->label(); | |
| } | |
| $url = $this->toUrl($rel); | |
| $options += $url->getOptions(); | |
| $url->setOptions($options); | |
| return new Link($text, $url); | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function url($rel = 'canonical', $options = array()) { | |
| // While self::toUrl() will throw an exception if the entity has no id, | |
| // the expected result for a URL is always a string. | |
| if ($this->id() === NULL || !$this->hasLinkTemplate($rel)) { | |
| return ''; | |
| } | |
| $uri = $this->toUrl($rel); | |
| $options += $uri->getOptions(); | |
| $uri->setOptions($options); | |
| return $uri->toString(); | |
| } | |
| /** | |
| * Gets an array of placeholders for this entity. | |
| * | |
| * Individual entity classes may override this method to add additional | |
| * placeholders if desired. If so, they should be sure to replicate the | |
| * property caching logic. | |
| * | |
| * @param string $rel | |
| * The link relationship type, for example: canonical or edit-form. | |
| * | |
| * @return array | |
| * An array of URI placeholders. | |
| */ | |
| protected function urlRouteParameters($rel) { | |
| $uri_route_parameters = []; | |
| if ($rel != 'collection') { | |
| // The entity ID is needed as a route parameter. | |
| $uri_route_parameters[$this->getEntityTypeId()] = $this->id(); | |
| } | |
| if ($rel === 'revision') { | |
| $uri_route_parameters[$this->getEntityTypeId() . '_revision'] = $this->getRevisionId(); | |
| } | |
| return $uri_route_parameters; | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function uriRelationships() { | |
| return array_keys($this->linkTemplates()); | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function access($operation, AccountInterface $account = NULL, $return_as_object = FALSE) { | |
| if ($operation == 'create') { | |
| return $this->entityManager() | |
| ->getAccessControlHandler($this->entityTypeId) | |
| ->createAccess($this->bundle(), $account, [], $return_as_object); | |
| } | |
| return $this->entityManager() | |
| ->getAccessControlHandler($this->entityTypeId) | |
| ->access($this, $operation, $account, $return_as_object); | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function language() { | |
| if ($key = $this->getEntityType()->getKey('langcode')) { | |
| $langcode = $this->$key; | |
| $language = $this->languageManager()->getLanguage($langcode); | |
| if ($language) { | |
| return $language; | |
| } | |
| } | |
| // Make sure we return a proper language object. | |
| $langcode = !empty($this->langcode) ? $this->langcode : LanguageInterface::LANGCODE_NOT_SPECIFIED; | |
| $language = new Language(array('id' => $langcode)); | |
| return $language; | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function save() { | |
| return $this->entityManager()->getStorage($this->entityTypeId)->save($this); | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function delete() { | |
| if (!$this->isNew()) { | |
| $this->entityManager()->getStorage($this->entityTypeId)->delete(array($this->id() => $this)); | |
| } | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function createDuplicate() { | |
| $duplicate = clone $this; | |
| $entity_type = $this->getEntityType(); | |
| // Reset the entity ID and indicate that this is a new entity. | |
| $duplicate->{$entity_type->getKey('id')} = NULL; | |
| $duplicate->enforceIsNew(); | |
| // Check if the entity type supports UUIDs and generate a new one if so. | |
| if ($entity_type->hasKey('uuid')) { | |
| $duplicate->{$entity_type->getKey('uuid')} = $this->uuidGenerator()->generate(); | |
| } | |
| return $duplicate; | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function getEntityType() { | |
| return $this->entityManager()->getDefinition($this->getEntityTypeId()); | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function preSave(EntityStorageInterface $storage) { | |
| // Check if this is an entity bundle. | |
| if ($this->getEntityType()->getBundleOf()) { | |
| // Throw an exception if the bundle ID is longer than 32 characters. | |
| if (Unicode::strlen($this->id()) > EntityTypeInterface::BUNDLE_MAX_LENGTH) { | |
| throw new ConfigEntityIdLengthException("Attempt to create a bundle with an ID longer than " . EntityTypeInterface::BUNDLE_MAX_LENGTH . " characters: $this->id()."); | |
| } | |
| } | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function postSave(EntityStorageInterface $storage, $update = TRUE) { | |
| $this->invalidateTagsOnSave($update); | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public static function preCreate(EntityStorageInterface $storage, array &$values) { | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function postCreate(EntityStorageInterface $storage) { | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public static function preDelete(EntityStorageInterface $storage, array $entities) { | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public static function postDelete(EntityStorageInterface $storage, array $entities) { | |
| static::invalidateTagsOnDelete($storage->getEntityType(), $entities); | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public static function postLoad(EntityStorageInterface $storage, array &$entities) { | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function referencedEntities() { | |
| return array(); | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function getCacheContexts() { | |
| return $this->cacheContexts; | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function getCacheTagsToInvalidate() { | |
| // @todo Add bundle-specific listing cache tag? | |
| // https://www.drupal.org/node/2145751 | |
| if ($this->isNew()) { | |
| return []; | |
| } | |
| return [$this->entityTypeId . ':' . $this->id()]; | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function getCacheTags() { | |
| if ($this->cacheTags) { | |
| return Cache::mergeTags($this->getCacheTagsToInvalidate(), $this->cacheTags); | |
| } | |
| return $this->getCacheTagsToInvalidate(); | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function getCacheMaxAge() { | |
| return $this->cacheMaxAge; | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public static function load($id) { | |
| $entity_manager = \Drupal::entityManager(); | |
| return $entity_manager->getStorage($entity_manager->getEntityTypeFromClass(get_called_class()))->load($id); | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public static function loadMultiple(array $ids = NULL) { | |
| $entity_manager = \Drupal::entityManager(); | |
| return $entity_manager->getStorage($entity_manager->getEntityTypeFromClass(get_called_class()))->loadMultiple($ids); | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public static function create(array $values = array()) { | |
| $entity_manager = \Drupal::entityManager(); | |
| return $entity_manager->getStorage($entity_manager->getEntityTypeFromClass(get_called_class()))->create($values); | |
| } | |
| /** | |
| * Invalidates an entity's cache tags upon save. | |
| * | |
| * @param bool $update | |
| * TRUE if the entity has been updated, or FALSE if it has been inserted. | |
| */ | |
| protected function invalidateTagsOnSave($update) { | |
| // An entity was created or updated: invalidate its list cache tags. (An | |
| // updated entity may start to appear in a listing because it now meets that | |
| // listing's filtering requirements. A newly created entity may start to | |
| // appear in listings because it did not exist before.) | |
| $tags = $this->getEntityType()->getListCacheTags(); | |
| if ($this->hasLinkTemplate('canonical')) { | |
| // Creating or updating an entity may change a cached 403 or 404 response. | |
| $tags = Cache::mergeTags($tags, ['4xx-response']); | |
| } | |
| if ($update) { | |
| // An existing entity was updated, also invalidate its unique cache tag. | |
| $tags = Cache::mergeTags($tags, $this->getCacheTagsToInvalidate()); | |
| } | |
| Cache::invalidateTags($tags); | |
| } | |
| /** | |
| * Invalidates an entity's cache tags upon delete. | |
| * | |
| * @param \Drupal\Core\Entity\EntityTypeInterface $entity_type | |
| * The entity type definition. | |
| * @param \Drupal\Core\Entity\EntityInterface[] $entities | |
| * An array of entities. | |
| */ | |
| protected static function invalidateTagsOnDelete(EntityTypeInterface $entity_type, array $entities) { | |
| $tags = $entity_type->getListCacheTags(); | |
| foreach ($entities as $entity) { | |
| // An entity was deleted: invalidate its own cache tag, but also its list | |
| // cache tags. (A deleted entity may cause changes in a paged list on | |
| // other pages than the one it's on. The one it's on is handled by its own | |
| // cache tag, but subsequent list pages would not be invalidated, hence we | |
| // must invalidate its list cache tags as well.) | |
| $tags = Cache::mergeTags($tags, $entity->getCacheTagsToInvalidate()); | |
| } | |
| Cache::invalidateTags($tags); | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function getOriginalId() { | |
| // By default, entities do not support renames and do not have original IDs. | |
| return NULL; | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function setOriginalId($id) { | |
| // By default, entities do not support renames and do not have original IDs. | |
| // If the specified ID is anything except NULL, this should mark this entity | |
| // as no longer new. | |
| if ($id !== NULL) { | |
| $this->enforceIsNew(FALSE); | |
| } | |
| return $this; | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function toArray() { | |
| return array(); | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function getTypedData() { | |
| if (!isset($this->typedData)) { | |
| $class = \Drupal::typedDataManager()->getDefinition('entity')['class']; | |
| $this->typedData = $class::createFromEntity($this); | |
| } | |
| return $this->typedData; | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function __sleep() { | |
| $this->typedData = NULL; | |
| return $this->traitSleep(); | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function getConfigDependencyKey() { | |
| return $this->getEntityType()->getConfigDependencyKey(); | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function getConfigDependencyName() { | |
| return $this->getEntityTypeId() . ':' . $this->bundle() . ':' . $this->uuid(); | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function getConfigTarget() { | |
| // For content entities, use the UUID for the config target identifier. | |
| // This ensures that references to the target can be deployed reliably. | |
| return $this->uuid(); | |
| } | |
| } |