diff --git a/core/lib/Drupal/Core/Entity/Sql/SqlContentEntityStorageSchema.php b/core/lib/Drupal/Core/Entity/Sql/SqlContentEntityStorageSchema.php index 3cfc34b..e1f5fbc 100644 --- a/core/lib/Drupal/Core/Entity/Sql/SqlContentEntityStorageSchema.php +++ b/core/lib/Drupal/Core/Entity/Sql/SqlContentEntityStorageSchema.php @@ -130,11 +130,31 @@ public function requiresEntityStorageSchemaChanges(EntityTypeInterface $entity_t $entity_type->getStorageClass() != $original->getStorageClass() || $entity_type->isRevisionable() != $original->isRevisionable() || $entity_type->isTranslatable() != $original->isTranslatable() || + $this->hasSharedTableNameChanges($entity_type, $original) || // Detect changes in key or index definitions. $this->getEntitySchemaData($entity_type, $this->getEntitySchema($entity_type, TRUE)) != $this->loadEntitySchemaData($original); } /** + * Detects whether any table name got renamed in an entity type update. + * + * @param \Drupal\Core\Entity\EntityTypeInterface $entity_type + * The new entity type. + * @param \Drupal\Core\Entity\EntityTypeInterface $original + * The origin entity type. + * + * @return bool + * Returns TRUE if there have been changes. + */ + protected function hasSharedTableNameChanges(EntityTypeInterface $entity_type, EntityTypeInterface $original) { + return + $entity_type->getBaseTable() != $original->getBaseTable() || + $entity_type->getDataTable() != $original->getDataTable() || + $entity_type->getRevisionTable() != $original->getRevisionTable() || + $entity_type->getRevisionDataTable() != $original->getRevisionDataTable(); + } + + /** * {@inheritdoc} */ public function requiresFieldStorageSchemaChanges(FieldStorageDefinitionInterface $storage_definition, FieldStorageDefinitionInterface $original) { diff --git a/core/modules/system/src/Tests/Entity/EntityDefinitionTestTrait.php b/core/modules/system/src/Tests/Entity/EntityDefinitionTestTrait.php new file mode 100644 index 0000000..25da8f2 --- /dev/null +++ b/core/modules/system/src/Tests/Entity/EntityDefinitionTestTrait.php @@ -0,0 +1,241 @@ +state->set('entity_test_update.entity_type', NULL); + $this->entityManager->clearCachedDefinitions(); + $this->entityDefinitionUpdateManager->applyUpdates(); + } + + /** + * Updates the 'entity_test_update' entity type to revisionable. + */ + protected function updateEntityTypeToRevisionable() { + $entity_type = clone $this->entityManager->getDefinition('entity_test_update'); + + $keys = $entity_type->getKeys(); + $keys['revision'] = 'revision_id'; + $entity_type->set('entity_keys', $keys); + + $this->state->set('entity_test_update.entity_type', $entity_type); + $this->entityManager->clearCachedDefinitions(); + } + + /** + * Updates the 'entity_test_update' entity type not revisionable. + */ + protected function updateEntityTypeToNotRevisionable() { + $entity_type = clone $this->entityManager->getDefinition('entity_test_update'); + + $keys = $entity_type->getKeys(); + unset($keys['revision']); + $entity_type->set('entity_keys', $keys); + + $this->state->set('entity_test_update.entity_type', $entity_type); + $this->entityManager->clearCachedDefinitions(); + } + + /** + * Updates the 'entity_test_update' entity type to translatable. + */ + protected function updateEntityTypeToTranslatable() { + $entity_type = clone $this->entityManager->getDefinition('entity_test_update'); + + $entity_type->set('translatable', TRUE); + $entity_type->set('data_table', 'entity_test_update_data'); + + if ($entity_type->isRevisionable()) { + $entity_type->set('revision_data_table', 'entity_test_update_revision_data'); + } + + $this->state->set('entity_test_update.entity_type', $entity_type); + $this->entityManager->clearCachedDefinitions(); + } + + /** + * Updates the 'entity_test_update' entity type to not translatable. + */ + protected function updateEntityTypeToNotTranslatable() { + $entity_type = clone $this->entityManager->getDefinition('entity_test_update'); + + $entity_type->set('translatable', FALSE); + $entity_type->set('data_table', NULL); + + if ($entity_type->isRevisionable()) { + $entity_type->set('revision_data_table', NULL); + } + + $this->state->set('entity_test_update.entity_type', $entity_type); + $this->entityManager->clearCachedDefinitions(); + } + + /** + * Adds a new base field to the 'entity_test_update' entity type. + * + * @param string $type + * (optional) The field type for the new field. Defaults to 'string'. + */ + protected function addBaseField($type = 'string') { + $definitions['new_base_field'] = BaseFieldDefinition::create($type) + ->setName('new_base_field') + ->setLabel(t('A new base field')); + $this->state->set('entity_test_update.additional_base_field_definitions', $definitions); + $this->entityManager->clearCachedDefinitions(); + } + + /** + * Modifies the new base field from 'string' to 'text'. + */ + protected function modifyBaseField() { + $this->addBaseField('text'); + } + + /** + * Removes the new base field from the 'entity_test_update' entity type. + */ + protected function removeBaseField() { + $this->state->delete('entity_test_update.additional_base_field_definitions'); + $this->entityManager->clearCachedDefinitions(); + } + + /** + * Adds a single-field index to the base field. + */ + protected function addBaseFieldIndex() { + $this->state->set('entity_test_update.additional_field_index.entity_test_update.new_base_field', TRUE); + $this->entityManager->clearCachedDefinitions(); + } + + /** + * Removes the index added in addBaseFieldIndex(). + */ + protected function removeBaseFieldIndex() { + $this->state->delete('entity_test_update.additional_field_index.entity_test_update.new_base_field'); + $this->entityManager->clearCachedDefinitions(); + } + + /** + * Adds a new bundle field to the 'entity_test_update' entity type. + * + * @param string $type + * (optional) The field type for the new field. Defaults to 'string'. + */ + protected function addBundleField($type = 'string') { + $definitions['new_bundle_field'] = FieldStorageDefinition::create($type) + ->setName('new_bundle_field') + ->setLabel(t('A new bundle field')) + ->setTargetEntityTypeId('entity_test_update'); + $this->state->set('entity_test_update.additional_field_storage_definitions', $definitions); + $this->state->set('entity_test_update.additional_bundle_field_definitions.test_bundle', $definitions); + $this->entityManager->clearCachedDefinitions(); + } + + /** + * Modifies the new bundle field from 'string' to 'text'. + */ + protected function modifyBundleField() { + $this->addBundleField('text'); + } + + /** + * Removes the new bundle field from the 'entity_test_update' entity type. + */ + protected function removeBundleField() { + $this->state->delete('entity_test_update.additional_field_storage_definitions'); + $this->state->delete('entity_test_update.additional_bundle_field_definitions.test_bundle'); + $this->entityManager->clearCachedDefinitions(); + } + + /** + * Adds an index to the 'entity_test_update' entity type's base table. + * + * @see \Drupal\entity_test\EntityTestStorageSchema::getEntitySchema(). + */ + protected function addEntityIndex() { + $indexes = array( + 'entity_test_update__new_index' => array('name', 'user_id'), + ); + $this->state->set('entity_test_update.additional_entity_indexes', $indexes); + } + + /** + * Removes the index added in addEntityIndex(). + */ + protected function removeEntityIndex() { + $this->state->delete('entity_test_update.additional_entity_indexes'); + } + + /** + * Renames the base table to 'entity_test_update_new'. + */ + protected function renameBaseTable() { + $entity_type = clone $this->entityManager->getDefinition('entity_test_update'); + + $entity_type->set('base_table', 'entity_test_update_new'); + + $this->state->set('entity_test_update.entity_type', $entity_type); + $this->entityManager->clearCachedDefinitions(); + } + + /** + * Renames the data table to 'entity_test_update_data_new'. + */ + protected function renameDataTable() { + $entity_type = clone $this->entityManager->getDefinition('entity_test_update'); + + $entity_type->set('data_table', 'entity_test_update_data_new'); + + $this->state->set('entity_test_update.entity_type', $entity_type); + $this->entityManager->clearCachedDefinitions(); + } + + /** + * Renames the revision table to 'entity_test_update_revision_new'. + */ + protected function renameRevisionBaseTable() { + $entity_type = clone $this->entityManager->getDefinition('entity_test_update'); + + $entity_type->set('revision_table', 'entity_test_update_revision_new'); + + $this->state->set('entity_test_update.entity_type', $entity_type); + $this->entityManager->clearCachedDefinitions(); + } + + /** + * Renames the revision data table to 'entity_test_update_revision_data_new'. + */ + protected function renameRevisionDataTable() { + $entity_type = clone $this->entityManager->getDefinition('entity_test_update'); + + $entity_type->set('revision_data_table', 'entity_test_update_revision_data_new'); + + $this->state->set('entity_test_update.entity_type', $entity_type); + $this->entityManager->clearCachedDefinitions(); + } + + /** + * Removes the entity type. + */ + protected function deleteEntityType() { + $this->state->set('entity_test_update.entity_type', 'null'); + $this->entityManager->clearCachedDefinitions(); + } + +} diff --git a/core/modules/system/src/Tests/Entity/EntityDefinitionUpdateTest.php b/core/modules/system/src/Tests/Entity/EntityDefinitionUpdateTest.php index c6072e9..c2c7ea8 100644 --- a/core/modules/system/src/Tests/Entity/EntityDefinitionUpdateTest.php +++ b/core/modules/system/src/Tests/Entity/EntityDefinitionUpdateTest.php @@ -23,6 +23,8 @@ */ class EntityDefinitionUpdateTest extends EntityUnitTestBase { + use EntityDefinitionTestTrait; + /** * The entity definition update manager. * @@ -557,112 +559,4 @@ public function testEntityTypeSchemaUpdateAndBaseFieldCreateWithoutData() { } } - /** - * Updates the 'entity_test_update' entity type to revisionable. - */ - protected function updateEntityTypeToRevisionable() { - $entity_type = clone $this->entityManager->getDefinition('entity_test_update'); - $keys = $entity_type->getKeys(); - $keys['revision'] = 'revision_id'; - $entity_type->set('entity_keys', $keys); - $this->state->set('entity_test_update.entity_type', $entity_type); - $this->entityManager->clearCachedDefinitions(); - } - - /** - * Adds a new base field to the 'entity_test_update' entity type. - * - * @param string $type - * (optional) The field type for the new field. Defaults to 'string'. - */ - protected function addBaseField($type = 'string') { - $definitions['new_base_field'] = BaseFieldDefinition::create($type) - ->setName('new_base_field') - ->setLabel(t('A new base field')); - $this->state->set('entity_test_update.additional_base_field_definitions', $definitions); - $this->entityManager->clearCachedDefinitions(); - } - - /** - * Modifies the new base field from 'string' to 'text'. - */ - protected function modifyBaseField() { - $this->addBaseField('text'); - } - - /** - * Removes the new base field from the 'entity_test_update' entity type. - */ - protected function removeBaseField() { - $this->state->delete('entity_test_update.additional_base_field_definitions'); - $this->entityManager->clearCachedDefinitions(); - } - - /** - * Adds a single-field index to the base field. - */ - protected function addBaseFieldIndex() { - $this->state->set('entity_test_update.additional_field_index.entity_test_update.new_base_field', TRUE); - $this->entityManager->clearCachedDefinitions(); - } - - /** - * Removes the index added in addBaseFieldIndex(). - */ - protected function removeBaseFieldIndex() { - $this->state->delete('entity_test_update.additional_field_index.entity_test_update.new_base_field'); - $this->entityManager->clearCachedDefinitions(); - } - - /** - * Adds a new bundle field to the 'entity_test_update' entity type. - * - * @param string $type - * (optional) The field type for the new field. Defaults to 'string'. - */ - protected function addBundleField($type = 'string') { - $definitions['new_bundle_field'] = FieldStorageDefinition::create($type) - ->setName('new_bundle_field') - ->setLabel(t('A new bundle field')) - ->setTargetEntityTypeId('entity_test_update'); - $this->state->set('entity_test_update.additional_field_storage_definitions', $definitions); - $this->state->set('entity_test_update.additional_bundle_field_definitions.test_bundle', $definitions); - $this->entityManager->clearCachedDefinitions(); - } - - /** - * Modifies the new bundle field from 'string' to 'text'. - */ - protected function modifyBundleField() { - $this->addBundleField('text'); - } - - /** - * Removes the new bundle field from the 'entity_test_update' entity type. - */ - protected function removeBundleField() { - $this->state->delete('entity_test_update.additional_field_storage_definitions'); - $this->state->delete('entity_test_update.additional_bundle_field_definitions.test_bundle'); - $this->entityManager->clearCachedDefinitions(); - } - - /** - * Adds an index to the 'entity_test_update' entity type's base table. - * - * @see \Drupal\entity_test\EntityTestStorageSchema::getEntitySchema(). - */ - protected function addEntityIndex() { - $indexes = array( - 'entity_test_update__new_index' => array('name', 'user_id'), - ); - $this->state->set('entity_test_update.additional_entity_indexes', $indexes); - } - - /** - * Removes the index added in addEntityIndex(). - */ - protected function removeEntityIndex() { - $this->state->delete('entity_test_update.additional_entity_indexes'); - } - } diff --git a/core/modules/system/tests/modules/entity_test/src/Entity/EntityTestUpdate.php b/core/modules/system/tests/modules/entity_test/src/Entity/EntityTestUpdate.php index 9e792c7..59a2648 100644 --- a/core/modules/system/tests/modules/entity_test/src/Entity/EntityTestUpdate.php +++ b/core/modules/system/tests/modules/entity_test/src/Entity/EntityTestUpdate.php @@ -29,7 +29,8 @@ * "id" = "id", * "uuid" = "uuid", * "bundle" = "type", - * "label" = "name" + * "label" = "name", + * "langcode" = "langcode", * } * ) */ diff --git a/core/modules/system/tests/modules/entity_test/src/EntityTestStorageSchema.php b/core/modules/system/tests/modules/entity_test/src/EntityTestStorageSchema.php index 09e2ab1..4477c63 100644 --- a/core/modules/system/tests/modules/entity_test/src/EntityTestStorageSchema.php +++ b/core/modules/system/tests/modules/entity_test/src/EntityTestStorageSchema.php @@ -21,7 +21,10 @@ class EntityTestStorageSchema extends SqlContentEntityStorageSchema { */ protected function getEntitySchema(ContentEntityTypeInterface $entity_type, $reset = FALSE) { $schema = parent::getEntitySchema($entity_type, $reset); - $schema['entity_test_update']['indexes'] += \Drupal::state()->get('entity_test_update.additional_entity_indexes', array()); + + if ($entity_type->id() == 'entity_test_update') { + $schema[$entity_type->getBaseTable()]['indexes'] += \Drupal::state()->get('entity_test_update.additional_entity_indexes', array()); + } return $schema; } diff --git a/core/modules/views/src/EventSubscriber/ViewsEntitySchemaSubscriber.php b/core/modules/views/src/EventSubscriber/ViewsEntitySchemaSubscriber.php new file mode 100644 index 0000000..2903539 --- /dev/null +++ b/core/modules/views/src/EventSubscriber/ViewsEntitySchemaSubscriber.php @@ -0,0 +1,398 @@ +entityManager = $entity_manager; + } + + /** + * {@inheritdoc} + */ + public static function getSubscribedEvents() { + return static::getEntityTypeEvents() + static::getFieldStorageDefinitionEvents(); + } + + /** + * {@inheritdoc} + */ + public function onEntityTypeCreate(EntityTypeInterface $entity_type) { + } + + /** + * {@inheritdoc} + */ + public function onEntityTypeUpdate(EntityTypeInterface $entity_type, EntityTypeInterface $original) { + $changes = []; + + // We implement a specific logic for table updates, which is bound to the + // default sql content entity storage. + if (!$this->entityManager->getStorage($entity_type->id()) instanceof SqlContentEntityStorage) { + return; + } + + if ($entity_type->getBaseTable() != $original->getBaseTable()) { + $changes[] = static::BASE_TABLE_RENAME; + } + + $revision_add = $entity_type->isRevisionable() && !$original->isRevisionable(); + $revision_remove = !$entity_type->isRevisionable() && $original->isRevisionable(); + $translation_add = $entity_type->isTranslatable() && !$original->isTranslatable(); + $translation_remove = !$entity_type->isTranslatable() && $original->isTranslatable(); + + if ($revision_add) { + $changes[] = static::REVISION_TABLE_ADDITION; + } + elseif ($revision_remove) { + $changes[] = static::REVISION_TABLE_REMOVAL; + } + elseif ($entity_type->isRevisionable() && $entity_type->getRevisionTable() != $original->getRevisionTable()) { + $changes[] = static::REVISION_TABLE_RENAME; + } + + if ($translation_add) { + $changes[] = static::DATA_TABLE_ADDITION; + } + elseif ($translation_remove) { + $changes[] = static::DATA_TABLE_REMOVAL; + } + elseif ($entity_type->isTranslatable() && $entity_type->getDataTable() != $original->getDataTable()) { + $changes[] = static::DATA_TABLE_RENAME; + } + + if ($entity_type->isRevisionable() && $entity_type->isTranslatable()) { + if ($revision_add || $translation_add) { + $changes[] = static::REVISION_DATA_TABLE_ADDITION; + } + elseif ($entity_type->getRevisionDataTable() != $original->getRevisionDataTable()) { + $changes[] = static::REVISION_DATA_TABLE_RENAME; + } + } + elseif ($original->isRevisionable() && $original->isTranslatable() && ($revision_remove || $translation_remove)) { + $changes[] = static::REVISION_DATA_TABLE_REMOVAL; + } + + $all_views = $this->entityManager->getStorage('view')->loadMultiple(NULL); + + foreach ($changes as $change) { + switch ($change) { + case static::BASE_TABLE_RENAME: + $this->baseTableRename($all_views, $entity_type->id(), $original->getBaseTable(), $entity_type->getBaseTable()); + break; + case static::DATA_TABLE_RENAME: + $this->dataTableRename($all_views, $entity_type->id(), $original->getDataTable(), $entity_type->getDataTable()); + break; + case static::DATA_TABLE_ADDITION: + $this->dataTableAddition($all_views, $entity_type, $entity_type->getDataTable(), $entity_type->getBaseTable()); + break; + case static::DATA_TABLE_REMOVAL: + $this->dataTableRemoval($all_views, $entity_type->id(), $original->getDataTable(), $entity_type->getBaseTable()); + break; + case static::REVISION_TABLE_RENAME: + $this->baseTableRename($all_views, $entity_type->id(), $original->getRevisionTable(), $entity_type->getRevisionTable()); + break; + case static::REVISION_TABLE_ADDITION: + // If we add revision support we don't have to do anything. + break; + case static::REVISION_TABLE_REMOVAL: + $this->revisionRemoval($all_views, $original); + break; + case static::REVISION_DATA_TABLE_RENAME: + $this->dataTableRename($all_views, $entity_type->id(), $original->getRevisionDataTable(), $entity_type->getRevisionDataTable()); + break; + case static::REVISION_DATA_TABLE_ADDITION: + $this->dataTableAddition($all_views, $entity_type, $entity_type->getRevisionDataTable(), $entity_type->getRevisionTable()); + break; + case static::REVISION_DATA_TABLE_REMOVAL: + $this->dataTableRemoval($all_views, $entity_type->id(), $original->getRevisionDataTable(), $entity_type->getRevisionTable()); + break; + } + } + + foreach ($all_views as $view) { + $view->save(); + } + } + + /** + * {@inheritdoc} + */ + public function onEntityTypeDelete(EntityTypeInterface $entity_type) { + $tables = [ + $entity_type->getBaseTable(), + $entity_type->getDataTable(), + $entity_type->getRevisionTable(), + $entity_type->getRevisionDataTable(), + ]; + + $all_views = $this->entityManager->getStorage('view')->loadMultiple(NULL); + /** @var \Drupal\views\Entity\View $view */ + foreach ($all_views as $id => $view) { + + // First check just the base table. + if (in_array($view->get('base_table'), $tables)) { + $view->disable(); + $view->save(); + } + } + } + + /** + * {@inheritdoc} + */ + public function onFieldStorageDefinitionCreate(FieldStorageDefinitionInterface $storage_definition) { + } + + /** + * {@inheritdoc} + */ + public function onFieldStorageDefinitionUpdate(FieldStorageDefinitionInterface $storage_definition, FieldStorageDefinitionInterface $original) { + } + + /** + * {@inheritdoc} + */ + public function onFieldStorageDefinitionDelete(FieldStorageDefinitionInterface $storage_definition) { + } + + /** + * Applies a callable onto all handlers of all passed in views. + * + * @param \Drupal\views\Entity\View[] $all_views + * All views entities. + * @param callable $process + * A callable which retrieves a handler config array. + */ + protected function processHandlers(array $all_views, callable $process) { + foreach ($all_views as $view) { + foreach (array_keys($view->get('display')) as $display_id) { + $display = &$view->getDisplay($display_id); + foreach (Views::getHandlerTypes() as $handler_type) { + $handler_type = $handler_type['plural']; + if (!isset($display['display_options'][$handler_type])) { + continue; + } + foreach ($display['display_options'][$handler_type] as $id => &$handler_config) { + $process($handler_config); + if ($handler_config === NULL) { + unset($display['display_options'][$handler_type][$id]); + } + } + } + } + } + } + + /** + * Updates views if a base table is renamed. + * + * @param \Drupal\views\Entity\View[] $all_views + * All views. + * @param string $entity_type_id + * The entity type ID. + * @param string $old_base_table + * The old base table name. + * @param string $new_base_table + * The new base table name. + */ + protected function baseTableRename($all_views, $entity_type_id, $old_base_table, $new_base_table) { + foreach ($all_views as $view) { + if ($view->get('base_table') == $old_base_table) { + $view->set('base_table', $new_base_table); + } + } + + $this->processHandlers($all_views, function (array &$handler_config) use ($entity_type_id, $old_base_table, $new_base_table) { + if (isset($handler_config['entity_type']) && $handler_config['entity_type'] == $entity_type_id && $handler_config['table'] == $old_base_table) { + $handler_config['table'] = $new_base_table; + } + }); + } + + /** + * + * Updates views if a data table is renamed. + * + * @param \Drupal\views\Entity\View[] $all_views + * All views. + * @param string $entity_type_id + * The entity type ID. + * @param string $old_data_table + * The old data table name. + * @param string $new_data_table + * The new data table name. + */ + protected function dataTableRename($all_views, $entity_type_id, $old_data_table, $new_data_table) { + foreach ($all_views as $view) { + if ($view->get('base_table') == $old_data_table) { + $view->set('base_table', $new_data_table); + } + } + + $this->processHandlers($all_views, function (array &$handler_config) use ($entity_type_id, $old_data_table, $new_data_table) { + if (isset($handler_config['entity_type']) && $handler_config['entity_type'] == $entity_type_id && $handler_config['table'] == $old_data_table) { + $handler_config['table'] = $new_data_table; + } + }); + } + + /** + * Updates views if a data table is added. + * + * @param \Drupal\views\Entity\View[] $all_views + * All views. + * @param \Drupal\Core\Entity\EntityTypeInterface $entity_type + * The entity type. + */ + protected function dataTableAddition($all_views, EntityTypeInterface $entity_type, $new_data_table, $base_table) { + /** @var \Drupal\Core\Entity\Sql\SqlContentEntityStorage $storage */ + $entity_type_id = $entity_type->id(); + $storage = $this->entityManager->getStorage($entity_type_id); + $storage->setEntityType($entity_type); + $table_mapping = $storage->getTableMapping(); + $data_table_fields = $table_mapping->getFieldNames($new_data_table); + $base_table_fields = $table_mapping->getFieldNames($base_table); + + $data_table = $new_data_table; + + $this->processHandlers($all_views, function (array &$handler_config) use ($entity_type_id, $base_table, $data_table, $base_table_fields, $data_table_fields) { + if (isset($handler_config['entity_type']) && isset($handler_config['entity_field']) && $handler_config['entity_type'] == $entity_type_id) { + // Move all fields which just exists on the data table. + if ($handler_config['table'] == $base_table && in_array($handler_config['entity_field'], $data_table_fields) && !in_array($handler_config['entity_field'], $base_table_fields)) { + $handler_config['table'] = $data_table; + } + } + }); + } + + /** + * Updates views if a data table is removed. + * + * @param \Drupal\views\Entity\View[] $all_views + * All views. + * @param string $entity_type_id + * The entity type ID. + * @param string $old_data_table + * The name of the previous existing data table. + * @param string $base_table + * The name of the base table. + */ + protected function dataTableRemoval($all_views, $entity_type_id, $old_data_table, $base_table) { + // We move back the data table back to the base table. + $this->processHandlers($all_views, function (array &$handler_config) use ($entity_type_id, $old_data_table, $base_table) { + if (isset($handler_config['entity_type']) && $handler_config['entity_type'] == $entity_type_id) { + if ($handler_config['table'] == $old_data_table) { + $handler_config['table'] = $base_table; + } + } + }); + } + + /** + * Updates views if revision support is removed + * + * @param \Drupal\views\Entity\View[] $all_views + * All views. + * @param \Drupal\Core\Entity\EntityTypeInterface $original + * The origin entity type. + */ + protected function revisionRemoval($all_views, EntityTypeInterface $original) { + $revision_base_table = $original->getRevisionTable(); + $revision_data_table = $original->getRevisionDataTable(); + + foreach ($all_views as $view) { + if (in_array($view->get('base_table'), [$revision_base_table, $revision_data_table])) { + // Let's disable the views as we no longer support revisions. + $view->setStatus(FALSE); + } + + // For any kind of field, let's rely on the broken handler functionality. + } + } + +} diff --git a/core/modules/views/src/Tests/EventSubscriber/ViewsEntitySchemaSubscriberIntegrationTest.php b/core/modules/views/src/Tests/EventSubscriber/ViewsEntitySchemaSubscriberIntegrationTest.php new file mode 100644 index 0000000..545b292 --- /dev/null +++ b/core/modules/views/src/Tests/EventSubscriber/ViewsEntitySchemaSubscriberIntegrationTest.php @@ -0,0 +1,456 @@ +eventDispatcher = $this->container->get('event_dispatcher'); + $this->eventSubscriber = $this->container->get('views.entity_schema_subscriber'); + $this->entityDefinitionUpdateManager = $this->container->get('entity.definition_update_manager'); + $this->entityManager = $this->container->get('entity.manager'); + $this->state = $this->container->get('state'); + + $this->database = $this->container->get('database'); + + // Install every entity type's schema that wasn't installed in the parent + // method. + foreach (array_diff_key($this->entityManager->getDefinitions(), array_flip(array('user', 'entity_test'))) as $entity_type_id => $entity_type) { + $this->installEntitySchema($entity_type_id); + } + + $this->installSchema('system', 'key_value_expire'); + } + + /** + * Tests that views are disabled when an entity type is deleted. + */ + public function testDeleteEntityType() { + $entity_storage = $this->entityManager->getStorage('view'); + + $views = $entity_storage->loadMultiple(); + + // Ensure that all test views exists. + $this->assertTrue(isset($views['test_view_entity_test'])); + $this->assertTrue(isset($views['test_view_entity_test_revision'])); + $this->assertTrue(isset($views['test_view_entity_test_data'])); + $this->assertTrue(isset($views['test_view_entity_test_additional_base_field'])); + + $event = new EntityTypeEvent($this->entityManager->getDefinition('entity_test_update')); + $this->eventDispatcher->dispatch(EntityTypeEvents::DELETE, $event); + + // We expect that views which use 'entity_test_update' as base tables are + // disabled. + $views = $entity_storage->loadMultiple(); + + // Ensure that all test views still exists after the deletion of the + // entity type. + $this->assertTrue(isset($views['test_view_entity_test'])); + $this->assertTrue(isset($views['test_view_entity_test_revision'])); + $this->assertTrue(isset($views['test_view_entity_test_data'])); + $this->assertTrue(isset($views['test_view_entity_test_additional_base_field'])); + + // Ensure that they are all disabled. + $this->assertFalse($views['test_view_entity_test']->status()); + $this->assertFalse($views['test_view_entity_test_revision']->status()); + $this->assertFalse($views['test_view_entity_test_data']->status()); + $this->assertFalse($views['test_view_entity_test_additional_base_field']->status()); + } + + /** + * Tests that renaming base tables adapts the views. + */ + public function testBaseTableRename() { + $this->renameBaseTable(); + $this->entityDefinitionUpdateManager->applyUpdates(); + + /** @var \Drupal\views\Entity\View $view */ + $entity_storage = $this->entityManager->getStorage('view'); + $view = $entity_storage->load('test_view_entity_test'); + + // Ensure the base table got renamed, so also the views fields. + $this->assertEqual('entity_test_update_new', $view->get('base_table')); + $display = $view->getDisplay('default'); + $this->assertEqual('entity_test_update_new', $display['display_options']['fields']['id']['table']); + $this->assertEqual('entity_test_update_new', $display['display_options']['fields']['name']['table']); + } + + /** + * Tests that renaming data tables adapts the views. + */ + public function testDataTableRename() { + $this->updateEntityTypeToTranslatable(); + $this->entityDefinitionUpdateManager->applyUpdates(); + + $entity_storage = $this->entityManager->getStorage('view'); + $view = $entity_storage->load('test_view_entity_test_data'); + $this->assertEqual('entity_test_update', $view->get('base_table')); + $display = $view->getDisplay('default'); + $this->assertEqual('entity_test_update', $display['display_options']['fields']['id']['table']); + // Ensure that the data table is used. + $this->assertEqual('entity_test_update_data', $display['display_options']['fields']['name']['table']); + + $this->renameDataTable(); + $this->entityDefinitionUpdateManager->applyUpdates(); + + /** @var \Drupal\views\Entity\View $view */ + $entity_storage = $this->entityManager->getStorage('view'); + $view = $entity_storage->load('test_view_entity_test_data'); + + // Ensure the data table got renamed, so also the views fields. + $this->assertEqual('entity_test_update', $view->get('base_table')); + $display = $view->getDisplay('default'); + $this->assertEqual('entity_test_update', $display['display_options']['fields']['id']['table']); + $this->assertEqual('entity_test_update_data_new', $display['display_options']['fields']['name']['table']); + } + + /** + * Tests that renaming revision tables adapts the views. + */ + public function testRevisionBaseTableRename() { + $this->updateEntityTypeToRevisionable(); + $this->entityDefinitionUpdateManager->applyUpdates(); + + /** @var \Drupal\views\Entity\View $view */ + $entity_storage = $this->entityManager->getStorage('view'); + $view = $entity_storage->load('test_view_entity_test_revision'); + $this->assertEqual('entity_test_update_revision', $view->get('base_table')); + $display = $view->getDisplay('default'); + $this->assertEqual('entity_test_update_revision', $display['display_options']['fields']['id']['table']); + $this->assertEqual('entity_test_update_revision', $display['display_options']['fields']['name']['table']); + + $this->renameRevisionBaseTable(); + $this->entityDefinitionUpdateManager->applyUpdates(); + + /** @var \Drupal\views\Entity\View $view */ + $entity_storage = $this->entityManager->getStorage('view'); + $view = $entity_storage->load('test_view_entity_test_revision'); + + // Ensure the base table got renamed, so also the views fields. + $this->assertEqual('entity_test_update_revision_new', $view->get('base_table')); + $display = $view->getDisplay('default'); + $this->assertEqual('entity_test_update_revision_new', $display['display_options']['fields']['id']['table']); + $this->assertEqual('entity_test_update_revision_new', $display['display_options']['fields']['name']['table']); + } + + /** + * Tests that renaming revision tables adapts the views. + */ + public function testRevisionDataTableRename() { + $this->updateEntityTypeToRevisionable(); + $this->updateEntityTypeToTranslatable(); + $this->entityDefinitionUpdateManager->applyUpdates(); + + /** @var \Drupal\views\Entity\View $view */ + $entity_storage = $this->entityManager->getStorage('view'); + $view = $entity_storage->load('test_view_entity_test_revision'); + $this->assertEqual('entity_test_update_revision', $view->get('base_table')); + $display = $view->getDisplay('default'); + $this->assertEqual('entity_test_update_revision', $display['display_options']['fields']['id']['table']); + $this->assertEqual('entity_test_update_revision_data', $display['display_options']['fields']['name']['table']); + + $this->renameRevisionDataTable(); + $this->entityDefinitionUpdateManager->applyUpdates(); + + /** @var \Drupal\views\Entity\View $view */ + $entity_storage = $this->entityManager->getStorage('view'); + $view = $entity_storage->load('test_view_entity_test_revision'); + + // Ensure the base table got renamed, so also the views fields. + $this->assertEqual('entity_test_update_revision', $view->get('base_table')); + $display = $view->getDisplay('default'); + $this->assertEqual('entity_test_update_revision', $display['display_options']['fields']['id']['table']); + $this->assertEqual('entity_test_update_revision_data_new', $display['display_options']['fields']['name']['table']); + } + + /** + * Tests that adding data tables adapts the views. + */ + public function testDataTableAddition() { + $this->updateEntityTypeToTranslatable(); + $this->entityDefinitionUpdateManager->applyUpdates(); + + /** @var \Drupal\views\Entity\View $view */ + $entity_storage = $this->entityManager->getStorage('view'); + $view = $entity_storage->load('test_view_entity_test'); + + // Ensure the data table got renamed, so also the views fields. + $this->assertEqual('entity_test_update', $view->get('base_table')); + $display = $view->getDisplay('default'); + $this->assertEqual('entity_test_update', $display['display_options']['fields']['id']['table']); + $this->assertEqual('entity_test_update_data', $display['display_options']['fields']['name']['table']); + } + + /** + * Tests that enabling revisions doesn't do anything. + */ + public function testRevisionEnabling() { + $this->updateEntityTypeToRevisionable(); + $this->entityDefinitionUpdateManager->applyUpdates(); + + /** @var \Drupal\views\Entity\View $view */ + $entity_storage = $this->entityManager->getStorage('view'); + $view = $entity_storage->load('test_view_entity_test'); + + // Ensure that nothing happens. + $this->assertEqual('entity_test_update', $view->get('base_table')); + $display = $view->getDisplay('default'); + $this->assertEqual('entity_test_update', $display['display_options']['fields']['id']['table']); + $this->assertEqual('entity_test_update', $display['display_options']['fields']['name']['table']); + } + + /** + * Tests that removing revision support disables the view. + */ + public function testRevisionDisabling() { + $this->updateEntityTypeToRevisionable(); + $this->entityDefinitionUpdateManager->applyUpdates(); + + $this->updateEntityTypeToNotRevisionable(); + $this->entityDefinitionUpdateManager->applyUpdates(); + + /** @var \Drupal\views\Entity\View $view */ + $entity_storage = $this->entityManager->getStorage('view'); + $view = $entity_storage->load('test_view_entity_test_revision'); + + $this->assertFalse($view->status()); + } + + /** + * Tests a bunch possible entity definition table updates. + */ + public function testVariousTableUpdates() { + // @fixme ... include a revision field as well. + // @fixme ... Add an explicit test for the langcode. + + // We want to test the following permutations of entity definition updates: + // base <-> base + translation + // base + translation <-> base + translation + revision + // base + revision <-> base + translation + revision + // base <-> base + revision + // base <-> base + translation + revision + + // base <-> base + translation + $this->updateEntityTypeToTranslatable(); + $this->entityDefinitionUpdateManager->applyUpdates(); + list($view, $display) = $this->getUpdatedViewAndDisplay(); + + $this->assertEqual('entity_test_update', $view->get('base_table')); + $this->assertEqual('entity_test_update', $display['display_options']['fields']['id']['table']); + $this->assertEqual('entity_test_update_data', $display['display_options']['fields']['name']['table']); + + $this->updateEntityTypeToNotTranslatable(); + $this->entityDefinitionUpdateManager->applyUpdates(); + list($view, $display) = $this->getUpdatedViewAndDisplay(); + + $this->assertEqual('entity_test_update', $view->get('base_table')); + $this->assertEqual('entity_test_update', $display['display_options']['fields']['id']['table']); + $this->assertEqual('entity_test_update', $display['display_options']['fields']['name']['table']); + + $this->resetEntityType(); + + // base + translation <-> base + translation + revision + $this->updateEntityTypeToTranslatable(); + $this->entityDefinitionUpdateManager->applyUpdates(); + list($view, $display) = $this->getUpdatedViewAndDisplay(); + + $this->assertEqual('entity_test_update', $view->get('base_table')); + $this->assertEqual('entity_test_update', $display['display_options']['fields']['id']['table']); + $this->assertEqual('entity_test_update_data', $display['display_options']['fields']['name']['table']); + + $this->updateEntityTypeToRevisionable(); + $this->entityDefinitionUpdateManager->applyUpdates(); + list($view, $display) = $this->getUpdatedViewAndDisplay(); + + $this->assertEqual('entity_test_update', $view->get('base_table')); + $this->assertEqual('entity_test_update', $display['display_options']['fields']['id']['table']); + $this->assertEqual('entity_test_update_data', $display['display_options']['fields']['name']['table']); + + $this->updateEntityTypeToNotRevisionable(); + $this->entityDefinitionUpdateManager->applyUpdates(); + list($view, $display) = $this->getUpdatedViewAndDisplay(); + + $this->assertEqual('entity_test_update', $view->get('base_table')); + $this->assertEqual('entity_test_update', $display['display_options']['fields']['id']['table']); + $this->assertEqual('entity_test_update_data', $display['display_options']['fields']['name']['table']); + + $this->resetEntityType(); + + // base + revision <-> base + translation + revision + $this->updateEntityTypeToRevisionable(); + list($view, $display) = $this->getUpdatedViewAndDisplay(); + + $this->assertEqual('entity_test_update', $view->get('base_table')); + $this->assertEqual('entity_test_update', $display['display_options']['fields']['id']['table']); + $this->assertEqual('entity_test_update', $display['display_options']['fields']['name']['table']); + + $this->updateEntityTypeToTranslatable(); + $this->entityDefinitionUpdateManager->applyUpdates(); + list($view, $display) = $this->getUpdatedViewAndDisplay(); + + $this->assertEqual('entity_test_update', $view->get('base_table')); + $this->assertEqual('entity_test_update', $display['display_options']['fields']['id']['table']); + $this->assertEqual('entity_test_update_data', $display['display_options']['fields']['name']['table']); + + $this->updateEntityTypeToNotTranslatable(); + $this->entityDefinitionUpdateManager->applyUpdates(); + list($view, $display) = $this->getUpdatedViewAndDisplay(); + + $this->assertEqual('entity_test_update', $view->get('base_table')); + $this->assertEqual('entity_test_update', $display['display_options']['fields']['id']['table']); + $this->assertEqual('entity_test_update', $display['display_options']['fields']['name']['table']); + + $this->resetEntityType(); + + // base <-> base + revision + $this->updateEntityTypeToRevisionable(); + $this->entityDefinitionUpdateManager->applyUpdates(); + list($view, $display) = $this->getUpdatedViewAndDisplay(); + + $this->assertEqual('entity_test_update', $view->get('base_table')); + $this->assertEqual('entity_test_update', $display['display_options']['fields']['id']['table']); + $this->assertEqual('entity_test_update', $display['display_options']['fields']['name']['table']); + + $this->updateEntityTypeToNotRevisionable(); + $this->entityDefinitionUpdateManager->applyUpdates(); + list($view, $display) = $this->getUpdatedViewAndDisplay(); + + $this->assertEqual('entity_test_update', $view->get('base_table')); + $this->assertEqual('entity_test_update', $display['display_options']['fields']['id']['table']); + $this->assertEqual('entity_test_update', $display['display_options']['fields']['name']['table']); + + $this->resetEntityType(); + + // base <-> base + translation + revision + $this->updateEntityTypeToRevisionable(); + $this->updateEntityTypeToTranslatable(); + $this->entityDefinitionUpdateManager->applyUpdates(); + list($view, $display) = $this->getUpdatedViewAndDisplay(); + + $this->assertEqual('entity_test_update', $view->get('base_table')); + $this->assertEqual('entity_test_update', $display['display_options']['fields']['id']['table']); + $this->assertEqual('entity_test_update_data', $display['display_options']['fields']['name']['table']); + + $this->updateEntityTypeToNotRevisionable(); + $this->updateEntityTypeToNotTranslatable(); + $this->entityDefinitionUpdateManager->applyUpdates(); + list($view, $display) = $this->getUpdatedViewAndDisplay(); + + $this->assertEqual('entity_test_update', $view->get('base_table')); + $this->assertEqual('entity_test_update', $display['display_options']['fields']['id']['table']); + $this->assertEqual('entity_test_update', $display['display_options']['fields']['name']['table']); + } + + public function testVariousTableUpdatesForRevisionView() { + // base + revision <-> base + translation + revision + $this->updateEntityTypeToRevisionable(); + list($view, $display) = $this->getUpdatedViewAndDisplay(TRUE); + + $this->assertEqual('entity_test_update_revision', $view->get('base_table')); + $this->assertEqual('entity_test_update_revision', $display['display_options']['fields']['id']['table']); + $this->assertEqual('entity_test_update_revision', $display['display_options']['fields']['name']['table']); + + $this->updateEntityTypeToTranslatable(); + $this->entityDefinitionUpdateManager->applyUpdates(); + list($view, $display) = $this->getUpdatedViewAndDisplay(TRUE); + + $this->assertEqual('entity_test_update_revision', $view->get('base_table')); + $this->assertEqual('entity_test_update_revision', $display['display_options']['fields']['id']['table']); + $this->assertEqual('entity_test_update_revision_data', $display['display_options']['fields']['name']['table']); + + $this->updateEntityTypeToNotTranslatable(); + $this->entityDefinitionUpdateManager->applyUpdates(); + list($view, $display) = $this->getUpdatedViewAndDisplay(TRUE); + + $this->assertEqual('entity_test_update_revision', $view->get('base_table')); + $this->assertEqual('entity_test_update_revision', $display['display_options']['fields']['id']['table']); + $this->assertEqual('entity_test_update_revision', $display['display_options']['fields']['name']['table']); + + $this->resetEntityType(); + } + + /** + * Gets a view and its display. + */ + protected function getUpdatedViewAndDisplay($revision = FALSE) { + $entity_storage = $this->entityManager->getStorage('view'); + /** @var \Drupal\views\Entity\View $view */ + $view = $entity_storage->load($revision ? 'test_view_entity_test_revision' : 'test_view_entity_test'); + $display = $view->getDisplay('default'); + + return [$view, $display]; + } + + // @todo think about translation, and revision tests. + +} diff --git a/core/modules/views/tests/modules/views_test_config/test_views/views.view.test_view_entity_test.yml b/core/modules/views/tests/modules/views_test_config/test_views/views.view.test_view_entity_test.yml new file mode 100644 index 0000000..ff18212 --- /dev/null +++ b/core/modules/views/tests/modules/views_test_config/test_views/views.view.test_view_entity_test.yml @@ -0,0 +1,67 @@ +langcode: und +status: true +dependencies: { } +id: test_view_entity_test +label: '' +module: views +description: '' +tag: '' +base_table: entity_test_update +base_field: nid +core: '8' +display: + default: + display_options: + access: + type: none + cache: + type: none + exposed_form: + type: basic + fields: + id: + alter: + alter_text: false + ellipsis: true + html: false + make_link: false + strip_tags: false + trim: false + word_boundary: true + empty_zero: false + field: id + hide_empty: false + id: id + table: entity_test_update + entity_type: entity_test_update + entity_field: id + plugin_id: numeric + name: + alter: + alter_text: false + ellipsis: true + html: false + make_link: false + strip_tags: false + trim: false + word_boundary: true + empty_zero: false + field: name + hide_empty: false + id: name + table: entity_test_update + plugin_id: standard + entity_type: entity_test_update + entity_field: name + pager: + type: some + style: + type: default + row: + type: fields + field_langcode: '***LANGUAGE_language_content***' + field_langcode_add_to_query: null + display_plugin: default + display_title: Master + id: default + position: 0 diff --git a/core/modules/views/tests/modules/views_test_config/test_views/views.view.test_view_entity_test_additional_base_field.yml b/core/modules/views/tests/modules/views_test_config/test_views/views.view.test_view_entity_test_additional_base_field.yml new file mode 100644 index 0000000..9527955 --- /dev/null +++ b/core/modules/views/tests/modules/views_test_config/test_views/views.view.test_view_entity_test_additional_base_field.yml @@ -0,0 +1,67 @@ +langcode: und +status: true +dependencies: { } +id: test_view_entity_test_additional_base_field +label: '' +module: views +description: '' +tag: '' +base_table: entity_test_update +base_field: nid +core: '8' +display: + default: + display_options: + access: + type: none + cache: + type: none + exposed_form: + type: basic + fields: + id: + alter: + alter_text: false + ellipsis: true + html: false + make_link: false + strip_tags: false + trim: false + word_boundary: true + empty_zero: false + field: id + hide_empty: false + id: id + table: entity_test_update + entity_type: entity_test_update + entity_field: id + plugin_id: numeric + new_base_field: + alter: + alter_text: false + ellipsis: true + html: false + make_link: false + strip_tags: false + trim: false + word_boundary: true + empty_zero: false + field: new_base_field + hide_empty: false + id: new_base_field + table: entity_test_update + plugin_id: standard + entity_type: entity_test_update + entity_field: new_base_field + pager: + type: some + style: + type: default + row: + type: fields + field_langcode: '***LANGUAGE_language_content***' + field_langcode_add_to_query: null + display_plugin: default + display_title: Master + id: default + position: 0 diff --git a/core/modules/views/tests/modules/views_test_config/test_views/views.view.test_view_entity_test_data.yml b/core/modules/views/tests/modules/views_test_config/test_views/views.view.test_view_entity_test_data.yml new file mode 100644 index 0000000..a711cf4 --- /dev/null +++ b/core/modules/views/tests/modules/views_test_config/test_views/views.view.test_view_entity_test_data.yml @@ -0,0 +1,67 @@ +langcode: und +status: true +dependencies: { } +id: test_view_entity_test_data +label: '' +module: views +description: '' +tag: '' +base_table: entity_test_update +base_field: nid +core: '8' +display: + default: + display_options: + access: + type: none + cache: + type: none + exposed_form: + type: basic + fields: + id: + alter: + alter_text: false + ellipsis: true + html: false + make_link: false + strip_tags: false + trim: false + word_boundary: true + empty_zero: false + field: id + hide_empty: false + id: id + table: entity_test_update + plugin_id: numeric + entity_type: entity_test_update + entity_field: id + name: + alter: + alter_text: false + ellipsis: true + html: false + make_link: false + strip_tags: false + trim: false + word_boundary: true + empty_zero: false + field: name + hide_empty: false + id: name + table: entity_test_update_data + plugin_id: standard + entity_type: entity_test_update + entity_field: id + pager: + type: some + style: + type: default + row: + type: fields + field_langcode: '***LANGUAGE_language_content***' + field_langcode_add_to_query: null + display_plugin: default + display_title: Master + id: default + position: 0 diff --git a/core/modules/views/tests/modules/views_test_config/test_views/views.view.test_view_entity_test_revision.yml b/core/modules/views/tests/modules/views_test_config/test_views/views.view.test_view_entity_test_revision.yml new file mode 100644 index 0000000..e80028b --- /dev/null +++ b/core/modules/views/tests/modules/views_test_config/test_views/views.view.test_view_entity_test_revision.yml @@ -0,0 +1,67 @@ +langcode: und +status: true +dependencies: { } +id: test_view_entity_test_revision +label: '' +module: views +description: '' +tag: '' +base_table: entity_test_update_revision +base_field: nid +core: '8' +display: + default: + display_options: + access: + type: none + cache: + type: none + exposed_form: + type: basic + fields: + id: + alter: + alter_text: false + ellipsis: true + html: false + make_link: false + strip_tags: false + trim: false + word_boundary: true + empty_zero: false + field: id + hide_empty: false + id: id + table: entity_test_update_revision + entity_type: entity_test_update + entity_field: id + plugin_id: numeric + name: + alter: + alter_text: false + ellipsis: true + html: false + make_link: false + strip_tags: false + trim: false + word_boundary: true + empty_zero: false + field: name + hide_empty: false + id: name + table: entity_test_update_revision + plugin_id: standard + entity_type: entity_test_update + entity_field: name + pager: + type: some + style: + type: default + row: + type: fields + field_langcode: '***LANGUAGE_language_content***' + field_langcode_add_to_query: null + display_plugin: default + display_title: Master + id: default + position: 0 diff --git a/core/modules/views/views.services.yml b/core/modules/views/views.services.yml index 9654432..f98ad1c 100644 --- a/core/modules/views/views.services.yml +++ b/core/modules/views/views.services.yml @@ -75,3 +75,8 @@ services: - { name: 'event_subscriber' } views.exposed_form_cache: class: Drupal\views\ExposedFormCache + views.entity_schema_subscriber: + class: Drupal\views\EventSubscriber\ViewsEntitySchemaSubscriber + arguments: ['@entity.manager'] + tags: + - { name: 'event_subscriber' }