示例#1
0
 /**
  * {@inheritdoc}
  */
 public function setUp()
 {
     parent::setUp();
     $this->configFactory = $this->getMock('Drupal\\Core\\Config\\ConfigFactoryInterface');
     $this->configManager = $this->getMock('Drupal\\Core\\Config\\ConfigManagerInterface');
     $this->configManager->expects($this->any())->method('getEntityTypeIdByName')->will($this->returnArgument(0));
     vfsStream::setup('public://');
 }
 /**
  * Adds form elements to list affected configuration entities.
  *
  * @param array $form
  *   The form array to add elements to.
  * @param string $type
  *   The type of dependency being checked. Either 'module', 'theme', 'config'
  *   or 'content'.
  * @param array $names
  *   The specific names to check. If $type equals 'module' or 'theme' then it
  *   should be a list of module names or theme names. In the case of 'config'
  *   or 'content' it should be a list of configuration dependency names.
  * @param \Drupal\Core\Config\ConfigManagerInterface $config_manager
  *   The config manager.
  * @param \Drupal\Core\Entity\EntityManagerInterface $entity_manager
  *   The entity manager.
  *
  * @see \Drupal\Core\Config\ConfigManagerInterface::getConfigEntitiesToChangeOnDependencyRemoval()
  */
 protected function addDependencyListsToForm(array &$form, $type, array $names, ConfigManagerInterface $config_manager, EntityManagerInterface $entity_manager)
 {
     // Get the dependent entities.
     $dependent_entities = $config_manager->getConfigEntitiesToChangeOnDependencyRemoval($type, $names);
     $entity_types = array();
     $form['entity_updates'] = array('#type' => 'details', '#title' => $this->t('Configuration updates'), '#description' => $this->t('The listed configuration will be updated.'), '#open' => TRUE, '#access' => FALSE);
     foreach ($dependent_entities['update'] as $entity) {
         /** @var \Drupal\Core\Config\Entity\ConfigEntityInterface  $entity */
         $entity_type_id = $entity->getEntityTypeId();
         if (!isset($form['entity_updates'][$entity_type_id])) {
             $entity_type = $entity_manager->getDefinition($entity_type_id);
             // Store the ID and label to sort the entity types and entities later.
             $label = $entity_type->getLabel();
             $entity_types[$entity_type_id] = $label;
             $form['entity_updates'][$entity_type_id] = array('#theme' => 'item_list', '#title' => $label, '#items' => array());
         }
         $form['entity_updates'][$entity_type_id]['#items'][$entity->id()] = $entity->label() ?: $entity->id();
     }
     if (!empty($dependent_entities['update'])) {
         $form['entity_updates']['#access'] = TRUE;
         // Add a weight key to the entity type sections.
         asort($entity_types, SORT_FLAG_CASE);
         $weight = 0;
         foreach ($entity_types as $entity_type_id => $label) {
             $form['entity_updates'][$entity_type_id]['#weight'] = $weight;
             // Sort the list of entity labels alphabetically.
             ksort($form['entity_updates'][$entity_type_id]['#items'], SORT_FLAG_CASE);
             $weight++;
         }
     }
     $form['entity_deletes'] = array('#type' => 'details', '#title' => $this->t('Configuration deletions'), '#description' => $this->t('The listed configuration will be deleted.'), '#open' => TRUE, '#access' => FALSE);
     foreach ($dependent_entities['delete'] as $entity) {
         $entity_type_id = $entity->getEntityTypeId();
         if (!isset($form['entity_deletes'][$entity_type_id])) {
             $entity_type = $entity_manager->getDefinition($entity_type_id);
             // Store the ID and label to sort the entity types and entities later.
             $label = $entity_type->getLabel();
             $entity_types[$entity_type_id] = $label;
             $form['entity_deletes'][$entity_type_id] = array('#theme' => 'item_list', '#title' => $label, '#items' => array());
         }
         $form['entity_deletes'][$entity_type_id]['#items'][$entity->id()] = $entity->label() ?: $entity->id();
     }
     if (!empty($dependent_entities['delete'])) {
         $form['entity_deletes']['#access'] = TRUE;
         // Add a weight key to the entity type sections.
         asort($entity_types, SORT_FLAG_CASE);
         $weight = 0;
         foreach ($entity_types as $entity_type_id => $label) {
             if (isset($form['entity_deletes'][$entity_type_id])) {
                 $form['entity_deletes'][$entity_type_id]['#weight'] = $weight;
                 // Sort the list of entity labels alphabetically.
                 ksort($form['entity_deletes'][$entity_type_id]['#items'], SORT_FLAG_CASE);
                 $weight++;
             }
         }
     }
 }
 /**
  * Loads configuration from storage into a property.
  */
 protected function initConfigCollection($reset = FALSE)
 {
     if ($reset || empty($this->configCollection)) {
         $config_collection = [];
         $config_types = $this->listConfigTypes();
         $dependency_manager = $this->configManager->getConfigDependencyManager();
         foreach (array_keys($config_types) as $config_type) {
             $config = $this->listConfigByType($config_type);
             foreach ($config as $item_name => $label) {
                 $name = $this->getFullName($config_type, $item_name);
                 $data = $this->configStorage->read($name);
                 // Compute dependent config.
                 $dependent_list = $dependency_manager->getDependentEntities('config', $name);
                 $dependents = array();
                 foreach ($dependent_list as $config_name => $item) {
                     if (!isset($dependents[$config_name])) {
                         $dependents[$config_name] = $config_name;
                     }
                     // Grab any dependent graph paths.
                     if (isset($item['reverse_paths'])) {
                         foreach ($item['reverse_paths'] as $dependent_name => $value) {
                             if ($value && !isset($dependents[$dependent_name])) {
                                 $dependents[$dependent_name] = $dependent_name;
                             }
                         }
                     }
                 }
                 $config_collection[$name] = ['name' => $name, 'name_short' => $item_name, 'label' => $label, 'type' => $config_type, 'data' => $data, 'dependents' => array_keys($dependents), 'subdirectory' => InstallStorage::CONFIG_INSTALL_DIRECTORY, 'package_excluded' => []];
             }
         }
         $this->setConfigCollection($config_collection);
     }
 }
 /**
  * {@inheritdoc}
  */
 public function updateExtension($type, $name, array $changelist = array(), $safe_only = TRUE)
 {
     // If no change list was passed, load one.
     if (empty($changelist)) {
         $changelist = $this->configSyncLister->getExtensionChangelist($type, $name, $safe_only);
     }
     // Process create changes.
     if (!empty($changelist['create'])) {
         foreach ($changelist['create'] as $item_name) {
             if (!($entity_type = $this->configManager->getEntityTypeIdByName($name))) {
                 $entity_type = 'system.simple';
             }
             $this->configRevert->import($entity_type, $item_name);
         }
     }
     // Process update changes.
     if (!empty($changelist['update'])) {
         foreach ($changelist['update'] as $item_name) {
             if (!($entity_type = $this->configManager->getEntityTypeIdByName($name))) {
                 $entity_type = 'system.simple';
             }
             $this->configRevert->revert($entity_type, $item_name);
         }
     }
     // Refresh the configuration snapshot.
     $this->configSyncSnapshotter->createExtensionSnapshot($type, $name);
 }
示例#5
0
 /**
  * Loads configuration from storage into a property.
  */
 protected function initConfigCollection($reset = FALSE)
 {
     if ($reset || empty($this->configCollection)) {
         $config_collection = [];
         $config_types = $this->listConfigTypes();
         $dependency_manager = $this->configManager->getConfigDependencyManager();
         // List configuration provided by installed features.
         $existing_config = $this->listExistingConfig(TRUE);
         foreach (array_keys($config_types) as $config_type) {
             $config = $this->listConfigByType($config_type);
             foreach ($config as $item_name => $label) {
                 $name = $this->getFullName($config_type, $item_name);
                 $data = $this->configStorage->read($name);
                 // Compute dependent config.
                 $dependent_list = $dependency_manager->getDependentEntities('config', $name);
                 $dependents = array();
                 foreach ($dependent_list as $config_name => $item) {
                     if (!isset($dependents[$config_name])) {
                         $dependents[$config_name] = $config_name;
                     }
                     // Grab any dependent graph paths.
                     if (isset($item['reverse_paths'])) {
                         foreach ($item['reverse_paths'] as $dependent_name => $value) {
                             if ($value && !isset($dependents[$dependent_name])) {
                                 $dependents[$dependent_name] = $dependent_name;
                             }
                         }
                     }
                 }
                 $config_collection[$name] = new ConfigurationItem($name, $data, ['shortName' => $item_name, 'label' => $label, 'type' => $config_type, 'dependents' => array_keys($dependents), 'subdirectory' => InstallStorage::CONFIG_INSTALL_DIRECTORY, 'package' => '', 'extensionProvided' => NULL, 'providingFeature' => isset($existing_config[$name]) ? $existing_config[$name] : NULL, 'packageExcluded' => []]);
             }
         }
         $this->setConfigCollection($config_collection);
     }
 }
示例#6
0
 /**
  * Generates and adds files to a given package or profile.
  */
 protected function addPackageFiles(Package $package)
 {
     $config_collection = $this->getConfigCollection();
     // Always add .info.yml and .features.yml files.
     $this->addInfoFile($package);
     // Only add files if there is at least one piece of configuration present.
     if ($package->getConfig()) {
         // Add configuration files.
         foreach ($package->getConfig() as $name) {
             $config = $config_collection[$name];
             $data = $config->getData();
             // The _core is site-specific, so don't export it.
             unset($data['_core']);
             // The UUID is site-specfic, so don't export it.
             if ($entity_type_id = $this->configManager->getEntityTypeIdByName($name)) {
                 unset($data['uuid']);
             }
             $config->setData($data);
             // User roles include all permissions currently assigned to them. To
             // avoid extraneous additions, reset permissions.
             if ($config->getType() == 'user_role') {
                 $data = $config->getData();
                 // Unset and not empty permissions data to prevent loss of configured
                 // role permissions in the event of a feature revert.
                 unset($data['permissions']);
                 $config->setData($data);
             }
             $package->appendFile(['filename' => $config->getName() . '.yml', 'subdirectory' => $config->getSubdirectory(), 'string' => Yaml::encode($config->getData())], $name);
         }
     }
 }
 /**
  * Loads configuration from storage into a property.
  */
 protected function initConfigCollection($reset = FALSE)
 {
     if ($reset || empty($this->configCollection)) {
         $config_collection = [];
         $config_types = $this->listConfigTypes();
         $dependency_manager = $this->configManager->getConfigDependencyManager();
         foreach (array_keys($config_types) as $config_type) {
             $config = $this->listConfigByType($config_type);
             foreach ($config as $item_name => $label) {
                 $name = $this->getFullName($config_type, $item_name);
                 $data = $this->configStorage->read($name);
                 // Compute dependent config.
                 $dependent_list = $dependency_manager->getDependentEntities('config', $name);
                 $dependents = array();
                 foreach ($dependent_list as $config_name => $item) {
                     if (!isset($dependents[$config_name])) {
                         $dependents[$config_name] = $config_name;
                     }
                     // Grab the dependent graph paths.
                     foreach ($item['paths'] as $dependent_name => $value) {
                         if ($value && !isset($dependents[$dependent_name])) {
                             $dependents[$dependent_name] = $dependent_name;
                         }
                     }
                 }
                 $config_collection[$name] = ['name' => $name, 'name_short' => $item_name, 'label' => $label, 'type' => $config_type, 'data' => $data, 'dependents' => array_keys($dependents)];
             }
         }
         $this->setConfigCollection($config_collection);
     }
 }
示例#8
0
 /**
  * {@inheritdoc}
  */
 public function build(FacetInterface $facet, array $results)
 {
     $field_identifier = $facet->getFieldIdentifier();
     $entity = 'node';
     // Support multiple entities when using Search API.
     if ($facet->getFacetSource() instanceof SearchApiFacetSourceInterface) {
         $index = $facet->getFacetSource()->getIndex();
         $field = $index->getField($field_identifier);
         $entity = str_replace('entity:', '', $field->getDatasourceId());
     }
     // If it's an entity base field, we find it in the field definitions.
     // We don't have access to the bundle via SearchApiFacetSourceInterface, so
     // we check the entity's base fields only.
     $base_fields = $this->entityFieldManager->getFieldDefinitions($entity, '');
     // This only works for configurable fields.
     $config_entity_name = sprintf('field.storage.%s.%s', $entity, $field_identifier);
     if (isset($base_fields[$field_identifier])) {
         $field = $base_fields[$field_identifier];
     } elseif ($this->configManager->loadConfigEntityByName($config_entity_name) !== NULL) {
         $field = $this->configManager->loadConfigEntityByName($config_entity_name);
     }
     if ($field) {
         $function = $field->getSetting('allowed_values_function');
         if (empty($function)) {
             $allowed_values = $field->getSetting('allowed_values');
         } else {
             $allowed_values = ${$function}($field);
         }
         if (is_array($allowed_values)) {
             /** @var \Drupal\facets\Result\ResultInterface $result */
             foreach ($results as &$result) {
                 if (isset($allowed_values[$result->getRawValue()])) {
                     $result->setDisplayValue($allowed_values[$result->getRawValue()]);
                 }
             }
         }
     }
     return $results;
 }
 /**
  * Ensures bundles that will be deleted are not in use.
  *
  * @param \Drupal\Core\Config\ConfigImporterEvent $event
  *   The config import event.
  */
 public function onConfigImporterValidate(ConfigImporterEvent $event)
 {
     foreach ($event->getChangelist('delete') as $config_name) {
         // Get the config entity type ID. This also ensure we are dealing with a
         // configuration entity.
         if ($entity_type_id = $this->configManager->getEntityTypeIdByName($config_name)) {
             $entity_type = $this->entityManager->getDefinition($entity_type_id);
             // Does this entity type define a bundle of another entity type.
             if ($bundle_of = $entity_type->getBundleOf()) {
                 // Work out if there are entities with this bundle.
                 $bundle_of_entity_type = $this->entityManager->getDefinition($bundle_of);
                 $bundle_id = ConfigEntityStorage::getIDFromConfigName($config_name, $entity_type->getConfigPrefix());
                 $entity_query = $this->entityManager->getStorage($bundle_of)->getQuery();
                 $entity_ids = $entity_query->condition($bundle_of_entity_type->getKey('bundle'), $bundle_id)->accessCheck(FALSE)->range(0, 1)->execute();
                 if (!empty($entity_ids)) {
                     $entity = $this->entityManager->getStorage($entity_type_id)->load($bundle_id);
                     $event->getConfigImporter()->logError($this->t('Entities exist of type %entity_type and %bundle_label %bundle. These entities need to be deleted before importing.', array('%entity_type' => $bundle_of_entity_type->getLabel(), '%bundle_label' => $bundle_of_entity_type->getBundleLabel(), '%bundle' => $entity->label())));
                 }
             }
         }
     }
 }
示例#10
0
 /**
  * Creates configuration in a collection based on the provided list.
  *
  * @param string $collection
  *   The configuration collection.
  * @param array $config_to_install
  *   A list of configuration object names to create.
  */
 protected function createConfiguration($collection, array $config_to_install)
 {
     // Order the configuration to install in the order of dependencies.
     $data = $this->getSourceStorage($collection)->readMultiple($config_to_install);
     $config_entity_support = $this->configManager->supportsConfigurationEntities($collection);
     if ($config_entity_support) {
         $dependency_manager = new ConfigDependencyManager();
         $config_to_install = $dependency_manager->setData($data)->sortAll();
     }
     // Remove configuration that already exists in the active storage.
     $config_to_install = array_diff($config_to_install, $this->getActiveStorage($collection)->listAll());
     foreach ($config_to_install as $name) {
         // Allow config factory overriders to use a custom configuration object if
         // they are responsible for the collection.
         $overrider = $this->configManager->getConfigCollectionInfo()->getOverrideService($collection);
         if ($overrider) {
             $new_config = $overrider->createConfigObject($name, $collection);
         } else {
             $new_config = new Config($name, $this->getActiveStorage($collection), $this->eventDispatcher, $this->typedConfig);
         }
         if ($data[$name] !== FALSE) {
             $new_config->setData($data[$name]);
         }
         if ($config_entity_support && ($entity_type = $this->configManager->getEntityTypeIdByName($name))) {
             // If we are syncing do not create configuration entities. Pluggable
             // configuration entities can have dependencies on modules that are
             // not yet enabled. This approach means that any code that expects
             // default configuration entities to exist will be unstable after the
             // module has been enabled and before the config entity has been
             // imported.
             if ($this->isSyncing) {
                 continue;
             }
             $entity_storage = $this->configManager->getEntityManager()->getStorage($entity_type);
             // It is possible that secondary writes can occur during configuration
             // creation. Updates of such configuration are allowed.
             if ($this->getActiveStorage($collection)->exists($name)) {
                 $id = $entity_storage->getIDFromConfigName($name, $entity_storage->getEntityType()->getConfigPrefix());
                 $entity = $entity_storage->load($id);
                 foreach ($new_config->get() as $property => $value) {
                     $entity->set($property, $value);
                 }
                 $entity->save();
             } else {
                 $entity_storage->create($new_config->get())->save();
             }
         } else {
             $new_config->save();
         }
     }
 }
示例#11
0
 /**
  * {@inheritdoc}
  */
 public function uninstall(array $theme_list)
 {
     $extension_config = $this->configFactory->getEditable('core.extension');
     $theme_config = $this->configFactory->getEditable('system.theme');
     $list = $this->themeHandler->listInfo();
     foreach ($theme_list as $key) {
         if (!isset($list[$key])) {
             throw new \InvalidArgumentException("Unknown theme: {$key}.");
         }
         if ($key === $theme_config->get('default')) {
             throw new \InvalidArgumentException("The current default theme {$key} cannot be uninstalled.");
         }
         if ($key === $theme_config->get('admin')) {
             throw new \InvalidArgumentException("The current admin theme {$key} cannot be uninstalled.");
         }
         // Base themes cannot be uninstalled if sub themes are installed, and if
         // they are not uninstalled at the same time.
         // @todo https://www.drupal.org/node/474684 and
         //   https://www.drupal.org/node/1297856 themes should leverage the module
         //   dependency system.
         if (!empty($list[$key]->sub_themes)) {
             foreach ($list[$key]->sub_themes as $sub_key => $sub_label) {
                 if (isset($list[$sub_key]) && !in_array($sub_key, $theme_list, TRUE)) {
                     throw new \InvalidArgumentException("The base theme {$key} cannot be uninstalled, because theme {$sub_key} depends on it.");
                 }
             }
         }
     }
     $this->cssCollectionOptimizer->deleteAll();
     $current_theme_data = $this->state->get('system.theme.data', array());
     foreach ($theme_list as $key) {
         // The value is not used; the weight is ignored for themes currently.
         $extension_config->clear("theme.{$key}");
         // Update the current theme data accordingly.
         unset($current_theme_data[$key]);
         // Reset theme settings.
         $theme_settings =& drupal_static('theme_get_setting');
         unset($theme_settings[$key]);
         // Remove all configuration belonging to the theme.
         $this->configManager->uninstall('theme', $key);
     }
     // Don't check schema when uninstalling a theme since we are only clearing
     // keys.
     $extension_config->save(TRUE);
     $this->state->set('system.theme.data', $current_theme_data);
     // @todo Remove system_list().
     $this->themeHandler->refreshInfo();
     $this->resetSystem();
     $this->moduleHandler->invokeAll('themes_uninstalled', [$theme_list]);
 }
示例#12
0
 /**
  * Shows diff of specified configuration file.
  *
  * @param string $source_name
  *   The name of the configuration file.
  * @param string $target_name
  *   (optional) The name of the target configuration file if different from
  *   the $source_name.
  * @param string $collection
  *   (optional) The configuration collection name. Defaults to the default
  *   collection.
  *
  * @return string
  *   Table showing a two-way diff between the active and staged configuration.
  */
 public function diff($source_name, $target_name = NULL, $collection = NULL)
 {
     if (!isset($collection)) {
         $collection = StorageInterface::DEFAULT_COLLECTION;
     }
     $diff = $this->configManager->diff($this->targetStorage, $this->sourceStorage, $source_name, $target_name, $collection);
     $this->diffFormatter->show_header = FALSE;
     $build = array();
     $build['#title'] = t('View changes of @config_file', array('@config_file' => $source_name));
     // Add the CSS for the inline diff.
     $build['#attached']['css'][] = drupal_get_path('module', 'system') . '/css/system.diff.css';
     $build['diff'] = array('#type' => 'table', '#header' => array(array('data' => t('Old'), 'colspan' => '2'), array('data' => t('New'), 'colspan' => '2')), '#rows' => $this->diffFormatter->format($diff));
     $build['back'] = array('#type' => 'link', '#attributes' => array('class' => array('dialog-cancel')), '#title' => "Back to 'Synchronize configuration' page.", '#href' => 'admin/config/development/configuration');
     return $build;
 }
示例#13
0
 /**
  * Shows diff of specified configuration file.
  *
  * @param string $source_name
  *   The name of the configuration file.
  * @param string $target_name
  *   (optional) The name of the target configuration file if different from
  *   the $source_name.
  * @param string $collection
  *   (optional) The configuration collection name. Defaults to the default
  *   collection.
  *
  * @return string
  *   Table showing a two-way diff between the active and staged configuration.
  */
 public function diff($source_name, $target_name = NULL, $collection = NULL)
 {
     if (!isset($collection)) {
         $collection = StorageInterface::DEFAULT_COLLECTION;
     }
     $diff = $this->configManager->diff($this->targetStorage, $this->sourceStorage, $source_name, $target_name, $collection);
     $this->diffFormatter->show_header = FALSE;
     $build = array();
     $build['#title'] = t('View changes of @config_file', array('@config_file' => $source_name));
     // Add the CSS for the inline diff.
     $build['#attached']['library'][] = 'system/diff';
     $build['diff'] = array('#type' => 'table', '#header' => array(array('data' => t('Active'), 'colspan' => '2'), array('data' => t('Staged'), 'colspan' => '2')), '#rows' => $this->diffFormatter->format($diff));
     $build['back'] = array('#type' => 'link', '#attributes' => array('class' => array('dialog-cancel')), '#title' => "Back to 'Synchronize configuration' page.", '#url' => Url::fromRoute('config.sync'));
     return $build;
 }
示例#14
0
 /**
  * Finds pre-existing configuration objects for the provided extension.
  *
  * Extensions can not be installed if configuration objects exist in the
  * active storage with the same names. This can happen in a number of ways,
  * commonly:
  * - if a user has created configuration with the same name as that provided
  *   by the extension.
  * - if the extension provides default configuration that does not depend on
  *   it and the extension has been uninstalled and is about to the
  *   reinstalled.
  *
  * @return array
  *   Array of configuration object names that already exist keyed by
  *   collection.
  */
 protected function findPreExistingConfiguration(StorageInterface $storage)
 {
     $existing_configuration = array();
     // Gather information about all the supported collections.
     $collection_info = $this->configManager->getConfigCollectionInfo();
     foreach ($collection_info->getCollectionNames() as $collection) {
         $config_to_create = array_keys($this->getConfigToCreate($storage, $collection));
         $active_storage = $this->getActiveStorages($collection);
         foreach ($config_to_create as $config_name) {
             if ($active_storage->exists($config_name)) {
                 $existing_configuration[$collection][] = $config_name;
             }
         }
     }
     return $existing_configuration;
 }
 /**
  * {@inheritdoc}
  */
 public function buildForm(array $form, array &$form_state)
 {
     // Retrieve the list of modules from the key value store.
     $account = $this->currentUser()->id();
     $this->modules = $this->keyValueExpirable->get($account);
     // Prevent this page from showing when the module list is empty.
     if (empty($this->modules)) {
         return new RedirectResponse('/admin/modules/uninstall');
     }
     $data = system_rebuild_module_data();
     $form['text']['#markup'] = '<p>' . $this->t('The following modules will be completely uninstalled from your site, and <em>all data from these modules will be lost</em>!') . '</p>';
     $form['modules'] = array('#theme' => 'item_list', '#items' => array_map(function ($module) use($data) {
         return $data[$module]->info['name'];
     }, $this->modules));
     $form['entities'] = array('#type' => 'details', '#title' => $this->t('Configuration deletions'), '#description' => $this->t('The listed configuration will be deleted.'), '#collapsible' => TRUE, '#collapsed' => TRUE, '#access' => FALSE);
     // Get the dependent entities.
     $entity_types = array();
     $dependent_entities = $this->configManager->findConfigEntityDependentsAsEntities('module', $this->modules);
     foreach ($dependent_entities as $entity) {
         $entity_type_id = $entity->getEntityTypeId();
         if (!isset($form['entities'][$entity_type_id])) {
             $entity_type = $this->entityManager->getDefinition($entity_type_id);
             // Store the ID and label to sort the entity types and entities later.
             $label = $entity_type->getLabel();
             $entity_types[$entity_type_id] = $label;
             $form['entities'][$entity_type_id] = array('#theme' => 'item_list', '#title' => $label, '#items' => array());
         }
         $form['entities'][$entity_type_id]['#items'][] = $entity->label();
     }
     if (!empty($dependent_entities)) {
         $form['entities']['#access'] = TRUE;
         // Add a weight key to the entity type sections.
         asort($entity_types, SORT_FLAG_CASE);
         $weight = 0;
         foreach ($entity_types as $entity_type_id => $label) {
             $form['entities'][$entity_type_id]['#weight'] = $weight;
             // Sort the list of entity labels alphabetically.
             sort($form['entities'][$entity_type_id]['#items'], SORT_FLAG_CASE);
             $weight++;
         }
     }
     return parent::buildForm($form, $form_state);
 }
示例#16
0
 /**
  * Gets and sorts configuration data from the source and target storages.
  */
 protected function getAndSortConfigData($collection)
 {
     $source_storage = $this->getSourceStorage($collection);
     $target_storage = $this->getTargetStorage($collection);
     $target_names = $target_storage->listAll();
     $source_names = $source_storage->listAll();
     $this->targetData[$collection] = $target_storage->readMultiple($target_names);
     $this->sourceData[$collection] = $source_storage->readMultiple($source_names);
     // If the collection only supports simple configuration do not use
     // configuration dependencies.
     if ($this->configManager->supportsConfigurationEntities($collection)) {
         $dependency_manager = new ConfigDependencyManager();
         $this->targetNames[$collection] = $dependency_manager->setData($this->targetData[$collection])->sortAll();
         $this->sourceNames[$collection] = $dependency_manager->setData($this->sourceData[$collection])->sortAll();
     } else {
         $this->targetNames[$collection] = $target_names;
         $this->sourceNames[$collection] = $source_names;
     }
 }
示例#17
0
 /**
  * Imports a configuration entity rename.
  *
  * @param string $collection
  *   The configuration collection.
  * @param string $rename_name
  *   The rename configuration name, as provided by
  *   \Drupal\Core\Config\StorageComparer::createRenameName().
  *
  * @throws \Drupal\Core\Entity\EntityStorageException
  *   Thrown if the data is owned by an entity type, but the entity storage
  *   does not support imports.
  *
  * @return bool
  *   TRUE if the configuration was imported as a configuration entity. FALSE
  *   otherwise.
  *
  * @see \Drupal\Core\Config\ConfigImporter::createRenameName()
  */
 protected function importInvokeRename($collection, $rename_name)
 {
     $names = $this->storageComparer->extractRenameNames($rename_name);
     $entity_type_id = $this->configManager->getEntityTypeIdByName($names['old_name']);
     $old_config = new Config($names['old_name'], $this->storageComparer->getTargetStorage($collection), $this->eventDispatcher, $this->typedConfigManager);
     if ($old_data = $this->storageComparer->getTargetStorage($collection)->read($names['old_name'])) {
         $old_config->initWithData($old_data);
     }
     $data = $this->storageComparer->getSourceStorage($collection)->read($names['new_name']);
     $new_config = new Config($names['new_name'], $this->storageComparer->getTargetStorage($collection), $this->eventDispatcher, $this->typedConfigManager);
     if ($data !== FALSE) {
         $new_config->setData($data);
     }
     $entity_storage = $this->configManager->getEntityManager()->getStorage($entity_type_id);
     // Call to the configuration entity's storage to handle the configuration
     // change.
     if (!$entity_storage instanceof ImportableEntityStorageInterface) {
         throw new EntityStorageException(SafeMarkup::format('The entity storage "@storage" for the "@entity_type" entity type does not support imports', array('@storage' => get_class($entity_storage), '@entity_type' => $entity_type_id)));
     }
     $entity_storage->importRename($names['old_name'], $new_config, $old_config);
     $this->setProcessedConfiguration($collection, 'rename', $rename_name);
     return TRUE;
 }
示例#18
0
 /**
  * @covers ::delete
  * @covers ::doDelete
  */
 public function testDelete()
 {
     // Dependencies are tested in
     // \Drupal\Tests\config\Kernel\ConfigDependencyTest.
     $this->configManager->expects($this->any())->method('getConfigEntitiesToChangeOnDependencyRemoval')->willReturn(['update' => [], 'delete' => [], 'unchanged' => []]);
     $entities = array();
     $configs = array();
     $config_map = array();
     foreach (array('foo', 'bar') as $id) {
         $entity = $this->getMockEntity(array('id' => $id));
         $entities[] = $entity;
         $config_object = $this->getMockBuilder('Drupal\\Core\\Config\\Config')->disableOriginalConstructor()->getMock();
         $config_object->expects($this->once())->method('delete');
         $configs[] = $config_object;
         $config_map[] = array("the_config_prefix.{$id}", $config_object);
     }
     $this->cacheTagsInvalidator->expects($this->once())->method('invalidateTags')->with(array($this->entityTypeId . '_list'));
     $this->configFactory->expects($this->exactly(2))->method('getEditable')->will($this->returnValueMap($config_map));
     $this->moduleHandler->expects($this->at(0))->method('invokeAll')->with('test_entity_type_predelete');
     $this->moduleHandler->expects($this->at(1))->method('invokeAll')->with('entity_predelete');
     $this->moduleHandler->expects($this->at(2))->method('invokeAll')->with('test_entity_type_predelete');
     $this->moduleHandler->expects($this->at(3))->method('invokeAll')->with('entity_predelete');
     $this->moduleHandler->expects($this->at(4))->method('invokeAll')->with('test_entity_type_delete');
     $this->moduleHandler->expects($this->at(5))->method('invokeAll')->with('entity_delete');
     $this->moduleHandler->expects($this->at(6))->method('invokeAll')->with('test_entity_type_delete');
     $this->moduleHandler->expects($this->at(7))->method('invokeAll')->with('entity_delete');
     $this->entityStorage->delete($entities);
 }
 /**
  * @param string $entity_type_id
  *
  * @return \Drupal\Core\Config\Entity\ConfigEntityStorageInterface
  */
 protected function getStorage($entity_type_id)
 {
     return $this->configManager->getEntityManager()->getStorage($entity_type_id);
 }
示例#20
0
 /**
  * Creates a config snapshot.
  *
  * @param \Drupal\Core\Config\ConfigImporterEvent $event
  *   The Event to process.
  */
 public function onConfigImporterImport(ConfigImporterEvent $event)
 {
     $this->configManager->createSnapshot($this->sourceStorage, $this->snapshotStorage);
 }
 /**
  * Returns the original language code for this shipped configuration.
  *
  * @param string $name
  *   The configuration name.
  *
  * @return null|string
  *   Language code of the default configuration for $name. If the default
  *   configuration data for $name did not contain a language code, it is
  *   assumed to be English. The return value is NULL if no such default
  *   configuration exists.
  */
 public function getDefaultConfigLangcode($name)
 {
     // Config entities that do not have the 'default_config_hash' cannot be
     // shipped configuration regardless of whether there is a name match.
     // configurable_language entities are a special case since they can be
     // translated regardless of whether they are shipped if they in the standard
     // language list.
     $config_entity_type = $this->configManager->getEntityTypeIdByName($name);
     if (!$config_entity_type || $config_entity_type === 'configurable_language' || !empty($this->configFactory->get($name)->get('_core.default_config_hash'))) {
         $shipped = $this->defaultConfigStorage->read($name);
         if (!empty($shipped)) {
             return !empty($shipped['langcode']) ? $shipped['langcode'] : 'en';
         }
     }
     return NULL;
 }