vendor/ezsystems/ezcommerce-shop/src/Silversolutions/Bundle/EshopBundle/Services/ConfigResolver.php line 21

Open in your IDE?
  1. <?php
  2. /**
  3.  * @copyright Copyright (C) Ibexa AS. All rights reserved.
  4.  * @license For full copyright and license information view LICENSE file distributed with this source code.
  5.  */
  6. namespace Silversolutions\Bundle\EshopBundle\Services;
  7. use eZ\Publish\Core\MVC\Symfony\SiteAccess;
  8. use Psr\Log\LoggerInterface;
  9. use Stash\Interfaces\PoolInterface;
  10. use eZ\Publish\Core\MVC\Symfony\Configuration\VersatileScopeInterface;
  11. use eZ\Publish\Core\MVC\Symfony\SiteAccess\SiteAccessAware;
  12. use eZ\Publish\Core\MVC\Exception\ParameterNotFoundException;
  13. use Symfony\Component\DependencyInjection\ContainerAwareInterface;
  14. use Symfony\Component\DependencyInjection\ContainerAwareTrait;
  15. /**
  16.  * This implementation of config resolver uses the stash cache to access the parameters.
  17.  */
  18. class ConfigResolver implements VersatileScopeInterfaceSiteAccessAwareContainerAwareInterface
  19. {
  20.     use ContainerAwareTrait;
  21.     const SCOPE_GLOBAL 'global';
  22.     const SCOPE_DEFAULT 'default';
  23.     const CONFIGURATION_CACHE_IDENTIFIER 'siso_config';
  24.     const CONFIGURATION_CACHE_EXIST 'configuration_cache_exist';
  25.     /**
  26.      * @var PoolInterface
  27.      */
  28.     protected $cache;
  29.     /**
  30.      * @var \eZ\Publish\API\Repository\SettingService
  31.      */
  32.     protected $settingService;
  33.     /**
  34.      * @var \Psr\Log\LoggerInterface
  35.      */
  36.     protected $logger;
  37.     /**
  38.      * @var \eZ\Publish\Core\MVC\Symfony\SiteAccess|null
  39.      */
  40.     protected $siteAccess;
  41.     /**
  42.      * @var array Siteaccess groups, indexed by siteaccess name
  43.      */
  44.     protected $groupsBySiteAccess;
  45.     /**
  46.      * @var string
  47.      */
  48.     protected $defaultNamespace;
  49.     /**
  50.      * @var string
  51.      */
  52.     protected $defaultScope;
  53.     /**
  54.      * @var array
  55.      */
  56.     protected $data;
  57.     /**
  58.      * @var bool
  59.      */
  60.     protected $warmupPhase false;
  61.     /** @var \Silversolutions\Bundle\EshopBundle\Services\ConfigurationService */
  62.     private $configurationService;
  63.     /**
  64.      * @param array $groupsBySiteAccess SiteAccess groups, indexed by siteaccess.
  65.      * @param string $defaultNamespace The default namespace
  66.      */
  67.     public function __construct(
  68.         PoolInterface $pool,
  69.         ConfigurationService $configurationService,
  70.         LoggerInterface $logger,
  71.         SiteAccess $siteAccess,
  72.         array $groupsBySiteAccess,
  73.         $defaultNamespace
  74.     ) {
  75.         $this->cache $pool;
  76.         $this->configurationService $configurationService;
  77.         $this->logger $logger;
  78.         $this->siteAccess $siteAccess;
  79.         $this->groupsBySiteAccess $groupsBySiteAccess;
  80.         $this->defaultNamespace $defaultNamespace;
  81.         $this->defaultScope $siteAccess->name;
  82.     }
  83.     /**
  84.      * Returns value for $paramName, in $namespace.
  85.      *
  86.      * @param string $paramName The parameter name, without $prefix and the current scope (i.e. siteaccess name).
  87.      * @param string $namespace Namespace for the parameter name. If null, the default namespace should be used.
  88.      * @param string $scope The scope you need $paramName value for.
  89.      *
  90.      * @return mixed
  91.      */
  92.     public function getParameter($paramNamestring $namespace nullstring $scope null)
  93.     {
  94.         if ($this->isSiteAccessUninitialized()) {
  95.             throw new ParameterNotFoundException($paramName$namespace);
  96.         }
  97.         if ($this->warmupPhase) {
  98.             throw new ParameterNotFoundException($paramName$namespace);
  99.         }
  100.         $this->setData();
  101.         //first try with given scope, if scope is not given current scope is used
  102.         $stashParameter $this->getConfigurationCache(
  103.             $this->getConfigurationKey($paramName$namespace$scope)
  104.         );
  105.         //then fallback to default scope
  106.         if ($stashParameter === null) {
  107.             $stashParameter $this->getConfigurationCache(
  108.                 $this->getConfigurationKey($paramName$namespaceself::SCOPE_DEFAULT)
  109.             );
  110.         }
  111.         if ($stashParameter !== null) {
  112.             return $stashParameter;
  113.         }
  114.         // Finally throw a ParameterNotFoundException since the chain resolver couldn't find any valid resolver
  115.         // for demanded parameter
  116.         throw new ParameterNotFoundException($paramName$namespace);
  117.     }
  118.     /**
  119.      * Checks if $paramName exists in $namespace.
  120.      *
  121.      * @param string $paramName
  122.      * @param string $namespace If null, the default namespace should be used.
  123.      * @param string $scope The scope you need $paramName value for.
  124.      *
  125.      * @return bool
  126.      */
  127.     public function hasParameter($paramNamestring $namespace nullstring $scope null): bool
  128.     {
  129.         if ($this->isSiteAccessUninitialized()) {
  130.             return false;
  131.         }
  132.         if ($this->warmupPhase) {
  133.             return false;
  134.         }
  135.         $this->setData();
  136.         $stashParameter $this->getConfigurationCache(
  137.             $this->getConfigurationKey($paramName$namespace$scope)
  138.         );
  139.         if ($stashParameter === null) {
  140.             $stashParameter $this->getConfigurationCache(
  141.                 $this->getConfigurationKey($paramName$namespaceself::SCOPE_DEFAULT)
  142.             );
  143.         }
  144.         return $stashParameter !== null;
  145.     }
  146.     /**
  147.      * Gets configuration from cache using stash.
  148.      *
  149.      * @param $configurationKey
  150.      *
  151.      * @return string|null
  152.      */
  153.     public function getConfigurationCache($configurationKey)
  154.     {
  155.         if (isset($this->data[$configurationKey])) {
  156.             return $this->data[$configurationKey];
  157.         }
  158.         return null;
  159.     }
  160.     /**
  161.      * Sets cache for configuration.
  162.      *
  163.      * @param $configurationList
  164.      */
  165.     public function setConfigurationCache($configurationList)
  166.     {
  167.         try {
  168.             if ($this->data == null) {
  169.                 $this->data = [];
  170.             }
  171.             $this->data array_merge($this->data$configurationList);
  172.             $cacheKey $this->getCacheKey();
  173.             $this->cache->getItem($cacheKey)->set($this->data)->save();
  174.         } catch (\Exception $e) {
  175.             $this->logger->error('Could not set configuration cache');
  176.         }
  177.     }
  178.     /**
  179.      * Changes the default namespace to look parameter into.
  180.      *
  181.      * @param string $defaultNamespace
  182.      */
  183.     public function setDefaultNamespace(string $defaultNamespace): void
  184.     {
  185.         $this->defaultNamespace $defaultNamespace;
  186.     }
  187.     /**
  188.      * @return string
  189.      */
  190.     public function getDefaultNamespace(): string
  191.     {
  192.         return $this->defaultNamespace;
  193.     }
  194.     public function getDefaultScope(): string
  195.     {
  196.         return $this->defaultScope;
  197.     }
  198.     public function setDefaultScope(string $scope): void
  199.     {
  200.         $this->defaultScope $scope;
  201.     }
  202.     /**
  203.      * Calculates cache key.
  204.      *
  205.      * @return string
  206.      */
  207.     protected function getCacheKey()
  208.     {
  209.         return self::CONFIGURATION_CACHE_IDENTIFIER;
  210.     }
  211.     /**
  212.      * Calculates key for configuration.
  213.      *
  214.      * @param $paramName
  215.      * @param $scope
  216.      * @param $namespace
  217.      *
  218.      * @return string
  219.      */
  220.     protected function getConfigurationKey($paramName$namespace$scope)
  221.     {
  222.         return $namespace '.' . ($scope ?: $this->defaultScope) . '.' $paramName;
  223.     }
  224.     /**
  225.      * set all parameters from stash cache into data variable.
  226.      */
  227.     protected function setData()
  228.     {
  229.         if ($this->data == null) {
  230.             try {
  231.                 $cacheKey $this->getCacheKey();
  232.                 $cachedItem $this->cache->getItem($cacheKey);
  233.                 if (!$cachedItem->isMiss()) {
  234.                     $cachedData $cachedItem->get();
  235.                     if (is_array($cachedData)) {
  236.                         $this->data $cachedData;
  237.                     }
  238.                 } else {
  239.                     $this->data $this->setConfiguration();
  240.                 }
  241.             } catch (\Exception $e) {
  242.                 $this->logger->error($e->getMessage());
  243.             }
  244.         }
  245.     }
  246.     /**
  247.      * sets the configuration in cache from file system (ezpublish/Resources/).
  248.      *
  249.      * @return array
  250.      */
  251.     protected function setConfiguration()
  252.     {
  253.         $this->warmupPhase true;
  254.         $configuration[self::CONFIGURATION_CACHE_EXIST] = true;
  255.         try {
  256.             $configurationList $this->configurationService->getConfigurationContentFromEz();
  257.             if (is_array($configurationList)) {
  258.                 if (isset($configurationList['parameters'])) {
  259.                     $configurationValidList $configurationList['parameters'];
  260.                 } else {
  261.                     $configurationValidList $configurationList;
  262.                 }
  263.                 foreach ($configurationValidList as $key => $value) {
  264.                     $configuration[$key] = $value;
  265.                 }
  266.             }
  267.         } catch (\Exception $e) {
  268.             $this->logger->error($e->getMessage());
  269.         }
  270.         $this->setConfigurationCache($configuration);
  271.         $this->warmupPhase false;
  272.         return $configuration;
  273.     }
  274.     public function setSiteAccess(SiteAccess $siteAccess null)
  275.     {
  276.         $this->siteAccess $siteAccess;
  277.         if (null !== $siteAccess) {
  278.             $this->defaultScope $siteAccess->name;
  279.         }
  280.     }
  281.     private function isSiteAccessUninitialized(): bool
  282.     {
  283.         return $this->siteAccess === null || $this->siteAccess->matchingType === 'uninitialized';
  284.     }
  285. }