/** * Tests some possible entity table updates for a revision view. */ public function testVariousTableUpdatesForRevisionView() { // base + revision <-> base + translation + revision $this->updateEntityTypeToRevisionable(); // Multiple changes, so we have to invalidate the caches, otherwise // the second update will revert the first. $this->entityManager->clearCachedDefinitions(); 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(); }
/** * Returns a list of changes to entity type and field storage definitions. * * @return array * An associative array keyed by entity type id of change descriptors. Every * entry is an associative array with the following optional keys: * - entity_type: a scalar having only the DEFINITION_UPDATED value. * - field_storage_definitions: an associative array keyed by field name of * scalars having one value among: * - DEFINITION_CREATED * - DEFINITION_UPDATED * - DEFINITION_DELETED */ protected function getChangeList() { $this->entityManager->clearCachedDefinitions(); $change_list = array(); foreach ($this->entityManager->getDefinitions() as $entity_type_id => $entity_type) { $original = $this->entityManager->getLastInstalledDefinition($entity_type_id); // Only manage changes to already installed entity types. Entity type // installation is handled elsewhere (e.g., // \Drupal\Core\Extension\ModuleHandler::install()). if (!$original) { continue; } // @todo Support non-storage-schema-changing definition updates too: // https://www.drupal.org/node/2336895. if ($this->requiresEntityStorageSchemaChanges($entity_type, $original)) { $change_list[$entity_type_id]['entity_type'] = static::DEFINITION_UPDATED; } if ($this->entityManager->getStorage($entity_type_id) instanceof DynamicallyFieldableEntityStorageInterface) { $field_changes = array(); $storage_definitions = $this->entityManager->getFieldStorageDefinitions($entity_type_id); $original_storage_definitions = $this->entityManager->getLastInstalledFieldStorageDefinitions($entity_type_id); // Detect created field storage definitions. foreach (array_diff_key($storage_definitions, $original_storage_definitions) as $field_name => $storage_definition) { $field_changes[$field_name] = static::DEFINITION_CREATED; } // Detect deleted field storage definitions. foreach (array_diff_key($original_storage_definitions, $storage_definitions) as $field_name => $original_storage_definition) { $field_changes[$field_name] = static::DEFINITION_DELETED; } // Detect updated field storage definitions. foreach (array_intersect_key($storage_definitions, $original_storage_definitions) as $field_name => $storage_definition) { // @todo Support non-storage-schema-changing definition updates too: // https://www.drupal.org/node/2336895. So long as we're checking // based on schema change requirements rather than definition // equality, skip the check if the entity type itself needs to be // updated, since that can affect the schema of all fields, so we // want to process that update first without reporting false // positives here. if (!isset($change_list[$entity_type_id]['entity_type']) && $this->requiresFieldStorageSchemaChanges($storage_definition, $original_storage_definitions[$field_name])) { $field_changes[$field_name] = static::DEFINITION_UPDATED; } } if ($field_changes) { $change_list[$entity_type_id]['field_storage_definitions'] = $field_changes; } } } return array_filter($change_list); }
/** * {@inheritdoc} */ public function applyUpdates() { $change_list = $this->getChangeList(); if ($change_list) { // getChangeList() only disables the cache and does not invalidate. // In case there are changes, explicitly invalidate caches. $this->entityManager->clearCachedDefinitions(); } foreach ($change_list as $entity_type_id => $change_list) { // Process entity type definition changes before storage definitions ones // this is necessary when you change an entity type from non-revisionable // to revisionable and at the same time add revisionable fields to the // entity type. if (!empty($change_list['entity_type'])) { $entity_type = $this->entityManager->getDefinition($entity_type_id); switch ($change_list['entity_type']) { case static::DEFINITION_CREATED: $this->entityManager->onEntityTypeCreate($entity_type); break; case static::DEFINITION_UPDATED: $original = $this->entityManager->getLastInstalledDefinition($entity_type_id); $this->entityManager->onEntityTypeUpdate($entity_type, $original); break; } } // Process field storage definition changes. if (!empty($change_list['field_storage_definitions'])) { $storage_definitions = $this->entityManager->getFieldStorageDefinitions($entity_type_id); $original_storage_definitions = $this->entityManager->getLastInstalledFieldStorageDefinitions($entity_type_id); foreach ($change_list['field_storage_definitions'] as $field_name => $change) { switch ($change) { case static::DEFINITION_CREATED: $this->entityManager->onFieldStorageDefinitionCreate($storage_definitions[$field_name]); break; case static::DEFINITION_UPDATED: $this->entityManager->onFieldStorageDefinitionUpdate($storage_definitions[$field_name], $original_storage_definitions[$field_name]); break; case static::DEFINITION_DELETED: $this->entityManager->onFieldStorageDefinitionDelete($original_storage_definitions[$field_name]); break; } } } } }
/** * {@inheritdoc} */ public function applyFieldUpdate($op, $entity_type_id, $field_name, $reset_cached_definitions = TRUE) { $change_list = $this->getChangeList(); if (!isset($change_list[$entity_type_id]['field_storage_definitions']) || $change_list[$entity_type_id]['field_storage_definitions'][$field_name] !== $op) { return FALSE; } if ($reset_cached_definitions) { // self::getChangeList() only disables the cache and does not invalidate. // In case there are changes, explicitly invalidate caches. $this->entityManager->clearCachedDefinitions(); } $storage_definitions = $this->entityManager->getFieldStorageDefinitions($entity_type_id); $original_storage_definitions = $this->entityManager->getLastInstalledFieldStorageDefinitions($entity_type_id); $storage_definition = isset($storage_definitions[$field_name]) ? $storage_definitions[$field_name] : NULL; $original_storage_definition = isset($original_storage_definitions[$field_name]) ? $original_storage_definitions[$field_name] : NULL; $this->doFieldUpdate($op, $storage_definition, $original_storage_definition); return TRUE; }
/** * {@inheritdoc} */ public function uninstallFieldStorageDefinition(FieldStorageDefinitionInterface $storage_definition) { $this->entityManager->clearCachedDefinitions(); $this->entityManager->onFieldStorageDefinitionDelete($storage_definition); }
/** * {@inheritdoc} */ public function clearCachedDefinitions() { $this->entityManager->clearCachedDefinitions(); }