Mercurial > hg > isophonics-drupal-site
view core/lib/Drupal/Core/Controller/ControllerBase.php @ 16:c2387f117808
Routine composer update
author | Chris Cannam |
---|---|
date | Tue, 10 Jul 2018 15:07:59 +0100 |
parents | 1fec387a4317 |
children | af1871eacc83 |
line wrap: on
line source
<?php namespace Drupal\Core\Controller; use Drupal\Core\DependencyInjection\ContainerInjectionInterface; use Drupal\Core\Logger\LoggerChannelTrait; use Drupal\Core\Routing\LinkGeneratorTrait; use Drupal\Core\Routing\RedirectDestinationTrait; use Drupal\Core\Routing\UrlGeneratorTrait; use Drupal\Core\StringTranslation\StringTranslationTrait; use Symfony\Component\DependencyInjection\ContainerInterface; use Drupal\Core\Messenger\MessengerTrait; /** * Utility base class for thin controllers. * * Controllers that use this base class have access to a number of utility * methods and to the Container, which can greatly reduce boilerplate dependency * handling code. However, it also makes the class considerably more * difficult to unit test. Therefore this base class should only be used by * controller classes that contain only trivial glue code. Controllers that * contain sufficiently complex logic that it's worth testing should not use * this base class but use ContainerInjectionInterface instead, or even * better be refactored to be trivial glue code. * * The services exposed here are those that it is reasonable for a well-behaved * controller to leverage. A controller that needs other services may * need to be refactored into a thin controller and a dependent unit-testable * service. * * @see \Drupal\Core\DependencyInjection\ContainerInjectionInterface * * @ingroup routing */ abstract class ControllerBase implements ContainerInjectionInterface { use LinkGeneratorTrait; use LoggerChannelTrait; use MessengerTrait; use RedirectDestinationTrait; use StringTranslationTrait; use UrlGeneratorTrait; /** * The entity manager. * * @var \Drupal\Core\Entity\EntityManagerInterface */ protected $entityManager; /** * The entity type manager. * * @var \Drupal\Core\Entity\EntityTypeManagerInterface */ protected $entityTypeManager; /** * The entity form builder. * * @var \Drupal\Core\Entity\EntityFormBuilderInterface */ protected $entityFormBuilder; /** * The language manager. * * @var \Drupal\Core\Language\LanguageManagerInterface */ protected $languageManager; /** * The configuration factory. * * @var \Drupal\Core\Config\ConfigFactoryInterface */ protected $configFactory; /** * The key-value storage. * * @var \Drupal\Core\KeyValueStore\KeyValueStoreInterface */ protected $keyValue; /** * The current user service. * * @var \Drupal\Core\Session\AccountInterface */ protected $currentUser; /** * The state service. * * @var \Drupal\Core\State\StateInterface */ protected $stateService; /** * The module handler. * * @var \Drupal\Core\Extension\ModuleHandlerInterface */ protected $moduleHandler; /** * The form builder. * * @var \Drupal\Core\Form\FormBuilderInterface */ protected $formBuilder; /** * {@inheritdoc} */ public static function create(ContainerInterface $container) { return new static(); } /** * Retrieves the entity manager service. * * @return \Drupal\Core\Entity\EntityManagerInterface * The entity manager service. * * @deprecated in Drupal 8.0.0, will be removed before Drupal 9.0.0. * Most of the time static::entityTypeManager() is supposed to be used * instead. */ protected function entityManager() { if (!$this->entityManager) { $this->entityManager = $this->container()->get('entity.manager'); } return $this->entityManager; } /** * Retrieves the entity type manager. * * @return \Drupal\Core\Entity\EntityTypeManagerInterface * The entity type manager. */ protected function entityTypeManager() { if (!isset($this->entityTypeManager)) { $this->entityTypeManager = $this->container()->get('entity_type.manager'); } return $this->entityTypeManager; } /** * Retrieves the entity form builder. * * @return \Drupal\Core\Entity\EntityFormBuilderInterface * The entity form builder. */ protected function entityFormBuilder() { if (!$this->entityFormBuilder) { $this->entityFormBuilder = $this->container()->get('entity.form_builder'); } return $this->entityFormBuilder; } /** * Returns the requested cache bin. * * @param string $bin * (optional) The cache bin for which the cache object should be returned, * defaults to 'default'. * * @return \Drupal\Core\Cache\CacheBackendInterface * The cache object associated with the specified bin. */ protected function cache($bin = 'default') { return $this->container()->get('cache.' . $bin); } /** * Retrieves a configuration object. * * This is the main entry point to the configuration API. Calling * @code $this->config('book.admin') @endcode will return a configuration * object in which the book module can store its administrative settings. * * @param string $name * The name of the configuration object to retrieve. The name corresponds to * a configuration file. For @code \Drupal::config('book.admin') @endcode, * the config object returned will contain the contents of book.admin * configuration file. * * @return \Drupal\Core\Config\Config * A configuration object. */ protected function config($name) { if (!$this->configFactory) { $this->configFactory = $this->container()->get('config.factory'); } return $this->configFactory->get($name); } /** * Returns a key/value storage collection. * * @param string $collection * Name of the key/value collection to return. * * @return \Drupal\Core\KeyValueStore\KeyValueStoreInterface */ protected function keyValue($collection) { if (!$this->keyValue) { $this->keyValue = $this->container()->get('keyvalue')->get($collection); } return $this->keyValue; } /** * Returns the state storage service. * * Use this to store machine-generated data, local to a specific environment * that does not need deploying and does not need human editing; for example, * the last time cron was run. Data which needs to be edited by humans and * needs to be the same across development, production, etc. environments * (for example, the system maintenance message) should use config() instead. * * @return \Drupal\Core\State\StateInterface */ protected function state() { if (!$this->stateService) { $this->stateService = $this->container()->get('state'); } return $this->stateService; } /** * Returns the module handler. * * @return \Drupal\Core\Extension\ModuleHandlerInterface */ protected function moduleHandler() { if (!$this->moduleHandler) { $this->moduleHandler = $this->container()->get('module_handler'); } return $this->moduleHandler; } /** * Returns the form builder service. * * @return \Drupal\Core\Form\FormBuilderInterface */ protected function formBuilder() { if (!$this->formBuilder) { $this->formBuilder = $this->container()->get('form_builder'); } return $this->formBuilder; } /** * Returns the current user. * * @return \Drupal\Core\Session\AccountInterface * The current user. */ protected function currentUser() { if (!$this->currentUser) { $this->currentUser = $this->container()->get('current_user'); } return $this->currentUser; } /** * Returns the language manager service. * * @return \Drupal\Core\Language\LanguageManagerInterface * The language manager. */ protected function languageManager() { if (!$this->languageManager) { $this->languageManager = $this->container()->get('language_manager'); } return $this->languageManager; } /** * Returns the service container. * * This method is marked private to prevent sub-classes from retrieving * services from the container through it. Instead, * \Drupal\Core\DependencyInjection\ContainerInjectionInterface should be used * for injecting services. * * @return \Symfony\Component\DependencyInjection\ContainerInterface * The service container. */ private function container() { return \Drupal::getContainer(); } }