Code Coverage |
||||||||||
Classes and Traits |
Functions and Methods |
Lines |
||||||||
| Total | |
0.00% |
0 / 1 |
|
0.00% |
0 / 4 |
CRAP | |
0.00% |
0 / 38 |
| LanguageNegotiationUserAdmin | |
0.00% |
0 / 1 |
|
0.00% |
0 / 4 |
182 | |
0.00% |
0 / 38 |
| __construct | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 5 |
|||
| create | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 7 |
|||
| getLangcode | |
0.00% |
0 / 1 |
20 | |
0.00% |
0 / 6 |
|||
| isAdminPath | |
0.00% |
0 / 1 |
56 | |
0.00% |
0 / 20 |
|||
| <?php | |
| /** | |
| * @file | |
| * Contains \Drupal\user\Plugin\LanguageNegotiation\LanguageNegotiationUserAdmin. | |
| */ | |
| namespace Drupal\user\Plugin\LanguageNegotiation; | |
| use Drupal\Core\PathProcessor\PathProcessorManager; | |
| use Drupal\Core\Plugin\ContainerFactoryPluginInterface; | |
| use Drupal\Core\Routing\AdminContext; | |
| use Drupal\Core\Routing\StackedRouteMatchInterface; | |
| use Drupal\language\LanguageNegotiationMethodBase; | |
| use Symfony\Cmf\Component\Routing\RouteObjectInterface; | |
| use Symfony\Component\DependencyInjection\ContainerInterface; | |
| use Symfony\Component\HttpFoundation\Request; | |
| use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException; | |
| use Symfony\Component\Routing\Exception\ResourceNotFoundException; | |
| use Symfony\Component\Routing\Matcher\UrlMatcherInterface; | |
| /** | |
| * Identifies admin language from the user preferences. | |
| * | |
| * @LanguageNegotiation( | |
| * id = Drupal\user\Plugin\LanguageNegotiation\LanguageNegotiationUserAdmin::METHOD_ID, | |
| * types = {Drupal\Core\Language\LanguageInterface::TYPE_INTERFACE}, | |
| * weight = -10, | |
| * name = @Translation("Account administration pages"), | |
| * description = @Translation("Account administration pages language setting.") | |
| * ) | |
| */ | |
| class LanguageNegotiationUserAdmin extends LanguageNegotiationMethodBase implements ContainerFactoryPluginInterface { | |
| /** | |
| * The language negotiation method id. | |
| */ | |
| const METHOD_ID = 'language-user-admin'; | |
| /** | |
| * The admin context. | |
| * | |
| * @var \Drupal\Core\Routing\AdminContext | |
| */ | |
| protected $adminContext; | |
| /** | |
| * The router. | |
| * | |
| * This is only used when called from an event subscriber, before the request | |
| * has been populated with the route info. | |
| * | |
| * @var \Symfony\Component\Routing\Matcher\UrlMatcherInterface | |
| */ | |
| protected $router; | |
| /** | |
| * The path processor manager. | |
| * | |
| * @var \Drupal\Core\PathProcessor\PathProcessorManager | |
| */ | |
| protected $pathProcessorManager; | |
| /** | |
| * The stacked route match. | |
| * | |
| * @var \Drupal\Core\Routing\StackedRouteMatchInterface | |
| */ | |
| protected $stackedRouteMatch; | |
| /** | |
| * Constructs a new LanguageNegotiationUserAdmin instance. | |
| * | |
| * @param \Drupal\Core\Routing\AdminContext $admin_context | |
| * The admin context. | |
| * @param \Symfony\Component\Routing\Matcher\UrlMatcherInterface $router | |
| * The router. | |
| * @param \Drupal\Core\PathProcessor\PathProcessorManager $path_processor_manager | |
| * The path processor manager. | |
| * @param \Drupal\Core\Routing\StackedRouteMatchInterface $stacked_route_match | |
| * The stacked route match. | |
| */ | |
| public function __construct(AdminContext $admin_context, UrlMatcherInterface $router, PathProcessorManager $path_processor_manager, StackedRouteMatchInterface $stacked_route_match) { | |
| $this->adminContext = $admin_context; | |
| $this->router = $router; | |
| $this->pathProcessorManager = $path_processor_manager; | |
| $this->stackedRouteMatch = $stacked_route_match; | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) { | |
| return new static( | |
| $container->get('router.admin_context'), | |
| $container->get('router'), | |
| $container->get('path_processor_manager'), | |
| $container->get('current_route_match') | |
| ); | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function getLangcode(Request $request = NULL) { | |
| $langcode = NULL; | |
| // User preference (only for administrators). | |
| if ($this->currentUser->hasPermission('access administration pages') && ($preferred_admin_langcode = $this->currentUser->getPreferredAdminLangcode(FALSE)) && $this->isAdminPath($request)) { | |
| $langcode = $preferred_admin_langcode; | |
| } | |
| // Not an admin, no admin language preference or not on an admin path. | |
| return $langcode; | |
| } | |
| /** | |
| * Checks whether the given path is an administrative one. | |
| * | |
| * @param \Symfony\Component\HttpFoundation\Request $request | |
| * The request object. | |
| * | |
| * @return bool | |
| * TRUE if the path is administrative, FALSE otherwise. | |
| */ | |
| protected function isAdminPath(Request $request) { | |
| $result = FALSE; | |
| if ($request && $this->adminContext) { | |
| // If called from an event subscriber, the request may not have the route | |
| // object yet (it is still being built), so use the router to look up | |
| // based on the path. | |
| $route_match = $this->stackedRouteMatch->getRouteMatchFromRequest($request); | |
| if ($route_match && !$route_object = $route_match->getRouteObject()) { | |
| try { | |
| // Process the path as an inbound path. This will remove any language | |
| // prefixes and other path components that inbound processing would | |
| // clear out, so we can attempt to load the route clearly. | |
| $path = $this->pathProcessorManager->processInbound(urldecode(rtrim($request->getPathInfo(), '/')), $request); | |
| $attributes = $this->router->match($path); | |
| } | |
| catch (ResourceNotFoundException $e) { | |
| return FALSE; | |
| } | |
| catch (AccessDeniedHttpException $e) { | |
| return FALSE; | |
| } | |
| $route_object = $attributes[RouteObjectInterface::ROUTE_OBJECT]; | |
| } | |
| $result = $this->adminContext->isAdminRoute($route_object); | |
| } | |
| return $result; | |
| } | |
| } |