class ConfigEntityMapper in Drupal 10

Same name and namespace in other branches

8 core/modules/config_translation/src/ConfigEntityMapper.php \Drupal\config_translation\ConfigEntityMapper
9 core/modules/config_translation/src/ConfigEntityMapper.php \Drupal\config_translation\ConfigEntityMapper

Configuration mapper for configuration entities.

Hierarchy

class \Drupal\Component\Plugin\PluginBase implements DerivativeInspectionInterface, PluginInspectionInterface
- class \Drupal\Core\Plugin\PluginBase uses DependencySerializationTrait, MessengerTrait, StringTranslationTrait
  - class \Drupal\config_translation\ConfigNamesMapper implements ConfigMapperInterface, ContainerFactoryPluginInterface
    class \Drupal\config_translation\ConfigEntityMapper

Expanded class hierarchy of ConfigEntityMapper

3 files declare their use of ConfigEntityMapper

ConfigEntityMapperTest.php in core/modules/config_translation/tests/src/Unit/ConfigEntityMapperTest.php
EditorConfigTranslationSubscriber.php in core/modules/editor/src/EventSubscriber/EditorConfigTranslationSubscriber.php
NodeTypeMapper.php in core/modules/node/src/ConfigTranslation/NodeTypeMapper.php

File

core/modules/config_translation/src/ConfigEntityMapper.php, line 22

Namespace

Drupal\config_translation

View source

class ConfigEntityMapper extends ConfigNamesMapper {

  /**
   * The entity type manager.
   *
   * @var \Drupal\Core\Entity\EntityTypeManagerInterface
   */
  protected $entityTypeManager;

  /**
   * Configuration entity type name.
   *
   * @var string
   */
  protected $entityType;

  /**
   * Loaded entity instance to help produce the translation interface.
   *
   * @var \Drupal\Core\Config\Entity\ConfigEntityInterface
   */
  protected $entity;

  /**
   * The label for the entity type.
   *
   * @var string
   */
  protected $typeLabel;

  /**
   * Constructs a ConfigEntityMapper.
   *
   * @param string $plugin_id
   *   The config mapper plugin ID.
   * @param mixed $plugin_definition
   *   An array of plugin information as documented in
   *   ConfigNamesMapper::__construct() with the following additional keys:
   *   - entity_type: The name of the entity type this mapper belongs to.
   * @param \Drupal\Core\Config\ConfigFactoryInterface $config_factory
   *   The configuration factory.
   * @param \Drupal\Core\Config\TypedConfigManagerInterface $typed_config
   *   The typed configuration manager.
   * @param \Drupal\locale\LocaleConfigManager $locale_config_manager
   *   The locale configuration manager.
   * @param \Drupal\config_translation\ConfigMapperManagerInterface $config_mapper_manager
   *   The mapper plugin discovery service.
   * @param \Drupal\Core\Routing\RouteProviderInterface $route_provider
   *   The route provider.
   * @param \Drupal\Core\StringTranslation\TranslationInterface $translation_manager
   *   The string translation manager.
   * @param \Drupal\Core\Entity\EntityTypeManagerInterface $entity_type_manager
   *   The entity type manager.
   * @param \Drupal\Core\Language\LanguageManagerInterface $language_manager
   *   The language manager.
   * @param \Symfony\Contracts\EventDispatcher\EventDispatcherInterface $event_dispatcher
   *   The event dispatcher.
   */
  public function __construct($plugin_id, $plugin_definition, ConfigFactoryInterface $config_factory, TypedConfigManagerInterface $typed_config, LocaleConfigManager $locale_config_manager, ConfigMapperManagerInterface $config_mapper_manager, RouteProviderInterface $route_provider, TranslationInterface $translation_manager, EntityTypeManagerInterface $entity_type_manager, LanguageManagerInterface $language_manager, EventDispatcherInterface $event_dispatcher = NULL) {
    parent::__construct($plugin_id, $plugin_definition, $config_factory, $typed_config, $locale_config_manager, $config_mapper_manager, $route_provider, $translation_manager, $language_manager, $event_dispatcher);
    $this
      ->setType($plugin_definition['entity_type']);
    $this->entityTypeManager = $entity_type_manager;
  }

  /**
   * {@inheritdoc}
   */
  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {

    // Note that we ignore the plugin $configuration because mappers have
    // nothing to configure in themselves.
    return new static($plugin_id, $plugin_definition, $container
      ->get('config.factory'), $container
      ->get('config.typed'), $container
      ->get('locale.config_manager'), $container
      ->get('plugin.manager.config_translation.mapper'), $container
      ->get('router.route_provider'), $container
      ->get('string_translation'), $container
      ->get('entity_type.manager'), $container
      ->get('language_manager'), $container
      ->get('event_dispatcher'));
  }

  /**
   * {@inheritdoc}
   */
  public function populateFromRouteMatch(RouteMatchInterface $route_match) {
    $entity = $route_match
      ->getParameter($this->entityType);
    $this
      ->setEntity($entity);
    parent::populateFromRouteMatch($route_match);
  }

  /**
   * Gets the entity instance for this mapper.
   *
   * @return \Drupal\Core\Config\Entity\ConfigEntityInterface
   *   The configuration entity.
   */
  public function getEntity() {
    return $this->entity;
  }

  /**
   * Sets the entity instance for this mapper.
   *
   * This method can only be invoked when the concrete entity is known, that is
   * in a request for an entity translation path. After this method is called,
   * the mapper is fully populated with the proper display title and
   * configuration names to use to check permissions or display a translation
   * screen.
   *
   * @param \Drupal\Core\Config\Entity\ConfigEntityInterface $entity
   *   The configuration entity to set.
   *
   * @return bool
   *   TRUE, if the entity was set successfully; FALSE otherwise.
   */
  public function setEntity(ConfigEntityInterface $entity) {
    if (isset($this->entity)) {
      return FALSE;
    }
    $this->entity = $entity;

    // Add the list of configuration IDs belonging to this entity. We add on a
    // possibly existing list of names. This allows modules to alter the entity
    // page with more names if form altering added more configuration to an
    // entity. This is not a Drupal 8 best practice (ideally the configuration
    // would have pluggable components), but this may happen as well.

    /** @var \Drupal\Core\Config\Entity\ConfigEntityTypeInterface $entity_type_info */
    $entity_type_info = $this->entityTypeManager
      ->getDefinition($this->entityType);
    $this
      ->addConfigName($entity_type_info
      ->getConfigPrefix() . '.' . $entity
      ->id());
    return TRUE;
  }

  /**
   * {@inheritdoc}
   */
  public function getTitle() {
    return $this->entity
      ->label() . ' ' . $this->pluginDefinition['title'];
  }

  /**
   * {@inheritdoc}
   */
  public function getBaseRouteParameters() {
    return [
      $this->entityType => $this->entity
        ->id(),
    ];
  }

  /**
   * Set entity type for this mapper.
   *
   * This should be set in initialization. A mapper that knows its type but
   * not yet its names is still useful for router item and tab generation. The
   * concrete entity only turns out later with actual controller invocations,
   * when the setEntity() method is invoked before the rest of the methods are
   * used.
   *
   * @param string $entity_type
   *   The entity type to set.
   *
   * @return bool
   *   TRUE if the entity type was set correctly; FALSE otherwise.
   */
  public function setType($entity_type) {
    if (isset($this->entityType)) {
      return FALSE;
    }
    $this->entityType = $entity_type;
    return TRUE;
  }

  /**
   * Gets the entity type from this mapper.
   *
   * @return string
   */
  public function getType() {
    return $this->entityType;
  }

  /**
   * {@inheritdoc}
   */
  public function getTypeName() {
    $entity_type_info = $this->entityTypeManager
      ->getDefinition($this->entityType);
    return $entity_type_info
      ->getLabel();
  }

  /**
   * {@inheritdoc}
   */
  public function getTypeLabel() {
    $entityType = $this->entityTypeManager
      ->getDefinition($this->entityType);
    return $entityType
      ->getLabel();
  }

  /**
   * {@inheritdoc}
   */
  public function getOperations() {
    return [
      'list' => [
        'title' => $this
          ->t('List'),
        'url' => Url::fromRoute('config_translation.entity_list', [
          'mapper_id' => $this
            ->getPluginId(),
        ]),
      ],
    ];
  }

  /**
   * {@inheritdoc}
   */
  public function getContextualLinkGroup() {

    // @todo Contextual groups do not map to entity types in a predictable
    //   way. See https://www.drupal.org/node/2134841 to make them predictable.
    switch ($this->entityType) {
      case 'menu':
      case 'block':
        return $this->entityType;
      case 'view':
        return 'entity.view.edit_form';
      default:
        return NULL;
    }
  }

  /**
   * {@inheritdoc}
   */
  public function getOverviewRouteName() {
    return 'entity.' . $this->entityType . '.config_translation_overview';
  }

  /**
   * {@inheritdoc}
   */
  protected function processRoute(Route $route) {

    // Add entity upcasting information.
    $parameters = $route
      ->getOption('parameters') ?: [];
    $parameters += [
      $this->entityType => [
        'type' => 'entity:' . $this->entityType,
      ],
    ];
    $route
      ->setOption('parameters', $parameters);
  }

}

You are here

class ConfigEntityMapper in Drupal 10

Hierarchy

File

Namespace

Members

API Navigation