vendor/sonata-project/block-bundle/src/Block/BlockContextManager.php line 235

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. /*
  6.  * This file is part of the Sonata Project package.
  7.  *
  8.  * (c) Thomas Rabaix <thomas.rabaix@sonata-project.org>
  9.  *
  10.  * For the full copyright and license information, please view the LICENSE
  11.  * file that was distributed with this source code.
  12.  */
  14. namespace Sonata\BlockBundle\Block;
  16. use Doctrine\Common\Util\ClassUtils;
  17. use Psr\Log\LoggerInterface;
  18. use Sonata\BlockBundle\Model\BlockInterface;
  19. use Symfony\Component\OptionsResolver\Exception\ExceptionInterface;
  20. use Symfony\Component\OptionsResolver\OptionsResolver;
  21. use Symfony\Component\OptionsResolver\OptionsResolverInterface;
  23. /**
  24.  * @final since sonata-project/block-bundle 3.0
  25.  */
  26. class BlockContextManager implements BlockContextManagerInterface
  27. {
  28.     /**
  29.      * @var BlockLoaderInterface
  30.      */
  31.     protected $blockLoader;
  33.     /**
  34.      * @var BlockServiceManagerInterface
  35.      */
  36.     protected $blockService;
  38.     /**
  39.      * @var array
  40.      */
  41.     protected $settingsByType;
  43.     /**
  44.      * @var array
  45.      */
  46.     protected $settingsByClass;
  48.     /**
  49.      * @var array
  50.      */
  51.     protected $cacheBlocks;
  53.     /**
  54.      * @var LoggerInterface
  55.      */
  56.     protected $logger;
  58.     /**
  59.      * Used for deprecation check on {@link resolve} method.
  60.      * To be removed in 4.0 with BC system.
  61.      *
  62.      * @var array
  63.      */
  64.     private $reflectionCache;
  66.     public function __construct(BlockLoaderInterface $blockLoader, BlockServiceManagerInterface $blockService,
  67.         array $cacheBlocks = [], LoggerInterface $logger = null
  68.     ) {
  69.         $this->blockLoader = $blockLoader;
  70.         $this->blockService = $blockService;
  71.         $this->cacheBlocks = $cacheBlocks;
  72.         $this->logger = $logger;
  73.         $this->reflectionCache = [];
  74.     }
  76.     public function addSettingsByType($type, array $settings, $replace = false)
  77.     {
  78.         $typeSettings = isset($this->settingsByType[$type]) ? $this->settingsByType[$type] : [];
  79.         if ($replace) {
  80.             $this->settingsByType[$type] = array_merge($typeSettings, $settings);
  81.         } else {
  82.             $this->settingsByType[$type] = array_merge($settings, $typeSettings);
  83.         }
  84.     }
  86.     public function addSettingsByClass($class, array $settings, $replace = false)
  87.     {
  88.         $classSettings = isset($this->settingsByClass[$class]) ? $this->settingsByClass[$class] : [];
  89.         if ($replace) {
  90.             $this->settingsByClass[$class] = array_merge($classSettings, $settings);
  91.         } else {
  92.             $this->settingsByClass[$class] = array_merge($settings, $classSettings);
  93.         }
  94.     }
  96.     /**
  97.      * Check if a given block type exists.
  98.      *
  99.      * @param string $type Block type to check for
  100.      *
  101.      * @return bool
  102.      */
  103.     public function exists($type)
  104.     {
  105.         return $this->blockLoader->exists($type);
  106.     }
  108.     public function get($meta, array $settings = [])
  109.     {
  110.         if (!$meta instanceof BlockInterface) {
  111.             $block = $this->blockLoader->load($meta);
  113.             if (\is_array($meta) && isset($meta['settings'])) {
  114.                 // merge user settings
  115.                 $settings = array_merge($meta['settings'], $settings);
  116.             }
  117.         } else {
  118.             $block = $meta;
  119.         }
  121.         if (!$block instanceof BlockInterface) {
  122.             return false;
  123.         }
  125.         $originalSettings = $settings;
  127.         try {
  128.             $settings = $this->resolve($block, array_merge($block->getSettings(), $settings));
  129.         } catch (ExceptionInterface $e) {
  130.             if ($this->logger) {
  131.                 $this->logger->error(sprintf(
  132.                     '[cms::blockContext] block.id=%s - error while resolving options - %s',
  133.                     $block->getId(),
  134.                     $e->getMessage()
  135.                 ));
  136.             }
  138.             $settings = $this->resolve($block, $settings);
  139.         }
  141.         $blockContext = new BlockContext($block, $settings);
  143.         $this->setDefaultExtraCacheKeys($blockContext, $originalSettings);
  145.         return $blockContext;
  146.     }
  148.     /**
  149.      * NEXT_MAJOR: remove this method.
  150.      *
  151.      * @deprecated since sonata-project/block-bundle 2.3, to be renamed in 4.0.
  152.      *             Use the method configureSettings instead
  153.      */
  154.     protected function setDefaultSettings(OptionsResolverInterface $optionsResolver, BlockInterface $block)
  155.     {
  156.         if (__CLASS__ !== static::class) {
  157.             @trigger_error(
  158.                 'The '.__METHOD__.' is deprecated since version 2.3, to be renamed in 4.0.'
  159.                 .' Use '.__CLASS__.'::configureSettings instead.',
  160.                 E_USER_DEPRECATED
  161.             );
  162.         }
  163.         $this->configureSettings($optionsResolver, $block);
  164.     }
  166.     protected function configureSettings(OptionsResolver $optionsResolver, BlockInterface $block)
  167.     {
  168.         // defaults for all blocks
  169.         $optionsResolver->setDefaults([
  170.             'use_cache' => true,
  171.             'extra_cache_keys' => [],
  172.             'attr' => [],
  173.             'template' => false,
  174.             'ttl' => (int) $block->getTtl(),
  175.         ]);
  177.         $optionsResolver
  178.             ->addAllowedTypes('use_cache', 'bool')
  179.             ->addAllowedTypes('extra_cache_keys', 'array')
  180.             ->addAllowedTypes('attr', 'array')
  181.             ->addAllowedTypes('ttl', 'int')
  182.             ->addAllowedTypes('template', ['string', 'bool'])
  183.         ;
  185.         // add type and class settings for block
  186.         $class = ClassUtils::getClass($block);
  187.         $settingsByType = isset($this->settingsByType[$block->getType()]) ? $this->settingsByType[$block->getType()] : [];
  188.         $settingsByClass = isset($this->settingsByClass[$class]) ? $this->settingsByClass[$class] : [];
  189.         $optionsResolver->setDefaults(array_merge($settingsByType, $settingsByClass));
  190.     }
  192.     /**
  193.      * Adds context settings, to be able to rebuild a block context, to the
  194.      * extra_cache_keys.
  195.      */
  196.     protected function setDefaultExtraCacheKeys(BlockContextInterface $blockContext, array $settings)
  197.     {
  198.         if (!$blockContext->getSetting('use_cache') || $blockContext->getSetting('ttl') <= 0) {
  199.             return;
  200.         }
  202.         $block = $blockContext->getBlock();
  204.         // type by block class
  205.         $class = ClassUtils::getClass($block);
  206.         $cacheServiceId = isset($this->cacheBlocks['by_class'][$class]) ? $this->cacheBlocks['by_class'][$class] : false;
  208.         // type by block service
  209.         if (!$cacheServiceId) {
  210.             $cacheServiceId = isset($this->cacheBlocks['by_type'][$block->getType()]) ? $this->cacheBlocks['by_type'][$block->getType()] : false;
  211.         }
  213.         if (!$cacheServiceId) {
  214.             // no context cache needed
  215.             return;
  216.         }
  218.         // do not add cache settings to extra_cache_keys
  219.         unset($settings['use_cache'], $settings['extra_cache_keys'], $settings['ttl']);
  221.         $extraCacheKeys = $blockContext->getSetting('extra_cache_keys');
  223.         // add context settings to extra_cache_keys
  224.         if (!isset($extraCacheKeys[self::CACHE_KEY])) {
  225.             $extraCacheKeys[self::CACHE_KEY] = $settings;
  226.             $blockContext->setSetting('extra_cache_keys', $extraCacheKeys);
  227.         }
  228.     }
  230.     /**
  231.      * @param array $settings
  232.      *
  233.      * @return array
  234.      */
  235.     private function resolve(BlockInterface $block, $settings)
  236.     {
  237.         $optionsResolver = new \Sonata\BlockBundle\Util\OptionsResolver();
  239.         $this->configureSettings($optionsResolver, $block);
  241.         $service = $this->blockService->get($block);
  243.         // Caching method reflection
  244.         // NEXT_MAJOR: Remove everything here
  245.         $serviceClass = \get_class($service);
  246.         if (!isset($this->reflectionCache[$serviceClass])) {
  247.             $reflector = new \ReflectionMethod($service, 'setDefaultSettings');
  248.             $isOldOverwritten = \get_class($service) === $reflector->getDeclaringClass()->getName();
  250.             // Prevention for service classes implementing directly the interface and not extends the new base class
  251.             if (!method_exists($service, 'configureSettings')) {
  252.                 $isNewOverwritten = false;
  253.             } else {
  254.                 $reflector = new \ReflectionMethod($service, 'configureSettings');
  255.                 $isNewOverwritten = \get_class($service) === $reflector->getDeclaringClass()->getName();
  256.             }
  258.             $this->reflectionCache[$serviceClass] = [
  259.                 'isOldOverwritten' => $isOldOverwritten,
  260.                 'isNewOverwritten' => $isNewOverwritten,
  261.             ];
  262.         }
  264.         // NEXT_MAJOR: Keep Only else case
  265.         if ($this->reflectionCache[$serviceClass]['isOldOverwritten'] && !$this->reflectionCache[$serviceClass]['isNewOverwritten']) {
  266.             @trigger_error(
  267.                 'The Sonata\BlockBundle\Block\BlockServiceInterface::setDefaultSettings() method is deprecated'
  268.                 .' since version 2.3 and will be removed in 4.0. Use configureSettings() instead.'
  269.                 .' This method will be added to the BlockServiceInterface with SonataBlockBundle 4.0.',
  270.                 E_USER_DEPRECATED
  271.             );
  272.             $service->setDefaultSettings($optionsResolver);
  273.         } else {
  274.             $service->configureSettings($optionsResolver);
  275.         }
  277.         return $optionsResolver->resolve($settings);
  278.     }
  279. }