Drupal
/
drupal
mirror of https://git.drupalcode.org/project/drupal.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Issue #2812811 by Sam152, timmillwood, amateescu, alexpott, catch: Use EntityPublishedInterface during moderation of entities to add support beyond nodes

8.3.x
Alex Pott 2017-01-18 17:38:15 +00:00
parent b1500e0704
commit d55b420af5
4 changed files with 206 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
core/modules/content_moderation/src/Entity/Handler/ModerationHandler.php
View File

@ -4,6 +4,7 @@ namespace Drupal\content_moderation\Entity\Handler;
use Drupal\Core\Entity\ContentEntityInterface; use Drupal\Core\Entity\ContentEntityInterface;
use Drupal\Core\Entity\EntityHandlerInterface; use Drupal\Core\Entity\EntityHandlerInterface;
use Drupal\Core\Entity\EntityPublishedInterface;
use Drupal\Core\Entity\EntityTypeInterface; use Drupal\Core\Entity\EntityTypeInterface;
use Drupal\Core\Form\FormStateInterface; use Drupal\Core\Form\FormStateInterface;
use Drupal\Core\StringTranslation\StringTranslationTrait; use Drupal\Core\StringTranslation\StringTranslationTrait;
@ -32,6 +33,11 @@ class ModerationHandler implements ModerationHandlerInterface, EntityHandlerInte
// This is probably not necessary if configuration is setup correctly. // This is probably not necessary if configuration is setup correctly.
$entity->setNewRevision(TRUE); $entity->setNewRevision(TRUE);
$entity->isDefaultRevision($default_revision); $entity->isDefaultRevision($default_revision);
// Update publishing status if it can be updated and if it needs updating.
if (($entity instanceof EntityPublishedInterface) && $entity->isPublished() !== $published_state) {
$published_state ? $entity->setPublished() : $entity->setUnpublished();
}
} }
/** /**

31
core/modules/content_moderation/src/Entity/Handler/NodeModerationHandler.php
View File

@ -3,7 +3,6 @@
namespace Drupal\content_moderation\Entity\Handler; namespace Drupal\content_moderation\Entity\Handler;
use Drupal\content_moderation\ModerationInformationInterface; use Drupal\content_moderation\ModerationInformationInterface;
use Drupal\Core\Entity\ContentEntityInterface;
use Drupal\Core\Entity\EntityTypeInterface; use Drupal\Core\Entity\EntityTypeInterface;
use Drupal\Core\Form\FormStateInterface; use Drupal\Core\Form\FormStateInterface;
use Symfony\Component\DependencyInjection\ContainerInterface; use Symfony\Component\DependencyInjection\ContainerInterface;
@ -39,18 +38,6 @@ class NodeModerationHandler extends ModerationHandler {
); );
} }
/**
* {@inheritdoc}
*/
public function onPresave(ContentEntityInterface $entity, $default_revision, $published_state) {
if ($this->shouldModerate($entity, $published_state)) {
parent::onPresave($entity, $default_revision, $published_state);
// Only nodes have a concept of published.
/** @var \Drupal\node\NodeInterface $entity */
$entity->setPublished($published_state);
}
}
/** /**
* {@inheritdoc} * {@inheritdoc}
*/ */
@ -74,22 +61,4 @@ class NodeModerationHandler extends ModerationHandler {
} }
} }
/**
* Check if an entity's default revision and/or state needs adjusting.
*
* @param \Drupal\Core\Entity\ContentEntityInterface $entity
* The entity to check.
* @param bool $published_state
* Whether the state being transitioned to is a published state or not.
*
* @return bool
* TRUE when either the default revision or the state needs to be updated.
*/
protected function shouldModerate(ContentEntityInterface $entity, $published_state) {
// @todo clarify the first condition.
// First condition is needed so you can add a translation.
// Second condition checks to see if the published status has changed.
return $entity->isDefaultTranslation() || $entity->isPublished() !== $published_state;
}
} }

231
core/modules/content_moderation/tests/src/Kernel/ContentModerationStateTest.php
View File

@ -3,14 +3,14 @@
namespace Drupal\Tests\content_moderation\Kernel; namespace Drupal\Tests\content_moderation\Kernel;
use Drupal\content_moderation\Entity\ContentModerationState; use Drupal\content_moderation\Entity\ContentModerationState;
use Drupal\Core\Entity\EntityPublishedInterface;
use Drupal\entity_test\Entity\EntityTestBundle; use Drupal\entity_test\Entity\EntityTestBundle;
use Drupal\entity_test\Entity\EntityTestRev;
use Drupal\entity_test\Entity\EntityTestWithBundle; use Drupal\entity_test\Entity\EntityTestWithBundle;
use Drupal\Core\Entity\EntityInterface;
use Drupal\KernelTests\KernelTestBase; use Drupal\KernelTests\KernelTestBase;
use Drupal\language\Entity\ConfigurableLanguage; use Drupal\language\Entity\ConfigurableLanguage;
use Drupal\node\Entity\Node; use Drupal\node\Entity\Node;
use Drupal\node\Entity\NodeType; use Drupal\node\Entity\NodeType;
use Drupal\node\NodeInterface;
use Drupal\workflows\Entity\Workflow; use Drupal\workflows\Entity\Workflow;
/** /**
@ -26,6 +26,7 @@ class ContentModerationStateTest extends KernelTestBase {
public static $modules = [ public static $modules = [
'entity_test', 'entity_test',
'node', 'node',
'block_content',
'content_moderation', 'content_moderation',
'user', 'user',
'system', 'system',
@ -35,6 +36,11 @@ class ContentModerationStateTest extends KernelTestBase {
'workflows', 'workflows',
]; ];
/**
* @var \Drupal\Core\Entity\EntityTypeManager
*/
protected $entityTypeManager;
/** /**
* {@inheritdoc} * {@inheritdoc}
*/ */
@ -46,36 +52,56 @@ class ContentModerationStateTest extends KernelTestBase {
$this->installEntitySchema('user'); $this->installEntitySchema('user');
$this->installEntitySchema('entity_test_with_bundle'); $this->installEntitySchema('entity_test_with_bundle');
$this->installEntitySchema('entity_test_rev'); $this->installEntitySchema('entity_test_rev');
$this->installEntitySchema('entity_test_mulrevpub');
$this->installEntitySchema('block_content');
$this->installEntitySchema('content_moderation_state'); $this->installEntitySchema('content_moderation_state');
$this->installConfig('content_moderation'); $this->installConfig('content_moderation');
$this->entityTypeManager = $this->container->get('entity_type.manager');
} }
/** /**
* Tests basic monolingual content moderation through the API. * Tests basic monolingual content moderation through the API.
*
* @dataProvider basicModerationTestCases
*/ */
public function testBasicModeration() { public function testBasicModeration($entity_type_id) {
$node_type = NodeType::create([ // Make the 'entity_test_with_bundle' entity type revisionable.
'type' => 'example', if ($entity_type_id == 'entity_test_with_bundle') {
$this->setEntityTestWithBundleKeys(['revision' => 'revision_id']);
}
$entity_storage = $this->entityTypeManager->getStorage($entity_type_id);
$bundle_id = $entity_type_id;
$bundle_entity_type_id = $this->entityTypeManager->getDefinition($entity_type_id)->getBundleEntityType();
if ($bundle_entity_type_id) {
$bundle_entity_type_definition = $this->entityTypeManager->getDefinition($bundle_entity_type_id);
$entity_type_storage = $this->entityTypeManager->getStorage($bundle_entity_type_id);
$entity_type = $entity_type_storage->create([
$bundle_entity_type_definition->getKey('id') => 'example',
]); ]);
$node_type->save(); $entity_type->save();
$bundle_id = $entity_type->id();
}
$workflow = Workflow::load('editorial'); $workflow = Workflow::load('editorial');
$workflow->getTypePlugin()->addEntityTypeAndBundle('node', 'example'); $workflow->getTypePlugin()->addEntityTypeAndBundle($entity_type_id, $bundle_id);
$workflow->save(); $workflow->save();
$node = Node::create([ $entity = $entity_storage->create([
'type' => 'example',
'title' => 'Test title', 'title' => 'Test title',
$this->entityTypeManager->getDefinition($entity_type_id)->getKey('bundle') => $bundle_id,
]); ]);
$node->save(); $entity->save();
$node = $this->reloadNode($node); $entity = $this->reloadEntity($entity);
$this->assertEquals('draft', $node->moderation_state->value); $this->assertEquals('draft', $entity->moderation_state->value);
$node->moderation_state->value = 'published'; $entity->moderation_state->value = 'published';
$node->save(); $entity->save();
$node = $this->reloadNode($node); $entity = $this->reloadEntity($entity);
$this->assertEquals('published', $node->moderation_state->value); $this->assertEquals('published', $entity->moderation_state->value);
// Change the state without saving the node. // Change the state without saving the node.
$content_moderation_state = ContentModerationState::load(1); $content_moderation_state = ContentModerationState::load(1);
@ -83,40 +109,71 @@ class ContentModerationStateTest extends KernelTestBase {
$content_moderation_state->setNewRevision(TRUE); $content_moderation_state->setNewRevision(TRUE);
$content_moderation_state->save(); $content_moderation_state->save();
$node = $this->reloadNode($node, 3); $entity = $this->reloadEntity($entity, 3);
$this->assertEquals('draft', $node->moderation_state->value); $this->assertEquals('draft', $entity->moderation_state->value);
$this->assertFalse($node->isPublished()); if ($entity instanceof EntityPublishedInterface) {
$this->assertFalse($entity->isPublished());
}
// Get the default revision. // Get the default revision.
$node = $this->reloadNode($node); $entity = $this->reloadEntity($entity);
$this->assertTrue($node->isPublished()); if ($entity instanceof EntityPublishedInterface) {
$this->assertEquals(2, $node->getRevisionId()); $this->assertTrue((bool) $entity->isPublished());
}
$this->assertEquals(2, $entity->getRevisionId());
$node->moderation_state->value = 'published'; $entity->moderation_state->value = 'published';
$node->save(); $entity->save();
$node = $this->reloadNode($node, 4); $entity = $this->reloadEntity($entity, 4);
$this->assertEquals('published', $node->moderation_state->value); $this->assertEquals('published', $entity->moderation_state->value);
// Get the default revision. // Get the default revision.
$node = $this->reloadNode($node); $entity = $this->reloadEntity($entity);
$this->assertTrue($node->isPublished()); if ($entity instanceof EntityPublishedInterface) {
$this->assertEquals(4, $node->getRevisionId()); $this->assertTrue((bool) $entity->isPublished());
}
$this->assertEquals(4, $entity->getRevisionId());
// Update the node to archived which will then be the default revision. // Update the node to archived which will then be the default revision.
$node->moderation_state->value = 'archived'; $entity->moderation_state->value = 'archived';
$node->save(); $entity->save();
// Revert to the previous (published) revision. // Revert to the previous (published) revision.
$previous_revision = \Drupal::entityTypeManager()->getStorage('node')->loadRevision(4); $previous_revision = $entity_storage->loadRevision(4);
$previous_revision->isDefaultRevision(TRUE); $previous_revision->isDefaultRevision(TRUE);
$previous_revision->setNewRevision(TRUE); $previous_revision->setNewRevision(TRUE);
$previous_revision->save(); $previous_revision->save();
// Get the default revision. // Get the default revision.
$node = $this->reloadNode($node); $entity = $this->reloadEntity($entity);
$this->assertEquals('published', $node->moderation_state->value); $this->assertEquals('published', $entity->moderation_state->value);
$this->assertTrue($node->isPublished()); if ($entity instanceof EntityPublishedInterface) {
$this->assertTrue($entity->isPublished());
}
}
/**
* Test cases for basic moderation test.
*/
public function basicModerationTestCases() {
return [
'Nodes' => [
'node',
],
'Block content' => [
'block_content',
],
'Test Entity with Bundle' => [
'entity_test_with_bundle',
],
'Test entity - revisions, data table, and published interface' => [
'entity_test_mulrevpub',
],
'Entity Test with revisions' => [
'entity_test_rev',
]
];
} }
/** /**
@ -140,37 +197,37 @@ class ContentModerationStateTest extends KernelTestBase {
]); ]);
// Revision 1 (en). // Revision 1 (en).
$english_node $english_node
->setPublished(FALSE) ->setUnpublished()
->save(); ->save();
$this->assertEquals('draft', $english_node->moderation_state->value); $this->assertEquals('draft', $english_node->moderation_state->value);
$this->assertFalse($english_node->isPublished()); $this->assertFalse($english_node->isPublished());
// Create a French translation. // Create a French translation.
$french_node = $english_node->addTranslation('fr', ['title' => 'French title']); $french_node = $english_node->addTranslation('fr', ['title' => 'French title']);
$french_node->setPublished(FALSE); $french_node->setUnpublished();
// Revision 1 (fr). // Revision 1 (fr).
$french_node->save(); $french_node->save();
$french_node = $this->reloadNode($english_node)->getTranslation('fr'); $french_node = $this->reloadEntity($english_node)->getTranslation('fr');
$this->assertEquals('draft', $french_node->moderation_state->value); $this->assertEquals('draft', $french_node->moderation_state->value);
$this->assertFalse($french_node->isPublished()); $this->assertFalse($french_node->isPublished());
// Move English node to create another draft. // Move English node to create another draft.
$english_node = $this->reloadNode($english_node); $english_node = $this->reloadEntity($english_node);
$english_node->moderation_state->value = 'draft'; $english_node->moderation_state->value = 'draft';
// Revision 2 (en, fr). // Revision 2 (en, fr).
$english_node->save(); $english_node->save();
$english_node = $this->reloadNode($english_node); $english_node = $this->reloadEntity($english_node);
$this->assertEquals('draft', $english_node->moderation_state->value); $this->assertEquals('draft', $english_node->moderation_state->value);
// French node should still be in draft. // French node should still be in draft.
$french_node = $this->reloadNode($english_node)->getTranslation('fr'); $french_node = $this->reloadEntity($english_node)->getTranslation('fr');
$this->assertEquals('draft', $french_node->moderation_state->value); $this->assertEquals('draft', $french_node->moderation_state->value);
// Publish the French node. // Publish the French node.
$french_node->moderation_state->value = 'published'; $french_node->moderation_state->value = 'published';
// Revision 3 (en, fr). // Revision 3 (en, fr).
$french_node->save(); $french_node->save();
$french_node = $this->reloadNode($french_node)->getTranslation('fr'); $french_node = $this->reloadEntity($french_node)->getTranslation('fr');
$this->assertTrue($french_node->isPublished()); $this->assertTrue($french_node->isPublished());
$this->assertEquals('published', $french_node->moderation_state->value); $this->assertEquals('published', $french_node->moderation_state->value);
$this->assertTrue($french_node->isPublished()); $this->assertTrue($french_node->isPublished());
@ -181,16 +238,16 @@ class ContentModerationStateTest extends KernelTestBase {
$english_node->moderation_state->value = 'published'; $english_node->moderation_state->value = 'published';
// Revision 4 (en, fr). // Revision 4 (en, fr).
$english_node->save(); $english_node->save();
$english_node = $this->reloadNode($english_node); $english_node = $this->reloadEntity($english_node);
$this->assertTrue($english_node->isPublished()); $this->assertTrue($english_node->isPublished());
// Move the French node back to draft. // Move the French node back to draft.
$french_node = $this->reloadNode($english_node)->getTranslation('fr'); $french_node = $this->reloadEntity($english_node)->getTranslation('fr');
$this->assertTrue($french_node->isPublished()); $this->assertTrue($french_node->isPublished());
$french_node->moderation_state->value = 'draft'; $french_node->moderation_state->value = 'draft';
// Revision 5 (en, fr). // Revision 5 (en, fr).
$french_node->save(); $french_node->save();
$french_node = $this->reloadNode($english_node, 5)->getTranslation('fr'); $french_node = $this->reloadEntity($english_node, 5)->getTranslation('fr');
$this->assertFalse($french_node->isPublished()); $this->assertFalse($french_node->isPublished());
$this->assertTrue($french_node->getTranslation('en')->isPublished()); $this->assertTrue($french_node->getTranslation('en')->isPublished());
@ -198,7 +255,7 @@ class ContentModerationStateTest extends KernelTestBase {
$french_node->moderation_state->value = 'published'; $french_node->moderation_state->value = 'published';
// Revision 6 (en, fr). // Revision 6 (en, fr).
$french_node->save(); $french_node->save();
$french_node = $this->reloadNode($english_node)->getTranslation('fr'); $french_node = $this->reloadEntity($english_node)->getTranslation('fr');
$this->assertTrue($french_node->isPublished()); $this->assertTrue($french_node->isPublished());
// Change the EN state without saving the node. // Change the EN state without saving the node.
@ -207,10 +264,10 @@ class ContentModerationStateTest extends KernelTestBase {
$content_moderation_state->setNewRevision(TRUE); $content_moderation_state->setNewRevision(TRUE);
// Revision 7 (en, fr). // Revision 7 (en, fr).
$content_moderation_state->save(); $content_moderation_state->save();
$english_node = $this->reloadNode($french_node, $french_node->getRevisionId() + 1); $english_node = $this->reloadEntity($french_node, $french_node->getRevisionId() + 1);
$this->assertEquals('draft', $english_node->moderation_state->value); $this->assertEquals('draft', $english_node->moderation_state->value);
$french_node = $this->reloadNode($english_node)->getTranslation('fr'); $french_node = $this->reloadEntity($english_node)->getTranslation('fr');
$this->assertEquals('published', $french_node->moderation_state->value); $this->assertEquals('published', $french_node->moderation_state->value);
// This should unpublish the French node. // This should unpublish the French node.
@ -221,16 +278,16 @@ class ContentModerationStateTest extends KernelTestBase {
// Revision 8 (en, fr). // Revision 8 (en, fr).
$content_moderation_state->save(); $content_moderation_state->save();
$english_node = $this->reloadNode($english_node, $english_node->getRevisionId()); $english_node = $this->reloadEntity($english_node, $english_node->getRevisionId());
$this->assertEquals('draft', $english_node->moderation_state->value); $this->assertEquals('draft', $english_node->moderation_state->value);
$french_node = $this->reloadNode($english_node, '8')->getTranslation('fr'); $french_node = $this->reloadEntity($english_node, '8')->getTranslation('fr');
$this->assertEquals('draft', $french_node->moderation_state->value); $this->assertEquals('draft', $french_node->moderation_state->value);
// Switching the moderation state to an unpublished state should update the // Switching the moderation state to an unpublished state should update the
// entity. // entity.
$this->assertFalse($french_node->isPublished()); $this->assertFalse($french_node->isPublished());
// Get the default english node. // Get the default english node.
$english_node = $this->reloadNode($english_node); $english_node = $this->reloadEntity($english_node);
$this->assertTrue($english_node->isPublished()); $this->assertTrue($english_node->isPublished());
$this->assertEquals(6, $english_node->getRevisionId()); $this->assertEquals(6, $english_node->getRevisionId());
} }
@ -240,12 +297,7 @@ class ContentModerationStateTest extends KernelTestBase {
*/ */
public function testNonTranslatableEntityTypeModeration() { public function testNonTranslatableEntityTypeModeration() {
// Make the 'entity_test_with_bundle' entity type revisionable. // Make the 'entity_test_with_bundle' entity type revisionable.
$entity_type = clone \Drupal::entityTypeManager()->getDefinition('entity_test_with_bundle'); $this->setEntityTestWithBundleKeys(['revision' => 'revision_id']);
$keys = $entity_type->getKeys();
$keys['revision'] = 'revision_id';
$entity_type->set('entity_keys', $keys);
\Drupal::state()->set('entity_test_with_bundle.entity_type', $entity_type);
\Drupal::entityDefinitionUpdateManager()->applyUpdates();
// Create a test bundle. // Create a test bundle.
$entity_test_bundle = EntityTestBundle::create([ $entity_test_bundle = EntityTestBundle::create([
@ -281,13 +333,7 @@ class ContentModerationStateTest extends KernelTestBase {
public function testNonLangcodeEntityTypeModeration() { public function testNonLangcodeEntityTypeModeration() {
// Make the 'entity_test_with_bundle' entity type revisionable and unset // Make the 'entity_test_with_bundle' entity type revisionable and unset
// the langcode entity key. // the langcode entity key.
$entity_type = clone \Drupal::entityTypeManager()->getDefinition('entity_test_with_bundle'); $this->setEntityTestWithBundleKeys(['revision' => 'revision_id'], ['langcode']);
$keys = $entity_type->getKeys();
$keys['revision'] = 'revision_id';
unset($keys['langcode']);
$entity_type->set('entity_keys', $keys);
\Drupal::state()->set('entity_test_with_bundle.entity_type', $entity_type);
\Drupal::entityDefinitionUpdateManager()->applyUpdates();
// Create a test bundle. // Create a test bundle.
$entity_test_bundle = EntityTestBundle::create([ $entity_test_bundle = EntityTestBundle::create([
@ -317,50 +363,43 @@ class ContentModerationStateTest extends KernelTestBase {
} }
/** /**
* Tests that entity types without config bundles can be moderated. * Set the keys on the test entity type.
*
* @param array $keys
* The entity keys to override
* @param array $remove_keys
* Keys to remove.
*/ */
public function testNonBundleConfigEntityTypeModeration() { protected function setEntityTestWithBundleKeys($keys, $remove_keys = []) {
$workflow = Workflow::load('editorial'); $entity_type = clone \Drupal::entityTypeManager()->getDefinition('entity_test_with_bundle');
$workflow->getTypePlugin()->addEntityTypeAndBundle('entity_test_rev', 'entity_test_rev'); $original_keys = $entity_type->getKeys();
$workflow->save(); foreach ($remove_keys as $remove_key) {
unset($original_keys[$remove_key]);
// Check that the tested entity type does not have bundles managed by a }
// config entity type. $entity_type->set('entity_keys', $keys + $original_keys);
$entity_type = \Drupal::entityTypeManager()->getDefinition('entity_test_rev'); \Drupal::state()->set('entity_test_with_bundle.entity_type', $entity_type);
$this->assertNull($entity_type->getBundleEntityType(), 'The test entity type does not have config bundles.'); \Drupal::entityDefinitionUpdateManager()->applyUpdates();
// Create a test entity.
$entity_test = EntityTestRev::create([
'type' => 'entity_test_rev'
]);
$entity_test->save();
$this->assertEquals('draft', $entity_test->moderation_state->value);
$entity_test->moderation_state->value = 'published';
$entity_test->save();
$this->assertEquals('published', EntityTestRev::load($entity_test->id())->moderation_state->value);
} }
/** /**
* Reloads the node after clearing the static cache. * Reloads the entity after clearing the static cache.
* *
* @param \Drupal\node\NodeInterface $node * @param \Drupal\Core\Entity\EntityInterface $entity
* The node to reload. * The entity to reload.
* @param int|false $revision_id * @param int|bool $revision_id
* The specific revision ID to load. Defaults FALSE and just loads the * The specific revision ID to load. Defaults FALSE and just loads the
* default revision. * default revision.
* *
* @return \Drupal\node\NodeInterface * @return \Drupal\Core\Entity\EntityInterface
* The reloaded node. * The reloaded entity.
*/ */
protected function reloadNode(NodeInterface $node, $revision_id = FALSE) { protected function reloadEntity(EntityInterface $entity, $revision_id = FALSE) {
$storage = \Drupal::entityTypeManager()->getStorage('node'); $storage = \Drupal::entityTypeManager()->getStorage($entity->getEntityTypeId());
$storage->resetCache([$node->id()]); $storage->resetCache([$entity->id()]);
if ($revision_id) { if ($revision_id) {
return $storage->loadRevision($revision_id); return $storage->loadRevision($revision_id);
} }
return $storage->load($node->id()); return $storage->load($entity->id());
} }
} }

64
core/modules/system/tests/modules/entity_test/src/Entity/EntityTestMulRevPub.php Normal file
View File

@ -0,0 +1,64 @@
<?php
namespace Drupal\entity_test\Entity;
use Drupal\Core\Entity\EntityPublishedInterface;
use Drupal\Core\Entity\EntityPublishedTrait;
use Drupal\Core\Entity\EntityTypeInterface;
/**
* Defines the test entity class.
*
* @ContentEntityType(
* id = "entity_test_mulrevpub",
* label = @Translation("Test entity - revisions, data table, and published interface"),
* handlers = {
* "view_builder" = "Drupal\entity_test\EntityTestViewBuilder",
* "access" = "Drupal\entity_test\EntityTestAccessControlHandler",
* "form" = {
* "default" = "Drupal\entity_test\EntityTestForm",
* "delete" = "Drupal\entity_test\EntityTestDeleteForm"
* },
* "translation" = "Drupal\content_translation\ContentTranslationHandler",
* "views_data" = "Drupal\views\EntityViewsData",
* "route_provider" = {
* "html" = "Drupal\Core\Entity\Routing\DefaultHtmlRouteProvider",
* },
* },
* base_table = "entity_test_mulrevpub",
* data_table = "entity_test_mulrevpub_property_data",
* revision_table = "entity_test_mulrevpub_revision",
* revision_data_table = "entity_test_mulrevpub_property_revision",
* admin_permission = "administer entity_test content",
* translatable = TRUE,
* show_revision_ui = TRUE,
* entity_keys = {
* "id" = "id",
* "uuid" = "uuid",
* "bundle" = "type",
* "revision" = "revision_id",
* "label" = "name",
* "langcode" = "langcode",
* "published" = "status",
* },
* links = {
* "add-form" = "/entity_test_mulrevpub/add",
* "canonical" = "/entity_test_mulrevpub/manage/{entity_test_mulrevpub}",
* "delete-form" = "/entity_test/delete/entity_test_mulrevpub/{entity_test_mulrevpub}",
* "edit-form" = "/entity_test_mulrevpub/manage/{entity_test_mulrevpub}/edit",
* "revision" = "/entity_test_mulrevpub/{entity_test_mulrevpub}/revision/{entity_test_mulrevpub_revision}/view",
* }
* )
*/
class EntityTestMulRevPub extends EntityTestMulRev implements EntityPublishedInterface {
use EntityPublishedTrait;
/**
* {@inheritdoc}
*/
public static function baseFieldDefinitions(EntityTypeInterface $entity_type) {
return parent::baseFieldDefinitions($entity_type) + EntityPublishedTrait::publishedBaseFieldDefinitions($entity_type);
}
}