Code Coverage |
||||||||||
Classes and Traits |
Functions and Methods |
Lines |
||||||||
| Total | |
0.00% |
0 / 1 |
|
16.67% |
2 / 12 |
CRAP | |
13.33% |
4 / 30 |
| ControllerBase | |
0.00% |
0 / 1 |
|
23.08% |
3 / 13 |
367.36 | |
13.33% |
4 / 30 |
| create | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 1 |
|||
| entityManager | |
100.00% |
1 / 1 |
2 | |
100.00% |
0 / 0 |
|||
| entityTypeManager | |
0.00% |
0 / 1 |
6 | |
0.00% |
0 / 3 |
|||
| entityFormBuilder | |
0.00% |
0 / 1 |
6 | |
0.00% |
0 / 3 |
|||
| cache | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 1 |
|||
| config | |
100.00% |
1 / 1 |
2 | |
100.00% |
3 / 3 |
|||
| keyValue | |
0.00% |
0 / 1 |
6 | |
0.00% |
0 / 3 |
|||
| state | |
0.00% |
0 / 1 |
6 | |
0.00% |
0 / 3 |
|||
| moduleHandler | |
0.00% |
0 / 1 |
6 | |
0.00% |
0 / 3 |
|||
| formBuilder | |
0.00% |
0 / 1 |
6 | |
0.00% |
0 / 3 |
|||
| currentUser | |
0.00% |
0 / 1 |
6 | |
0.00% |
0 / 3 |
|||
| languageManager | |
0.00% |
0 / 1 |
6 | |
0.00% |
0 / 3 |
|||
| container | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| <?php | |
| /** | |
| * @file | |
| * Contains \Drupal\Core\Controller\ControllerBase. | |
| */ | |
| namespace Drupal\Core\Controller; | |
| use Drupal\Core\DependencyInjection\ContainerInjectionInterface; | |
| 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; | |
| /** | |
| * 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 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\Config | |
| */ | |
| 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\KeyValueStore\KeyValueStoreInterface | |
| */ | |
| 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\KeyValueStore\KeyValueStoreInterface | |
| */ | |
| 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 $container | |
| * The service container. | |
| */ | |
| private function container() { | |
| return \Drupal::getContainer(); | |
| } | |
| } |