core/lib/Thelia/Core/Template/TheliaTemplateHelper.php line 163

  1. <?php
  3. /*
  4.  * This file is part of the Thelia package.
  5.  * http://www.thelia.net
  6.  *
  7.  * (c) OpenStudio <info@thelia.net>
  8.  *
  9.  * For the full copyright and license information, please view the LICENSE
  10.  * file that was distributed with this source code.
  11.  */
  13. namespace Thelia\Core\Template;
  15. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  16. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  17. use Thelia\Core\Event\Cache\CacheEvent;
  18. use Thelia\Core\Event\Config\ConfigUpdateEvent;
  19. use Thelia\Core\Event\TheliaEvents;
  20. use Thelia\Model\ConfigQuery;
  22. class TheliaTemplateHelper implements TemplateHelperInterface, EventSubscriberInterface
  23. {
  24.     protected $kernelCacheDir;
  26.     public function __construct($kernelCacheDir)
  27.     {
  28.         $this->kernelCacheDir = $kernelCacheDir;
  29.     }
  31.     /**
  32.      * @return TemplateDefinition
  33.      */
  34.     public function getActiveMailTemplate()
  35.     {
  36.         return new TemplateDefinition(
  37.             ConfigQuery::read('active-mail-template', 'default'),
  38.             TemplateDefinition::EMAIL
  39.         );
  40.     }
  42.     /**
  43.      * Check if a template definition is the current active template.
  44.      *
  45.      * @return bool true is the given template is the active template
  46.      */
  47.     public function isActive(TemplateDefinition $tplDefinition)
  48.     {
  49.         $tplVar = '';
  51.         switch ($tplDefinition->getType()) {
  52.             case TemplateDefinition::FRONT_OFFICE:
  53.                 $tplVar = 'active-front-template';
  54.                 break;
  55.             case TemplateDefinition::BACK_OFFICE:
  56.                 $tplVar = 'active-admin-template';
  57.                 break;
  58.             case TemplateDefinition::PDF:
  59.                 $tplVar = 'active-pdf-template';
  60.                 break;
  61.             case TemplateDefinition::EMAIL:
  62.                 $tplVar = 'active-mail-template';
  63.                 break;
  64.         }
  66.         return $tplDefinition->getName() == ConfigQuery::read($tplVar, 'default');
  67.     }
  69.     /**
  70.      * @return TemplateDefinition
  71.      */
  72.     public function getActivePdfTemplate()
  73.     {
  74.         return new TemplateDefinition(
  75.             ConfigQuery::read('active-pdf-template', 'default'),
  76.             TemplateDefinition::PDF
  77.         );
  78.     }
  80.     /**
  81.      * @return TemplateDefinition
  82.      */
  83.     public function getActiveAdminTemplate()
  84.     {
  85.         return new TemplateDefinition(
  86.             ConfigQuery::read('active-admin-template', 'default'),
  87.             TemplateDefinition::BACK_OFFICE
  88.         );
  89.     }
  91.     /**
  92.      * @return TemplateDefinition
  93.      */
  94.     public function getActiveFrontTemplate()
  95.     {
  96.         return new TemplateDefinition(
  97.             ConfigQuery::read('active-front-template', 'default'),
  98.             TemplateDefinition::FRONT_OFFICE
  99.         );
  100.     }
  102.     /**
  103.      * Returns an array which contains all standard template definitions.
  104.      */
  105.     public function getStandardTemplateDefinitions()
  106.     {
  107.         return [
  108.             $this->getActiveFrontTemplate(),
  109.             $this->getActiveAdminTemplate(),
  110.             $this->getActivePdfTemplate(),
  111.             $this->getActiveMailTemplate(),
  112.         ];
  113.     }
  115.     /**
  116.      * Return a list of existing templates for a given template type.
  117.      *
  118.      * @param int    $templateType the template type
  119.      * @param string $base         the template base (module or core, default to core)
  120.      *
  121.      * @return TemplateDefinition[] of \Thelia\Core\Template\TemplateDefinition
  122.      */
  123.     public function getList($templateType, $base = THELIA_TEMPLATE_DIR)
  124.     {
  125.         $list = $exclude = [];
  127.         $tplIterator = TemplateDefinition::getStandardTemplatesSubdirsIterator();
  129.         foreach ($tplIterator as $type => $subdir) {
  130.             if ($templateType == $type) {
  131.                 $baseDir = rtrim($base, DS).DS.$subdir;
  133.                 try {
  134.                     // Every subdir of the basedir is supposed to be a template.
  135.                     $di = new \DirectoryIterator($baseDir);
  137.                     /** @var \DirectoryIterator $file */
  138.                     foreach ($di as $file) {
  139.                         // Ignore 'dot' elements
  140.                         if ($file->isDot() || !$file->isDir()) {
  141.                             continue;
  142.                         }
  144.                         // Ignore reserved directory names
  145.                         if (\in_array($file->getFilename(), $exclude)) {
  146.                             continue;
  147.                         }
  149.                         $list[] = new TemplateDefinition($file->getFilename(), $templateType);
  150.                     }
  151.                 } catch (\UnexpectedValueException $ex) {
  152.                     // Ignore the exception and continue
  153.                 }
  154.             }
  155.         }
  157.         return $list;
  158.     }
  160.     /**
  161.      * Clear the cache if the front or admin template is changed in the back-office.
  162.      */
  163.     public function clearCache(ConfigUpdateEvent $event, string $eventName, EventDispatcherInterface $dispatcher): void
  164.     {
  165.         if (
  166.             (null === $config = ConfigQuery::create()->findPk($event->getConfigId()))
  167.             ||
  168.             ($config->getValue() === $event->getValue())
  169.             ||
  170.             ($config->getName() !== TemplateDefinition::BACK_OFFICE_CONFIG_NAME
  171.              &&
  172.              $config->getName() !== TemplateDefinition::FRONT_OFFICE_CONFIG_NAME)
  173.         ) {
  174.             return;
  175.         }
  177.         $cacheEvent = new CacheEvent($this->kernelCacheDir);
  178.         $dispatcher->dispatch($cacheEvent, TheliaEvents::CACHE_CLEAR);
  179.     }
  181.     /**
  182.      * {@inheritdoc}
  183.      */
  184.     public static function getSubscribedEvents()
  185.     {
  186.         return [
  187.             TheliaEvents::CONFIG_SETVALUE => ['clearCache', 130],
  188.         ];
  189.     }
  190. }