ControllerBase.php

<?php

namespace Drupal\Core\Controller;

use Drupal\Core\DependencyInjection\AutowireTrait;
use Drupal\Core\DependencyInjection\ContainerInjectionInterface;
use Drupal\Core\Logger\LoggerChannelTrait;
use Drupal\Core\Routing\RedirectDestinationTrait;
use Drupal\Core\StringTranslation\StringTranslationTrait;
use Drupal\Core\Url;
use Drupal\Core\Messenger\MessengerTrait;
use Symfony\Component\HttpFoundation\RedirectResponse;

/**
 * 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 AutowireTrait;
    use LoggerChannelTrait;
    use MessengerTrait;
    use RedirectDestinationTrait;
    use StringTranslationTrait;
    
    /**
     * 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;
    
    /**
     * 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('my_module.admin') @endcode will return a configuration
     * object in which the my_module 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('my_module.admin') @endcode,
     *   the config object returned will contain the contents of my_module.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 a redirect response object for the specified route.
     *
     * @param string $route_name
     *   The name of the route to which to redirect.
     * @param array $route_parameters
     *   (optional) Parameters for the route.
     * @param array $options
     *   (optional) An associative array of additional options.
     * @param int $status
     *   (optional) The HTTP redirect status code for the redirect. The default is
     *   302 Found.
     *
     * @return \Symfony\Component\HttpFoundation\RedirectResponse
     *   A redirect response object that may be returned by the controller.
     */
    protected function redirect($route_name, array $route_parameters = [], array $options = [], $status = 302) {
        $options['absolute'] = TRUE;
        return new RedirectResponse(Url::fromRoute($route_name, $route_parameters, $options)->toString(), $status);
    }
    
    /**
     * 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();
    }

}