vendor/sulu/sulu/src/Sulu/Component/Webspace/Manager/WebspaceManager.php line 155

  1. <?php
  3. /*
  4.  * This file is part of Sulu.
  5.  *
  6.  * (c) Sulu GmbH
  7.  *
  8.  * This source file is subject to the MIT license that is bundled
  9.  * with this source code in the file LICENSE.
  10.  */
  12. namespace Sulu\Component\Webspace\Manager;
  14. use Sulu\Component\Content\Metadata\Factory\StructureMetadataFactoryInterface;
  15. use Sulu\Component\Content\Metadata\StructureMetadata;
  16. use Sulu\Component\Localization\Localization;
  17. use Sulu\Component\Util\WildcardUrlUtil;
  18. use Sulu\Component\Webspace\Analyzer\Attributes\RequestAttributes;
  19. use Sulu\Component\Webspace\Analyzer\RequestAnalyzerInterface;
  20. use Sulu\Component\Webspace\Manager\Dumper\PhpWebspaceCollectionDumper;
  21. use Sulu\Component\Webspace\Portal;
  22. use Sulu\Component\Webspace\PortalInformation;
  23. use Sulu\Component\Webspace\Url\ReplacerInterface;
  24. use Sulu\Component\Webspace\Webspace;
  25. use Symfony\Component\Config\ConfigCache;
  26. use Symfony\Component\Config\Loader\LoaderInterface;
  27. use Symfony\Component\HttpFoundation\RequestStack;
  29. /**
  30.  * This class is responsible for loading, reading and caching the portal configuration files.
  31.  */
  32. class WebspaceManager implements WebspaceManagerInterface
  33. {
  34.     /**
  35.      * @var WebspaceCollection
  36.      */
  37.     private $webspaceCollection;
  39.     /**
  40.      * @var LoaderInterface
  41.      */
  42.     private $loader;
  44.     /**
  45.      * @var ReplacerInterface
  46.      */
  47.     private $urlReplacer;
  49.     /**
  50.      * @var RequestStack
  51.      */
  52.     private $requestStack;
  54.     /**
  55.      * @var array
  56.      */
  57.     private $options;
  59.     /**
  60.      * @var string
  61.      */
  62.     private $environment;
  64.     /**
  65.      * @var string
  66.      */
  67.     private $defaultHost;
  69.     /**
  70.      * @var string
  71.      */
  72.     private $defaultScheme;
  74.     /**
  75.      * @var StructureMetadataFactoryInterface
  76.      */
  77.     private $structureMetadataFactory;
  79.     /**
  80.      * @var mixed[]
  81.      */
  82.     private $portalUrlCache = [];
  84.     public function __construct(
  85.         LoaderInterface $loader,
  86.         ReplacerInterface $urlReplacer,
  87.         RequestStack $requestStack,
  88.         array $options,
  89.         string $environment,
  90.         string $defaultHost,
  91.         string $defaultScheme,
  92.         StructureMetadataFactoryInterface $structureMetadataFactory
  93.     ) {
  94.         $this->loader = $loader;
  95.         $this->urlReplacer = $urlReplacer;
  96.         $this->requestStack = $requestStack;
  97.         $this->setOptions($options);
  98.         $this->environment = $environment;
  99.         $this->defaultHost = $defaultHost;
  100.         $this->defaultScheme = $defaultScheme;
  101.         $this->structureMetadataFactory = $structureMetadataFactory;
  102.     }
  104.     public function findWebspaceByKey(?string $key): ?Webspace
  105.     {
  106.         if (!$key) {
  107.             return null;
  108.         }
  110.         return $this->getWebspaceCollection()->getWebspace($key);
  111.     }
  113.     public function findPortalByKey(?string $key): ?Portal
  114.     {
  115.         if (!$key) {
  116.             return null;
  117.         }
  119.         return $this->getWebspaceCollection()->getPortal($key);
  120.     }
  122.     public function findPortalInformationByUrl(string $url, ?string $environment = null): ?PortalInformation
  123.     {
  124.         if (null === $environment) {
  125.             $environment = $this->environment;
  126.         }
  128.         $portalInformations = $this->getWebspaceCollection()->getPortalInformations($environment);
  129.         foreach ($portalInformations as $portalInformation) {
  130.             if ($this->matchUrl($url, $portalInformation->getUrl())) {
  131.                 return $portalInformation;
  132.             }
  133.         }
  135.         return null;
  136.     }
  138.     public function findPortalInformationsByHostIncludingSubdomains(string $host, ?string $environment = null): array
  139.     {
  140.         if (null === $environment) {
  141.             $environment = $this->environment;
  142.         }
  144.         return \array_filter(
  145.             $this->getWebspaceCollection()->getPortalInformations($environment),
  146.             function(PortalInformation $portalInformation) use ($host) {
  147.                 $portalHost = $portalInformation->getHost();
  149.                 // add a slash to avoid problems with "example.co" and "example.com"
  150.                 return false !== \strpos($portalHost . '/', $host . '/');
  151.             }
  152.         );
  153.     }
  155.     public function findPortalInformationsByUrl(string $url, ?string $environment = null): array
  156.     {
  157.         if (null === $environment) {
  158.             $environment = $this->environment;
  159.         }
  161.         return \array_filter(
  162.             $this->getWebspaceCollection()->getPortalInformations($environment),
  163.             function(PortalInformation $portalInformation) use ($url) {
  164.                 return $this->matchUrl($url, $portalInformation->getUrl());
  165.             }
  166.         );
  167.     }
  169.     public function findPortalInformationsByWebspaceKeyAndLocale(
  170.         string $webspaceKey,
  171.         string $locale,
  172.         ?string $environment = null
  173.     ): array {
  174.         if (null === $environment) {
  175.             $environment = $this->environment;
  176.         }
  178.         return \array_filter(
  179.             $this->getWebspaceCollection()->getPortalInformations($environment),
  180.             function(PortalInformation $portalInformation) use ($webspaceKey, $locale) {
  181.                 return $portalInformation->getWebspace()->getKey() === $webspaceKey
  182.                     && $portalInformation->getLocale() === $locale;
  183.             }
  184.         );
  185.     }
  187.     public function findPortalInformationsByPortalKeyAndLocale(
  188.         string $portalKey,
  189.         string $locale,
  190.         ?string $environment = null
  191.     ): array {
  192.         if (null === $environment) {
  193.             $environment = $this->environment;
  194.         }
  196.         return \array_filter(
  197.             $this->getWebspaceCollection()->getPortalInformations($environment),
  198.             function(PortalInformation $portalInformation) use ($portalKey, $locale) {
  199.                 return $portalInformation->getPortal()
  200.                     && $portalInformation->getPortal()->getKey() === $portalKey
  201.                     && $portalInformation->getLocale() === $locale;
  202.             }
  203.         );
  204.     }
  206.     public function findUrlsByResourceLocator(
  207.         string $resourceLocator,
  208.         ?string $environment,
  209.         string $languageCode,
  210.         ?string $webspaceKey = null,
  211.         ?string $domain = null,
  212.         ?string $scheme = null
  213.     ): array {
  214.         if (null === $environment) {
  215.             $environment = $this->environment;
  216.         }
  217.         if (null === $webspaceKey) {
  218.             $currentWebspace = $this->getCurrentWebspace();
  219.             $webspaceKey = $currentWebspace ? $currentWebspace->getKey() : $webspaceKey;
  220.         }
  222.         $urls = [];
  223.         $portals = $this->getWebspaceCollection()->getPortalInformations(
  224.             $environment,
  225.             [RequestAnalyzerInterface::MATCH_TYPE_FULL]
  226.         );
  227.         foreach ($portals as $portalInformation) {
  228.             $sameLocalization = $portalInformation->getLocalization()->getLocale() === $languageCode;
  229.             $sameWebspace = null === $webspaceKey || $portalInformation->getWebspace()->getKey() === $webspaceKey;
  230.             $url = $this->createResourceLocatorUrl($portalInformation->getUrl(), $resourceLocator, $scheme);
  231.             if ($sameLocalization && $sameWebspace && $this->isFromDomain($url, $domain)) {
  232.                 $urls[] = $url;
  233.             }
  234.         }
  236.         return $urls;
  237.     }
  239.     public function findUrlByResourceLocator(
  240.         ?string $resourceLocator,
  241.         ?string $environment,
  242.         string $languageCode,
  243.         ?string $webspaceKey = null,
  244.         ?string $domain = null,
  245.         ?string $scheme = null
  246.     ): ?string {
  247.         if (null === $environment) {
  248.             $environment = $this->environment;
  249.         }
  250.         if (null === $webspaceKey) {
  251.             $currentWebspace = $this->getCurrentWebspace();
  252.             $webspaceKey = $currentWebspace ? $currentWebspace->getKey() : $webspaceKey;
  253.         }
  255.         if (isset($this->portalUrlCache[$webspaceKey][$domain][$environment][$languageCode])) {
  256.             $portalUrl = $this->portalUrlCache[$webspaceKey][$domain][$environment][$languageCode];
  258.             if (!$portalUrl) {
  259.                 return null;
  260.             }
  262.             return $this->createResourceLocatorUrl($portalUrl, $resourceLocator, $scheme);
  263.         }
  265.         $sameDomainUrl = null;
  266.         $fullMatchedUrl = null;
  267.         $partialMatchedUrl = null;
  269.         $portals = $this->getWebspaceCollection()->getPortalInformations(
  270.             $environment
  271.         );
  273.         foreach ($portals as $portalInformation) {
  274.             if (!\in_array($portalInformation->getType(), [
  275.                 RequestAnalyzerInterface::MATCH_TYPE_FULL,
  276.                 RequestAnalyzerInterface::MATCH_TYPE_PARTIAL,
  277.                 RequestAnalyzerInterface::MATCH_TYPE_REDIRECT,
  278.             ])) {
  279.                 continue;
  280.             }
  282.             $sameWebspace = null === $webspaceKey || $portalInformation->getWebspace()->getKey() === $webspaceKey;
  284.             if (!$sameWebspace) {
  285.                 continue;
  286.             }
  288.             $portalLocalization = $portalInformation->getLocalization();
  290.             $sameLocalization = (
  291.                 null === $portalLocalization
  292.                 || $portalLocalization->getLocale() === $languageCode
  293.             );
  295.             if (!$sameLocalization) {
  296.                 continue;
  297.             }
  299.             $portalUrl = $portalInformation->getUrl();
  300.             if (RequestAnalyzerInterface::MATCH_TYPE_FULL === $portalInformation->getType()) {
  301.                 if ($this->isFromDomain('http://' . $portalUrl, $domain)) {
  302.                     if ($portalInformation->isMain()) {
  303.                         $sameDomainUrl = $portalUrl;
  304.                     } elseif (!$sameDomainUrl) {
  305.                         $sameDomainUrl = $portalUrl;
  306.                     }
  307.                 } elseif ($sameDomainUrl) {
  308.                     continue;
  309.                 } elseif ($portalInformation->isMain()) {
  310.                     $fullMatchedUrl = $portalUrl;
  311.                 } elseif (!$fullMatchedUrl) {
  312.                     $fullMatchedUrl = $portalUrl;
  313.                 }
  314.             } elseif ($fullMatchedUrl || $sameDomainUrl) {
  315.                 continue;
  316.             } elseif (!$partialMatchedUrl) {
  317.                 $partialMatchedUrl = $portalUrl;
  318.             }
  319.         }
  321.         if ($sameDomainUrl) {
  322.             $portalUrl = $sameDomainUrl;
  323.         } elseif ($fullMatchedUrl) {
  324.             $portalUrl = $fullMatchedUrl;
  325.         } elseif ($partialMatchedUrl) {
  326.             $portalUrl = $partialMatchedUrl;
  327.         } else {
  328.             $portalUrl = null;
  329.         }
  331.         $this->portalUrlCache[$webspaceKey][$domain][$environment][$languageCode] = $portalUrl;
  333.         if (!$portalUrl) {
  334.             return null;
  335.         }
  337.         return $this->createResourceLocatorUrl($portalUrl, $resourceLocator, $scheme);
  338.     }
  340.     public function getPortals(): array
  341.     {
  342.         return $this->getWebspaceCollection()->getPortals();
  343.     }
  345.     public function getUrls(?string $environment = null): array
  346.     {
  347.         if (null === $environment) {
  348.             $environment = $this->environment;
  349.         }
  351.         $urls = [];
  353.         foreach ($this->getWebspaceCollection()->getPortalInformations($environment) as $portalInformation) {
  354.             $urls[] = $portalInformation->getUrl();
  355.         }
  357.         return $urls;
  358.     }
  360.     public function getPortalInformations(?string $environment = null): array
  361.     {
  362.         if (null === $environment) {
  363.             $environment = $this->environment;
  364.         }
  366.         return $this->getWebspaceCollection()->getPortalInformations($environment);
  367.     }
  369.     public function getPortalInformationsByWebspaceKey(?string $environment, string $webspaceKey): array
  370.     {
  371.         if (null === $environment) {
  372.             $environment = $this->environment;
  373.         }
  375.         return \array_filter(
  376.             $this->getWebspaceCollection()->getPortalInformations($environment),
  377.             function(PortalInformation $portal) use ($webspaceKey) {
  378.                 return $portal->getWebspaceKey() === $webspaceKey;
  379.             }
  380.         );
  381.     }
  383.     public function getAllLocalizations(): array
  384.     {
  385.         $localizations = [];
  387.         /** @var Webspace $webspace */
  388.         foreach ($this->getWebspaceCollection() as $webspace) {
  389.             foreach ($webspace->getAllLocalizations() as $localization) {
  390.                 $localizations[$localization->getLocale()] = $localization;
  391.             }
  392.         }
  394.         return $localizations;
  395.     }
  397.     public function getAllLocales(): array
  398.     {
  399.         return \array_values(
  400.             \array_map(
  401.                 function(Localization $localization) {
  402.                     return $localization->getLocale();
  403.                 },
  404.                 $this->getAllLocalizations()
  405.             )
  406.         );
  407.     }
  409.     public function getAllLocalesByWebspaces(): array
  410.     {
  411.         $webspaces = [];
  412.         foreach ($this->getWebspaceCollection() as $webspace) {
  413.             /** @var Webspace $webspace */
  414.             $locales = [];
  415.             $defaultLocale = $webspace->getDefaultLocalization();
  416.             $locales[$defaultLocale->getLocale()] = $defaultLocale;
  417.             foreach ($webspace->getAllLocalizations() as $localization) {
  418.                 if (!\array_key_exists($localization->getLocale(), $locales)) {
  419.                     $locales[$localization->getLocale()] = $localization;
  420.                 }
  421.             }
  422.             $webspaces[$webspace->getKey()] = $locales;
  423.         }
  425.         return $webspaces;
  426.     }
  428.     public function getWebspaceCollection(): WebspaceCollection
  429.     {
  430.         if (null === $this->webspaceCollection) {
  431.             /** @var class-string<WebspaceCollection> $class */
  432.             $class = $this->options['cache_class'];
  433.             $cache = new ConfigCache(
  434.                 $this->options['cache_dir'] . '/' . $class . '.php',
  435.                 $this->options['debug']
  436.             );
  438.             if (!$cache->isFresh()) {
  439.                 $availableTemplates = \array_map(
  440.                     function(StructureMetadata $structure) {
  441.                         return $structure->getName();
  442.                     },
  443.                     $this->structureMetadataFactory->getStructures('page')
  444.                 );
  445.                 $webspaceCollectionBuilder = new WebspaceCollectionBuilder(
  446.                     $this->loader,
  447.                     $this->urlReplacer,
  448.                     $this->options['config_dir'],
  449.                     $availableTemplates
  450.                 );
  451.                 $webspaceCollection = $webspaceCollectionBuilder->build();
  452.                 $dumper = new PhpWebspaceCollectionDumper($webspaceCollection);
  453.                 $cache->write(
  454.                     $dumper->dump(
  455.                         [
  456.                             'cache_class' => $class,
  457.                             'base_class' => $this->options['base_class'],
  458.                         ]
  459.                     ),
  460.                     $webspaceCollection->getResources()
  461.                 );
  462.             }
  464.             require_once $cache->getPath();
  466.             $this->webspaceCollection = new $class();
  468.             $currentRequest = $this->requestStack->getCurrentRequest();
  470.             $host = $currentRequest ? $currentRequest->getHost() : $this->defaultHost;
  471.             foreach ($this->getPortalInformations() as $portalInformation) {
  472.                 $portalInformation->setUrl($this->urlReplacer->replaceHost($portalInformation->getUrl(), $host));
  473.                 $portalInformation->setUrlExpression(
  474.                     $this->urlReplacer->replaceHost($portalInformation->getUrlExpression(), $host)
  475.                 );
  476.                 $portalInformation->setRedirect(
  477.                     $this->urlReplacer->replaceHost($portalInformation->getRedirect(), $host)
  478.                 );
  479.             }
  480.         }
  482.         return $this->webspaceCollection;
  483.     }
  485.     /**
  486.      * Sets the options for the manager.
  487.      *
  488.      * @param mixed[] $options
  489.      */
  490.     public function setOptions($options)
  491.     {
  492.         $this->options = [
  493.             'config_dir' => null,
  494.             'cache_dir' => null,
  495.             'debug' => false,
  496.             'cache_class' => 'WebspaceCollectionCache',
  497.             'base_class' => 'WebspaceCollection',
  498.         ];
  500.         // overwrite the default values with the given options
  501.         $this->options = \array_merge($this->options, $options);
  502.     }
  504.     /**
  505.      * Url is from domain.
  506.      *
  507.      * @param string $url
  508.      * @param string $domain
  509.      *
  510.      * @return bool
  511.      */
  512.     protected function isFromDomain($url, $domain)
  513.     {
  514.         if (!$domain) {
  515.             return true;
  516.         }
  518.         $parsedUrl = \parse_url($url);
  519.         // if domain or subdomain
  520.         if (
  521.             isset($parsedUrl['host'])
  522.             && (
  523.                 $parsedUrl['host'] == $domain
  524.                 || \fnmatch('*.' . $domain, $parsedUrl['host'])
  525.             )
  526.         ) {
  527.             return true;
  528.         }
  530.         return false;
  531.     }
  533.     /**
  534.      * Matches given url with portal-url.
  535.      *
  536.      * @param string $url
  537.      * @param string $portalUrl
  538.      *
  539.      * @return bool
  540.      */
  541.     protected function matchUrl($url, $portalUrl)
  542.     {
  543.         return WildcardUrlUtil::match($url, $portalUrl);
  544.     }
  546.     private function getCurrentWebspace(): ?Webspace
  547.     {
  548.         $currentRequest = $this->requestStack->getCurrentRequest();
  549.         if (!$currentRequest) {
  550.             return null;
  551.         }
  553.         $suluAttributes = $currentRequest->attributes->get('_sulu');
  554.         if (!$suluAttributes instanceof RequestAttributes) {
  555.             return null;
  556.         }
  558.         return $suluAttributes->getAttribute('webspace');
  559.     }
  561.     /**
  562.      * Return a valid resource locator url.
  563.      *
  564.      * @param string $portalUrl
  565.      * @param string $resourceLocator
  566.      * @param string|null $scheme
  567.      *
  568.      * @return string
  569.      */
  570.     private function createResourceLocatorUrl($portalUrl, $resourceLocator, $scheme = null)
  571.     {
  572.         $currentRequest = $this->requestStack->getCurrentRequest();
  574.         if (!$scheme) {
  575.             $scheme = $currentRequest ? $currentRequest->getScheme() : $this->defaultScheme;
  576.         }
  578.         if (false !== \strpos($portalUrl, '/')) {
  579.             // trim slash when resourceLocator is not domain root
  580.             $resourceLocator = \rtrim($resourceLocator, '/');
  581.         }
  583.         $url = \rtrim(\sprintf('%s://%s', $scheme, $portalUrl), '/') . $resourceLocator;
  585.         // add port if url points to host of current request and current request uses a custom port
  586.         if ($currentRequest) {
  587.             $host = $currentRequest->getHost();
  588.             $port = $currentRequest->getPort();
  590.             if ($url && $host && false !== \strpos($url, $host)) {
  591.                 if (!('http' == $scheme && 80 == $port) && !('https' == $scheme && 443 == $port)) {
  592.                     $url = \str_replace($host, $host . ':' . $port, $url);
  593.                 }
  594.             }
  595.         }
  597.         return $url;
  598.     }
  599. }