PHP ConfigFactoryInterface::listAll方法代码示例

 /**
  * {@inheritdoc}
  */
 public function uninstall($type, $name)
 {
     // Remove all dependent configuration entities.
     $dependent_entities = $this->findConfigEntityDependentsAsEntities($type, array($name));
     // Reverse the array to that entities are removed in the correct order of
     // dependence. For example, this ensures that field instances are removed
     // before fields.
     foreach (array_reverse($dependent_entities) as $entity) {
         $entity->setUninstalling(TRUE);
         $entity->delete();
     }
     $config_names = $this->configFactory->listAll($name . '.');
     foreach ($config_names as $config_name) {
         $this->configFactory->get($config_name)->delete();
     }
     // Remove any matching configuration from collections.
     foreach ($this->activeStorage->getAllCollectionNames() as $collection) {
         $collection_storage = $this->activeStorage->createCollection($collection);
         $collection_storage->deleteAll($name . '.');
     }
     $schema_dir = drupal_get_path($type, $name) . '/' . InstallStorage::CONFIG_SCHEMA_DIRECTORY;
     if (is_dir($schema_dir)) {
         // Refresh the schema cache if uninstalling an extension that provides
         // configuration schema.
         $this->typedConfigManager->clearCachedDefinitions();
     }
 }

 /**
  * Retrieves the list of available view modes for the current node.
  *
  * @param EntityInterface $node
  *   The node being previewed.
  *
  * @return array
  *   List of available view modes for the current node.
  */
 protected function getViewModeOptions(EntityInterface $node)
 {
     $load_ids = array();
     $view_mode_options = array();
     // Load all the node's view modes.
     $view_modes = $this->entityManager->getViewModes('node');
     // Get the list of available view modes for the current node's bundle.
     $ids = $this->configFactory->listAll('core.entity_view_display.node.' . $node->bundle());
     foreach ($ids as $id) {
         $config_id = str_replace('core.entity_view_display' . '.', '', $id);
         $load_ids[] = $config_id;
     }
     $displays = entity_load_multiple('entity_view_display', $load_ids);
     // Generate the display options array.
     foreach ($displays as $display) {
         $view_mode_name = $display->get('mode');
         // Skip view modes that are not used in the front end.
         if (in_array($view_mode_name, array('rss', 'search_index'))) {
             continue;
         }
         if ($display->status()) {
             $view_mode_options[$view_mode_name] = $view_mode_name == 'default' ? t('Default') : $view_modes[$view_mode_name]['label'];
         }
     }
     return $view_mode_options;
 }

 /**
  * {@inheritdoc}
  */
 public function uninstall($type, $name)
 {
     $entities = $this->getConfigEntitiesToChangeOnDependencyRemoval($type, [$name], FALSE);
     // Fix all dependent configuration entities.
     /** @var \Drupal\Core\Config\Entity\ConfigEntityInterface $entity */
     foreach ($entities['update'] as $entity) {
         $entity->save();
     }
     // Remove all dependent configuration entities.
     foreach ($entities['delete'] as $entity) {
         $entity->setUninstalling(TRUE);
         $entity->delete();
     }
     $config_names = $this->configFactory->listAll($name . '.');
     foreach ($config_names as $config_name) {
         $this->configFactory->getEditable($config_name)->delete();
     }
     // Remove any matching configuration from collections.
     foreach ($this->activeStorage->getAllCollectionNames() as $collection) {
         $collection_storage = $this->activeStorage->createCollection($collection);
         $collection_storage->deleteAll($name . '.');
     }
     $schema_dir = drupal_get_path($type, $name) . '/' . InstallStorage::CONFIG_SCHEMA_DIRECTORY;
     if (is_dir($schema_dir)) {
         // Refresh the schema cache if uninstalling an extension that provides
         // configuration schema.
         $this->typedConfigManager->clearCachedDefinitions();
     }
 }

 /**
  * {@inheritdoc}
  */
 public function getLanguages($flags = LanguageInterface::STATE_CONFIGURABLE)
 {
     if (!isset($this->languages)) {
         // Prepopulate the language list with the default language to keep things
         // working even if we have no configuration.
         $default = $this->getDefaultLanguage();
         $this->languages = array($default->getId() => $default);
         // Retrieve the list of languages defined in configuration.
         $prefix = 'language.entity.';
         $config_ids = $this->configFactory->listAll($prefix);
         // Instantiate languages from config objects.
         $weight = 0;
         foreach ($this->configFactory->loadMultiple($config_ids) as $config) {
             $data = $config->get();
             $langcode = $data['id'];
             // Initialize default property so callers have an easy reference and can
             // save the same object without data loss.
             $data['default'] = $langcode == $default->getId();
             $data['name'] = $data['label'];
             $this->languages[$langcode] = new Language($data);
             $weight = max(array($weight, $this->languages[$langcode]->getWeight()));
         }
         // Add locked languages, they will be filtered later if needed.
         $this->languages += $this->getDefaultLockedLanguages($weight);
         // Sort the language list by weight then title.
         Language::sort($this->languages);
     }
     return parent::getLanguages($flags);
 }

 /**
  * Finds default configuration with unmet dependencies.
  *
  * @param array $enabled_extensions
  *   A list of all the currently enabled modules and themes.
  *
  * @return array
  *   List of configuration that has unmet dependencies
  */
 protected function findDefaultConfigWithUnmetDependencies(StorageInterface $storage, array $enabled_extensions, StorageInterface $profile_storage = NULL)
 {
     $config_to_create = $this->getConfigToCreate($storage, StorageInterface::DEFAULT_COLLECTION, '', $profile_storage);
     $all_config = array_merge($this->configFactory->listAll(), array_keys($config_to_create));
     return array_filter(array_keys($config_to_create), function ($config_name) use($enabled_extensions, $all_config, $config_to_create) {
         return !$this->validateDependencies($config_name, $config_to_create[$config_name], $enabled_extensions, $all_config);
     });
 }

 /**
  * {@inheritdoc}
  */
 public function getAllDefinedLanguages()
 {
     // Get list of all configured languages.
     $languages = [];
     // See Drupal\language\ConfigurableLanguageManager::getLanguages() for details
     $predefined = LanguageManager::getStandardLanguageList();
     foreach ($predefined as $key => $value) {
         $languages[$key] = new TranslatableMarkup($value[0]);
     }
     $config_ids = $this->configFactory->listAll('language.entity.');
     foreach ($this->configFactory->loadMultiple($config_ids) as $config) {
         $data = $config->get();
         $languages[$data['id']] = new TranslatableMarkup($data['label']);
     }
     asort($languages);
     return $languages;
 }

 /**
  * {@inheritdoc}
  */
 public function uninstall($type, $name)
 {
     // Remove all dependent configuration entities.
     $extension_dependent_entities = $this->findConfigEntityDependentsAsEntities($type, array($name));
     // Give config entities a chance to become independent of the entities we
     // are going to delete.
     foreach ($extension_dependent_entities as $entity) {
         $entity_dependencies = $entity->getDependencies();
         if (empty($entity_dependencies)) {
             // No dependent entities nothing to do.
             continue;
         }
         // Work out if any of the entity's dependencies are going to be affected
         // by the uninstall.
         $affected_dependencies = array('entity' => array(), 'module' => array(), 'theme' => array());
         if (isset($entity_dependencies['entity'])) {
             foreach ($extension_dependent_entities as $extension_dependent_entity) {
                 if (in_array($extension_dependent_entity->getConfigDependencyName(), $entity_dependencies['entity'])) {
                     $affected_dependencies['entity'][] = $extension_dependent_entity;
                 }
             }
         }
         // Check if the extension being uninstalled is a dependency of the entity.
         if (isset($entity_dependencies[$type]) && in_array($name, $entity_dependencies[$type])) {
             $affected_dependencies[$type] = array($name);
         }
         // Inform the entity.
         $entity->onDependencyRemoval($affected_dependencies);
     }
     // Recalculate the dependencies, some config entities may have fixed their
     // dependencies on the to-be-removed entities.
     $extension_dependent_entities = $this->findConfigEntityDependentsAsEntities($type, array($name));
     // Reverse the array to that entities are removed in the correct order of
     // dependence. For example, this ensures that fields are removed before
     // field storages.
     foreach (array_reverse($extension_dependent_entities) as $extension_dependent_entity) {
         $extension_dependent_entity->setUninstalling(TRUE);
         $extension_dependent_entity->delete();
     }
     $config_names = $this->configFactory->listAll($name . '.');
     foreach ($config_names as $config_name) {
         $this->configFactory->get($config_name)->delete();
     }
     // Remove any matching configuration from collections.
     foreach ($this->activeStorage->getAllCollectionNames() as $collection) {
         $collection_storage = $this->activeStorage->createCollection($collection);
         $collection_storage->deleteAll($name . '.');
     }
     $schema_dir = drupal_get_path($type, $name) . '/' . InstallStorage::CONFIG_SCHEMA_DIRECTORY;
     if (is_dir($schema_dir)) {
         // Refresh the schema cache if uninstalling an extension that provides
         // configuration schema.
         $this->typedConfigManager->clearCachedDefinitions();
     }
 }

 public function get($entity = NULL, $bundle = NULL)
 {
     if ($entity && $bundle) {
         $permission = 'Administer content types';
         if (!$this->currentUser->hasPermission($permission)) {
             throw new AccessDeniedHttpException();
         }
         $entity_view_display = $this->entityManager->getDefinition('entity_view_display');
         $config_prefix = $entity_view_display->getConfigPrefix();
         $list = $this->configFactory->listAll($config_prefix . '.' . $entity . '.' . $bundle . '.');
         $view_modes = array();
         foreach ($list as $view_mode) {
             $view_mode_machine_id = str_replace($config_prefix . '.', '', $view_mode);
             list(, , $view_mode_label) = explode('.', $view_mode_machine_id);
             $view_modes[$view_mode_machine_id] = $view_mode_label;
         }
         if (!empty($view_modes)) {
             return new ResourceResponse($view_modes);
         }
         throw new NotFoundHttpException(t('Views modes for @entity and @bundle were not found', array('@entity' => $entity, '@bundle' => $bundle)));
     }
     throw new HttpException(t('Entity or Bundle weren\'t provided'));
 }

 /**
  * {@inheritdoc}
  */
 protected function doLoadMultiple(array $ids = NULL)
 {
     $prefix = $this->getPrefix();
     // Get the names of the configuration entities we are going to load.
     if ($ids === NULL) {
         $names = $this->configFactory->listAll($prefix);
     } else {
         $names = array();
         foreach ($ids as $id) {
             // Add the prefix to the ID to serve as the configuration object name.
             $names[] = $prefix . $id;
         }
     }
     // Load all of the configuration entities.
     /** @var \Drupal\Core\Config\Config[] $configs */
     $configs = [];
     $records = [];
     foreach ($this->configFactory->loadMultiple($names) as $config) {
         $id = $config->get($this->idKey);
         $records[$id] = $this->overrideFree ? $config->getOriginal(NULL, FALSE) : $config->get();
         $configs[$id] = $config;
     }
     $entities = $this->mapFromStorageRecords($records, $configs);
     // Config entities wrap config objects, and therefore they need to inherit
     // the cacheability metadata of config objects (to ensure e.g. additional
     // cacheability metadata added by config overrides is not lost).
     foreach ($entities as $id => $entity) {
         // But rather than simply inheriting all cacheability metadata of config
         // objects, we need to make sure the self-referring cache tag that is
         // present on Config objects is not added to the Config entity. It must be
         // removed for 3 reasons:
         // 1. When renaming/duplicating a Config entity, the cache tag of the
         //    original config object would remain present, which would be wrong.
         // 2. Some Config entities choose to not use the cache tag that the under-
         //    lying Config object provides by default (For performance and
         //    cacheability reasons it may not make sense to have a unique cache
         //    tag for every Config entity. The DateFormat Config entity specifies
         //    the 'rendered' cache tag for example, because A) date formats are
         //    changed extremely rarely, so invalidating all render cache items is
         //    fine, B) it means fewer cache tags per page.).
         // 3. Fewer cache tags is better for performance.
         $self_referring_cache_tag = ['config:' . $configs[$id]->getName()];
         $config_cacheability = CacheableMetadata::createFromObject($configs[$id]);
         $config_cacheability->setCacheTags(array_diff($config_cacheability->getCacheTags(), $self_referring_cache_tag));
         $entity->addCacheableDependency($config_cacheability);
     }
     return $entities;
 }

 /**
  * Returns entity (form) displays for the current entity display type.
  *
  * @return array
  *   An array holding entity displays or entity form displays.
  */
 protected function getDisplays()
 {
     $load_ids = array();
     $display_entity_type = $this->getDisplayType();
     $entity_type = $this->entityManager->getDefinition($display_entity_type);
     $config_prefix = $entity_type->getConfigPrefix();
     $ids = $this->configFactory->listAll($config_prefix . '.' . $this->entity_type . '.' . $this->bundle . '.');
     foreach ($ids as $id) {
         $config_id = str_replace($config_prefix . '.', '', $id);
         list(, , $display_mode) = explode('.', $config_id);
         if ($display_mode != 'default') {
             $load_ids[] = $config_id;
         }
     }
     return entity_load_multiple($display_entity_type, $load_ids);
 }

 /**
  * {@inheritdoc}
  */
 protected function doLoadMultiple(array $ids = NULL)
 {
     $prefix = $this->getPrefix();
     // Get the names of the configuration entities we are going to load.
     if ($ids === NULL) {
         $names = $this->configFactory->listAll($prefix);
     } else {
         $names = array();
         foreach ($ids as $id) {
             // Add the prefix to the ID to serve as the configuration object name.
             $names[] = $prefix . $id;
         }
     }
     // Load all of the configuration entities.
     $records = array();
     foreach ($this->configFactory->loadMultiple($names) as $config) {
         $records[$config->get($this->idKey)] = $this->overrideFree ? $config->getOriginal(NULL, FALSE) : $config->get();
     }
     return $this->mapFromStorageRecords($records);
 }

 /**
  * Loads the config records to examine for the query.
  *
  * @return array
  *   Config records keyed by entity IDs.
  */
 protected function loadRecords()
 {
     $prefix = $this->entityType->getConfigPrefix() . '.';
     $prefix_length = strlen($prefix);
     // Search the conditions for restrictions on entity IDs.
     $ids = array();
     if ($this->condition->getConjunction() == 'AND') {
         foreach ($this->condition->conditions() as $condition) {
             if (is_string($condition['field']) && $condition['field'] == $this->entityType->getKey('id')) {
                 $operator = $condition['operator'] ?: (is_array($condition['value']) ? 'IN' : '=');
                 if ($operator == '=') {
                     $ids = array($condition['value']);
                 } elseif ($operator == 'IN') {
                     $ids = $condition['value'];
                 }
                 // We stop at the first restricting condition on ID. In the (weird)
                 // case where there are additional restricting conditions, results
                 // will be eliminated when the conditions are checked on the loaded
                 // records.
                 if ($ids) {
                     break;
                 }
             }
         }
     }
     // If there are conditions restricting config ID, we can narrow the list of
     // records to load and parse.
     if ($ids) {
         $names = array_map(function ($id) use($prefix) {
             return $prefix . $id;
         }, $ids);
     } else {
         $names = $this->configFactory->listAll($prefix);
     }
     // Load the corresponding records.
     $records = array();
     foreach ($this->configFactory->loadMultiple($names) as $config) {
         $records[substr($config->getName(), $prefix_length)] = $config->get();
     }
     return $records;
 }

 /**
  * {@inheritdoc}
  */
 public function getLanguages($flags = LanguageInterface::STATE_CONFIGURABLE)
 {
     // If a config override is set, cache using that language's ID.
     if ($override_language = $this->getConfigOverrideLanguage()) {
         $static_cache_id = $override_language->getId();
     } else {
         $static_cache_id = $this->getCurrentLanguage()->getId();
     }
     if (!isset($this->languages[$static_cache_id][$flags])) {
         // Initialize the language list with the default language and default
         // locked languages. These cannot be removed. This serves as a fallback
         // list if this method is invoked while the language module is installed
         // and the configuration entities for languages are not yet fully
         // imported.
         $default = $this->getDefaultLanguage();
         $languages = array($default->getId() => $default);
         $languages += $this->getDefaultLockedLanguages($default->getWeight());
         // Load configurable languages on top of the defaults. Ideally this could
         // use the entity API to load and instantiate ConfigurableLanguage
         // objects. However the entity API depends on the language system, so that
         // would result in infinite loops. We use the configuration system
         // directly and instantiate runtime Language objects. When language
         // entities are imported those cover the default and locked languages, so
         // site-specific configuration will prevail over the fallback values.
         // Having them in the array already ensures if this is invoked in the
         // middle of importing language configuration entities, the defaults are
         // always present.
         $config_ids = $this->configFactory->listAll('language.entity.');
         foreach ($this->configFactory->loadMultiple($config_ids) as $config) {
             $data = $config->get();
             $data['name'] = $data['label'];
             $languages[$data['id']] = new Language($data);
         }
         Language::sort($languages);
         // Filter the full list of languages based on the value of $flags.
         $this->languages[$static_cache_id][$flags] = $this->filterLanguages($languages, $flags);
     }
     return $this->languages[$static_cache_id][$flags];
 }

 /**
  * Creates new instance of BaseMapping class.
  *
  * @param ConfigFactoryInterface $config
  */
 public function __construct(ConfigFactoryInterface $config)
 {
     $ids = $config->listAll($this->getConfigKey());
     $this->config = $config->loadMultiple($ids);
 }

 /**
  * Loads the config records to examine for the query.
  *
  * @return array
  *   Config records keyed by entity IDs.
  */
 protected function loadRecords()
 {
     $prefix = $this->entityType->getConfigPrefix() . '.';
     $prefix_length = strlen($prefix);
     // Search the conditions for restrictions on configuration object names.
     $names = FALSE;
     $id_condition = NULL;
     $id_key = $this->entityType->getKey('id');
     if ($this->condition->getConjunction() == 'AND') {
         $lookup_keys = $this->entityType->getLookupKeys();
         $conditions = $this->condition->conditions();
         foreach ($conditions as $condition_key => $condition) {
             $operator = $condition['operator'] ?: (is_array($condition['value']) ? 'IN' : '=');
             if (is_string($condition['field']) && ($operator == 'IN' || $operator == '=')) {
                 // Special case ID lookups.
                 if ($condition['field'] == $id_key) {
                     $ids = (array) $condition['value'];
                     $names = array_map(function ($id) use($prefix) {
                         return $prefix . $id;
                     }, $ids);
                 } elseif (in_array($condition['field'], $lookup_keys)) {
                     // If we don't find anything then there are no matches. No point in
                     // listing anything.
                     $names = array();
                     $keys = (array) $condition['value'];
                     $keys = array_map(function ($value) use($condition) {
                         return $condition['field'] . ':' . $value;
                     }, $keys);
                     foreach ($this->getConfigKeyStore()->getMultiple($keys) as $list) {
                         $names = array_merge($names, $list);
                     }
                 }
             } elseif (!$id_condition && $condition['field'] == $id_key) {
                 $id_condition = $condition;
             }
             // We stop at the first restricting condition on name. In the case where
             // there are additional restricting conditions, results will be
             // eliminated when the conditions are checked on the loaded records.
             if ($names !== FALSE) {
                 // If the condition has been responsible for narrowing the list of
                 // configuration to check there is no point in checking it further.
                 unset($conditions[$condition_key]);
                 break;
             }
         }
     }
     // If no restrictions on IDs were found, we need to parse all records.
     if ($names === FALSE) {
         $names = $this->configFactory->listAll($prefix);
     }
     // In case we have an ID condition, try to narrow down the list of config
     // objects to load.
     if ($id_condition && !empty($names)) {
         $value = $id_condition['value'];
         $filter = NULL;
         switch ($id_condition['operator']) {
             case '<>':
                 $filter = function ($name) use($value, $prefix_length) {
                     $id = substr($name, $prefix_length);
                     return $id !== $value;
                 };
                 break;
             case 'STARTS_WITH':
                 $filter = function ($name) use($value, $prefix_length) {
                     $id = substr($name, $prefix_length);
                     return strpos($id, $value) === 0;
                 };
                 break;
             case 'CONTAINS':
                 $filter = function ($name) use($value, $prefix_length) {
                     $id = substr($name, $prefix_length);
                     return strpos($id, $value) !== FALSE;
                 };
                 break;
             case 'ENDS_WITH':
                 $filter = function ($name) use($value, $prefix_length) {
                     $id = substr($name, $prefix_length);
                     return strrpos($id, $value) === strlen($id) - strlen($value);
                 };
                 break;
         }
         if ($filter) {
             $names = array_filter($names, $filter);
         }
     }
     // Load the corresponding records.
     $records = array();
     foreach ($this->configFactory->loadMultiple($names) as $config) {
         $records[substr($config->getName(), $prefix_length)] = $config->get();
     }
     return $records;
 }