core/lib/Thelia/Core/Thelia.php line 426

  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;
  15. /*
  16.  * Root class of Thelia
  17.  *
  18.  * It extends Symfony\Component\HttpKernel\Kernel for changing some features
  19.  *
  20.  *
  21.  * @author Manuel Raynaud <manu@raynaud.io>
  22.  */
  24. use Composer\Autoload\ClassLoader;
  25. use Propel\Runtime\Connection\ConnectionInterface;
  26. use Propel\Runtime\DataFetcher\PDODataFetcher;
  27. use Propel\Runtime\Propel;
  28. use Symfony\Bundle\FrameworkBundle\Kernel\MicroKernelTrait;
  29. use Symfony\Component\Config\FileLocator;
  30. use Symfony\Component\DependencyInjection\ContainerAwareInterface;
  31. use Symfony\Component\DependencyInjection\ContainerBuilder;
  32. use Symfony\Component\DependencyInjection\ContainerInterface;
  33. use Symfony\Component\DependencyInjection\Definition;
  34. use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
  35. use Symfony\Component\DependencyInjection\Loader\PhpFileLoader;
  36. use Symfony\Component\DependencyInjection\Reference;
  37. use Symfony\Component\ErrorHandler\Debug;
  38. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  39. use Symfony\Component\Filesystem\Filesystem;
  40. use Symfony\Component\Finder\Finder;
  41. use Symfony\Component\Form\FormExtensionInterface;
  42. use Symfony\Component\HttpFoundation\Request;
  43. use Symfony\Component\HttpKernel\HttpKernelInterface;
  44. use Symfony\Component\HttpKernel\Kernel;
  45. use Symfony\Component\Routing\Loader\Configurator\RoutingConfigurator;
  46. use Symfony\Component\VarExporter\VarExporter;
  47. use Symfony\Contracts\EventDispatcher\Event;
  48. use Thelia\Condition\Implementation\ConditionInterface;
  49. use Thelia\Controller\ControllerInterface;
  50. use Thelia\Core\Archiver\ArchiverInterface;
  51. use Thelia\Core\DependencyInjection\Loader\XmlFileLoader;
  52. use Thelia\Core\DependencyInjection\TheliaContainer;
  53. use Thelia\Core\Event\TheliaEvents;
  54. use Thelia\Core\Hook\BaseHookInterface;
  55. use Thelia\Core\Propel\Schema\SchemaLocator;
  56. use Thelia\Core\Serializer\SerializerInterface;
  57. use Thelia\Core\Template\Element\BaseLoopInterface;
  58. use Thelia\Core\Template\TemplateDefinition;
  59. use Thelia\Core\Template\TemplateHelperInterface;
  60. use Thelia\Core\Translation\Translator;
  61. use Thelia\Coupon\Type\CouponInterface;
  62. use Thelia\Form\FormInterface;
  63. use Thelia\Log\Tlog;
  64. use Thelia\Model\ConfigQuery;
  65. use Thelia\Model\Module;
  66. use Thelia\Model\ModuleQuery;
  67. use Thelia\Module\ModuleManagement;
  68. use TheliaSmarty\Template\SmartyParser;
  70. class Thelia extends Kernel
  71. {
  72.     use MicroKernelTrait;
  74.     public const THELIA_VERSION = '2.5.2';
  76.     /** @var SchemaLocator */
  77.     protected $propelSchemaLocator;
  79.     /** @var PropelInitService */
  80.     protected $propelInitService;
  82.     protected $propelConnectionAvailable;
  84.     protected $theliaDatabaseConnection;
  86.     protected $cacheRefresh;
  88.     public function __construct($environment, $debug)
  89.     {
  90.         $loader = new ClassLoader();
  92.         $loader->addPsr4('', THELIA_ROOT."var/cache/{$environment}/propel/model");
  94.         $loader->addPsr4('TheliaMain\\', THELIA_ROOT."var/cache/{$environment}/propel/database/TheliaMain");
  95.         $loader->register();
  97.         parent::__construct($environment, $debug);
  99.         if ($debug) {
  100.             Debug::enable();
  101.         }
  102.     }
  104.     /** Get the front and back templates "components" directory path.
  105.      *
  106.      */
  107.     public static function getTemplateComponentsDirectories(): array
  108.     {
  109.         return [
  110.             'backOffice\\' => THELIA_TEMPLATE_DIR
  111.                 .TemplateDefinition::BACK_OFFICE_SUBDIR.DS
  112.                 .ConfigQuery::read(TemplateDefinition::BACK_OFFICE_CONFIG_NAME, 'default').DS
  113.                 .'components',
  114.             'frontOffice\\' => THELIA_TEMPLATE_DIR
  115.                 .TemplateDefinition::FRONT_OFFICE_SUBDIR.DS
  116.                 .ConfigQuery::read(TemplateDefinition::BACK_OFFICE_CONFIG_NAME, 'default').DS
  117.                 .'components',
  118.         ];
  119.     }
  121.     /**
  122.      * Configures the container.
  123.      *
  124.      * You can register extensions:
  125.      *
  126.      *     $c->extension('framework', [
  127.      *         'secret' => '%secret%'
  128.      *     ]);
  129.      *
  130.      * Or services:
  131.      *
  132.      *     $c->services()->set('halloween', 'FooBundle\HalloweenProvider');
  133.      *
  134.      * Or parameters:
  135.      *
  136.      *     $c->parameters()->set('halloween', 'lot of fun');
  137.      */
  138.     protected function configureContainer(ContainerConfigurator $container): void
  139.     {
  140.         $container->parameters()->set('thelia_front_template', ConfigQuery::read(TemplateDefinition::FRONT_OFFICE_CONFIG_NAME, 'default'));
  141.         $container->parameters()->set('thelia_admin_template', ConfigQuery::read(TemplateDefinition::BACK_OFFICE_CONFIG_NAME, 'default'));
  143.         $container->import(__DIR__.'/../Config/Resources/*.yaml');
  144.         $container->import(__DIR__.'/../Config/Resources/{packages}/*.yaml');
  145.         $container->import(__DIR__.'/../Config/Resources/{packages}/'.$this->environment.'/*.yaml');
  146.     }
  148.     protected function configureRoutes(RoutingConfigurator $routes): void
  149.     {
  150.     }
  152.     public static function isInstalled()
  153.     {
  154.         return file_exists(THELIA_CONF_DIR.'database.yml') || (!empty($_SERVER['DB_HOST']));
  155.     }
  157.     protected function checkMySQLConfigurations(ConnectionInterface $con): void
  158.     {
  159.         if (!file_exists($this->getCacheDir().DS.'check_mysql_configurations.php')) {
  160.             $sessionSqlMode = [];
  161.             $canUpdate = false;
  162.             $logs = [];
  163.             /** @var PDODataFetcher $result */
  164.             $result = $con->query('SELECT VERSION() as version, @@SESSION.sql_mode as session_sql_mode');
  166.             if ($result && $data = $result->fetch(\PDO::FETCH_ASSOC)) {
  167.                 $sessionSqlMode = explode(',', $data['session_sql_mode']);
  168.                 if (empty($sessionSqlMode[0])) {
  169.                     unset($sessionSqlMode[0]);
  170.                 }
  172.                 // MariaDB is not impacted by this problem
  173.                 if (false === strpos($data['version'], 'MariaDB')) {
  174.                     // MySQL 5.6+ compatibility
  175.                     if (version_compare($data['version'], '5.6.0', '>=')) {
  176.                         // add NO_ENGINE_SUBSTITUTION
  177.                         if (!\in_array('NO_ENGINE_SUBSTITUTION', $sessionSqlMode)) {
  178.                             $sessionSqlMode[] = 'NO_ENGINE_SUBSTITUTION';
  179.                             $canUpdate = true;
  180.                             $logs[] = 'Add sql_mode NO_ENGINE_SUBSTITUTION. Please configure your MySQL server.';
  181.                         }
  183.                         // remove STRICT_TRANS_TABLES
  184.                         if (($key = array_search('STRICT_TRANS_TABLES', $sessionSqlMode)) !== false) {
  185.                             unset($sessionSqlMode[$key]);
  186.                             $canUpdate = true;
  187.                             $logs[] = 'Remove sql_mode STRICT_TRANS_TABLES. Please configure your MySQL server.';
  188.                         }
  190.                         // remove ONLY_FULL_GROUP_BY
  191.                         if (($key = array_search('ONLY_FULL_GROUP_BY', $sessionSqlMode)) !== false) {
  192.                             unset($sessionSqlMode[$key]);
  193.                             $canUpdate = true;
  194.                             $logs[] = 'Remove sql_mode ONLY_FULL_GROUP_BY. Please configure your MySQL server.';
  195.                         }
  196.                     }
  197.                 } else {
  198.                     // MariaDB 10.2.4+ compatibility
  199.                     if (version_compare($data['version'], '10.2.4', '>=')) {
  200.                         // remove STRICT_TRANS_TABLES
  201.                         if (($key = array_search('STRICT_TRANS_TABLES', $sessionSqlMode)) !== false) {
  202.                             unset($sessionSqlMode[$key]);
  203.                             $canUpdate = true;
  204.                             $logs[] = 'Remove sql_mode STRICT_TRANS_TABLES. Please configure your MySQL server.';
  205.                         }
  206.                     }
  208.                     if (version_compare($data['version'], '10.1.7', '>=')) {
  209.                         if (!\in_array('NO_ENGINE_SUBSTITUTION', $sessionSqlMode)) {
  210.                             $sessionSqlMode[] = 'NO_ENGINE_SUBSTITUTION';
  211.                             $canUpdate = true;
  212.                             $logs[] = 'Add sql_mode NO_ENGINE_SUBSTITUTION. Please configure your MySQL server.';
  213.                         }
  214.                     }
  215.                 }
  216.             } else {
  217.                 $logs[] = 'Failed to get MySQL version and sql_mode';
  218.             }
  220.             foreach ($logs as $log) {
  221.                 Tlog::getInstance()->addWarning($log);
  222.             }
  224.             (new Filesystem())->dumpFile(
  225.                 $this->getCacheDir().DS.'check_mysql_configurations.php',
  226.                 '<?php return '.VarExporter::export([
  227.                     'modes' => array_values($sessionSqlMode),
  228.                     'canUpdate' => $canUpdate,
  229.                     'logs' => $logs,
  230.                 ]).';'
  231.             );
  232.         }
  234.         $cache = require $this->getCacheDir().DS.'check_mysql_configurations.php';
  236.         if (!empty($cache['canUpdate'])) {
  237.             if (null === $con->query("SET SESSION sql_mode='".implode(',', $cache['modes'])."';")) {
  238.                 throw new \RuntimeException('Failed to set MySQL global and session sql_mode');
  239.             }
  240.         }
  241.     }
  243.     /**
  244.      * Gets the container's base class.
  245.      *
  246.      * All names except Container must be fully qualified.
  247.      */
  248.     protected function getContainerBaseClass(): string
  249.     {
  250.         return TheliaContainer::class;
  251.     }
  253.     protected function initializeContainer(): void
  254.     {
  255.         // initialize Propel, building its cache if necessary
  256.         $this->propelSchemaLocator = new SchemaLocator(
  257.             THELIA_CONF_DIR,
  258.             THELIA_MODULE_DIR
  259.         );
  261.         $this->propelInitService = new PropelInitService(
  262.             $this->getEnvironment(),
  263.             $this->isDebug(),
  264.             $this->getKernelParameters(),
  265.             $this->propelSchemaLocator
  266.         );
  268.         $this->propelConnectionAvailable = $this->initializePropelService(false, $this->cacheRefresh);
  270.         if ($this->propelConnectionAvailable) {
  271.             $this->theliaDatabaseConnection = Propel::getConnection('TheliaMain');
  272.             $this->checkMySQLConfigurations($this->theliaDatabaseConnection);
  273.         }
  275.         parent::initializeContainer();
  277.         $this->getContainer()->set('thelia.propel.schema.locator', $this->propelSchemaLocator);
  278.         $this->getContainer()->set('thelia.propel.init', $this->propelInitService);
  279.     }
  281.     /**
  282.      * {@inheritDoc}
  283.      *
  284.      * @throws \Exception
  285.      */
  286.     public function boot(): void
  287.     {
  288.         parent::boot();
  290.         if ($this->cacheRefresh) {
  291.             $moduleManagement = new ModuleManagement($this->getContainer());
  292.             $moduleManagement->updateModules($this->getContainer());
  293.         }
  295.         /** @var EventDispatcherInterface $eventDispatcher */
  296.         $eventDispatcher = $this->getContainer()->get('event_dispatcher');
  298.         if ($this->propelConnectionAvailable) {
  299.             $this->theliaDatabaseConnection->setEventDispatcher($eventDispatcher);
  300.         }
  302.         if (self::isInstalled()) {
  303.             $eventDispatcher->dispatch(new Event(), TheliaEvents::BOOT);
  304.         }
  305.     }
  307.     public function initCacheConfigs(bool $force = false): void
  308.     {
  309.         if ($force || !file_exists($this->getCacheDir().DS.'thelia_configs.php')) {
  310.             $caches = [];
  312.             $configs = ConfigQuery::create()->find();
  314.             foreach ($configs as $config) {
  315.                 $caches[$config->getName()] = $config->getValue();
  316.             }
  318.             (new Filesystem())->dumpFile(
  319.                 $this->getCacheDir().DS.'thelia_configs.php',
  320.                 '<?php return '.VarExporter::export($caches).';'
  321.             );
  322.         }
  324.         ConfigQuery::initCache(
  325.             require $this->getCacheDir().DS.'thelia_configs.php'
  326.         );
  327.     }
  329.     /**
  330.      * @throws \Throwable
  331.      *
  332.      * @return bool
  333.      */
  334.     public function initializePropelService($forcePropelCacheGeneration, &$cacheRefresh)
  335.     {
  336.         $cacheRefresh = false;
  338.         return $this->propelInitService->init($forcePropelCacheGeneration, $cacheRefresh);
  339.     }
  341.     /**
  342.      * Add all module's standard templates to the parser environment.
  343.      *
  344.      * @param Definition $parser the parser
  345.      * @param Module     $module the Module
  346.      */
  347.     protected function addStandardModuleTemplatesToParserEnvironment($parser, $module): void
  348.     {
  349.         $stdTpls = TemplateDefinition::getStandardTemplatesSubdirsIterator();
  351.         foreach ($stdTpls as $templateType => $templateSubdirName) {
  352.             $this->addModuleTemplateToParserEnvironment($parser, $module, $templateType, $templateSubdirName);
  353.         }
  354.     }
  356.     /**
  357.      * Add a module template directory to the parser environment.
  358.      *
  359.      * @param Definition $parser             the parser
  360.      * @param Module     $module             the Module
  361.      * @param string     $templateType       the template type (one of the TemplateDefinition type constants)
  362.      * @param string     $templateSubdirName the template subdirectory name (one of the TemplateDefinition::XXX_SUBDIR constants)
  363.      */
  364.     protected function addModuleTemplateToParserEnvironment($parser, $module, $templateType, $templateSubdirName): void
  365.     {
  366.         // Get template path
  367.         $templateDirectory = $module->getAbsoluteTemplateDirectoryPath($templateSubdirName);
  368.         try {
  369.             $templateDirBrowser = new \DirectoryIterator($templateDirectory);
  371.             $code = ucfirst($module->getCode());
  373.             /* browse the directory */
  374.             foreach ($templateDirBrowser as $templateDirContent) {
  375.                 /* is it a directory which is not . or .. ? */
  376.                 if ($templateDirContent->isDir() && !$templateDirContent->isDot()) {
  377.                     $parser->addMethodCall(
  378.                         'addTemplateDirectory',
  379.                         [
  380.                             $templateType,
  381.                             $templateDirContent->getFilename(),
  382.                             $templateDirContent->getPathName(),
  383.                             $code,
  384.                         ]
  385.                     );
  386.                 }
  387.             }
  388.         } catch (\UnexpectedValueException $ex) {
  389.             // The directory does not exists, ignore it.
  390.         }
  391.     }
  393.     private function preBoot(): ContainerInterface
  394.     {
  395.         if (!self::isInstalled()) {
  396.             throw new \Exception('Thelia is not installed');
  397.         }
  398.         if ($this->debug) {
  399.             $this->startTime = microtime(true);
  400.         }
  401.         if ($this->debug && !isset($_ENV['SHELL_VERBOSITY']) && !isset($_SERVER['SHELL_VERBOSITY'])) {
  402.             putenv('SHELL_VERBOSITY=3');
  403.             $_ENV['SHELL_VERBOSITY'] = 3;
  404.             $_SERVER['SHELL_VERBOSITY'] = 3;
  405.         }
  407.         $this->initializeBundles();
  408.         $this->initializeContainer();
  410.         $container = $this->container;
  412.         if ($container->hasParameter('kernel.trusted_hosts') && $trustedHosts = $container->getParameter('kernel.trusted_hosts')) {
  413.             Request::setTrustedHosts($trustedHosts);
  414.         }
  416.         if ($container->hasParameter('kernel.trusted_proxies') && $container->hasParameter('kernel.trusted_headers') && $trustedProxies = $container->getParameter('kernel.trusted_proxies')) {
  417.             Request::setTrustedProxies(\is_array($trustedProxies) ? $trustedProxies : array_map('trim', explode(',', $trustedProxies)), $container->getParameter('kernel.trusted_headers'));
  418.         }
  420.         return $container;
  421.     }
  423.     /**
  424.      * @throws \Exception
  425.      */
  426.     public function handle(Request $request, int $type = HttpKernelInterface::MAIN_REQUEST, bool $catch = true): \Symfony\Component\HttpFoundation\Response
  427.     {
  428.         if (!$this->booted) {
  429.             $container = $this->container ?? $this->preBoot();
  431.             if ($container->has('http_cache')) {
  432.                 return $container->get('http_cache')->handle($request, $type, $catch);
  433.             }
  434.         }
  436.         $this->boot();
  438.         return parent::handle($request, $type, $catch);
  439.     }
  441.     /**
  442.      * Load some configuration
  443.      * Initialize all plugins.
  444.      *
  445.      * @throws \Exception
  446.      */
  447.     protected function loadConfiguration(ContainerBuilder $container): void
  448.     {
  449.         $fileLocator = new FileLocator(__DIR__.'/../Config/Resources');
  450.         $phpLoader = new PhpFileLoader($container, $fileLocator);
  451.         $phpLoader->load('services.php');
  453.         $autoconfiguredInterfaces = [
  454.             SerializerInterface::class => 'thelia.serializer',
  455.             ArchiverInterface::class => 'thelia.archiver',
  456.             FormExtensionInterface::class => 'thelia.forms.extension',
  457.             BaseLoopInterface::class => 'thelia.loop',
  458.             ContainerAwareInterface::class => 'thelia.command',
  459.             FormInterface::class => 'thelia.form',
  460.             CouponInterface::class => 'thelia.coupon.addCoupon',
  461.             ConditionInterface::class => 'thelia.coupon.addCondition',
  462.             ControllerInterface::class => 'controller.service_arguments',
  463.         ];
  465.         foreach ($autoconfiguredInterfaces as $interfaceClass => $tag) {
  466.             $container->registerForAutoconfiguration($interfaceClass)
  467.                 ->addTag($tag);
  468.         }
  470.         // We set this particular service with public true to have all of his subscribers after removing type (see TheliaBundle.php)
  471.         $container->registerForAutoconfiguration(BaseHookInterface::class)
  472.             ->addTag('hook.event_listener')
  473.             ->setPublic(true);
  475.         $loader = new XmlFileLoader($container, $fileLocator);
  476.         $finder = Finder::create()
  477.             ->name('*.xml')
  478.             ->depth(0)
  479.             ->in(__DIR__.'/../Config/Resources');
  481.         /** @var \SplFileInfo $file */
  482.         foreach ($finder as $file) {
  483.             $loader->load($file->getBaseName());
  484.         }
  486.         if (\defined('THELIA_INSTALL_MODE') === false) {
  487.             $modules = ModuleQuery::getActivated();
  489.             $translationDirs = [];
  491.             /** @var Module $module */
  492.             foreach ($modules as $module) {
  493.                 try {
  494.                     // In case modules want add configuration
  495.                     \call_user_func([$module->getFullNamespace(), 'loadConfiguration'], $container);
  497.                     $definition = new Definition();
  498.                     $definition->setClass($module->getFullNamespace());
  499.                     $definition->addMethodCall('setContainer', [new Reference('service_container')]);
  500.                     $definition->setPublic(true);
  502.                     $container->setDefinition(
  503.                         'module.'.$module->getCode(),
  504.                         $definition
  505.                     );
  507.                     $compilers = \call_user_func([$module->getFullNamespace(), 'getCompilers']);
  509.                     foreach ($compilers as $compiler) {
  510.                         if (\is_array($compiler)) {
  511.                             $container->addCompilerPass($compiler[0], $compiler[1]);
  512.                         } else {
  513.                             $container->addCompilerPass($compiler);
  514.                         }
  515.                     }
  517.                     $loader = new XmlFileLoader($container, new FileLocator($module->getAbsoluteConfigPath()));
  518.                     $loader->load('config.xml', 'module.'.$module->getCode());
  520.                     $envConfigFileName = sprintf('config_%s.xml', $this->environment);
  521.                     $envConfigFile = sprintf('%s%s%s', $module->getAbsoluteConfigPath(), DS, $envConfigFileName);
  523.                     if (is_file($envConfigFile) && is_readable($envConfigFile)) {
  524.                         $loader->load($envConfigFileName, 'module.'.$module->getCode());
  525.                     }
  527.                     $templateBasePath = $module->getAbsoluteTemplateBasePath();
  528.                     if (is_dir($templateBasePath)) {
  529.                         $container->loadFromExtension('twig', [
  530.                             'paths' => [
  531.                                 $templateBasePath => $module->getCode().'Module',
  532.                             ],
  533.                         ]);
  534.                     }
  535.                 } catch (\Exception $e) {
  536.                     if ($this->debug) {
  537.                         throw $e;
  538.                     }
  539.                     Tlog::getInstance()->addError(
  540.                         sprintf('Failed to load module %s: %s', $module->getCode(), $e->getMessage()),
  541.                         $e
  542.                     );
  543.                 }
  544.             }
  546.             // Register templates 'component' directories in a class loader.
  547.             $templateClassLoader = new ClassLoader();
  549.             foreach (self::getTemplateComponentsDirectories() as $namespace => $resource) {
  550.                 if (is_dir($resource)) {
  551.                     $templateClassLoader->addPsr4($namespace, $resource);
  552.                 }
  553.             }
  555.             $templateClassLoader->register();
  557.             $parser = $container->getDefinition(SmartyParser::class);
  559.             /** @var \Thelia\Core\Template\TemplateHelperInterface $templateHelper */
  560.             $templateHelper = $container->get('thelia.template_helper');
  562.             /** @var Module $module */
  563.             foreach ($modules as $module) {
  564.                 try {
  565.                     $this->loadModuleTranslationDirectories($module, $translationDirs, $templateHelper);
  567.                     $this->addStandardModuleTemplatesToParserEnvironment($parser, $module);
  568.                 } catch (\Exception $e) {
  569.                     if ($this->debug) {
  570.                         throw $e;
  571.                     }
  572.                     Tlog::getInstance()->addError(
  573.                         sprintf('Failed to load module %s: %s', $module->getCode(), $e->getMessage()),
  574.                         $e
  575.                     );
  576.                 }
  577.             }
  579.             // Load core translation
  580.             $translationDirs['core'] = THELIA_LIB.'Config'.DS.'I18n';
  582.             // Load core translation
  583.             $translationDirs[Translator::GLOBAL_FALLBACK_DOMAIN] = THELIA_LOCAL_DIR.'I18n';
  585.             // Standard templates (front, back, pdf, mail)
  586.             /** @var TemplateDefinition $templateDefinition */
  587.             foreach ($templateHelper->getStandardTemplateDefinitions() as $templateDefinition) {
  588.                 // Load parent templates transaltions, the current template translations.
  589.                 $templateList = array_merge(
  590.                     $templateDefinition->getParentList(),
  591.                     [$templateDefinition]
  592.                 );
  594.                 /** @var TemplateDefinition $tplDef */
  595.                 foreach ($templateList as $tplDef) {
  596.                     if (is_dir($dir = $tplDef->getAbsoluteI18nPath())) {
  597.                         $translationDirs[$tplDef->getTranslationDomain()] = $dir;
  598.                     }
  599.                 }
  600.             }
  602.             if ($translationDirs) {
  603.                 $this->loadTranslation($container, $translationDirs);
  604.             }
  605.         }
  606.     }
  608.     /**
  609.      * @param TemplateHelperInterface $templateHelper
  610.      */
  611.     private function loadModuleTranslationDirectories(Module $module, array &$translationDirs, $templateHelper): void
  612.     {
  613.         // Core module translation
  614.         if (is_dir($dir = $module->getAbsoluteI18nPath())) {
  615.             $translationDirs[$module->getTranslationDomain()] = $dir;
  616.         }
  618.         // Admin includes translation
  619.         if (is_dir($dir = $module->getAbsoluteAdminIncludesI18nPath())) {
  620.             $translationDirs[$module->getAdminIncludesTranslationDomain()] = $dir;
  621.         }
  623.         // Module back-office template, if any
  624.         $templates =
  625.             $templateHelper->getList(
  626.                 TemplateDefinition::BACK_OFFICE,
  627.                 $module->getAbsoluteTemplateBasePath()
  628.             );
  630.         foreach ($templates as $template) {
  631.             $translationDirs[$module->getBackOfficeTemplateTranslationDomain($template->getName())] =
  632.                 $module->getAbsoluteBackOfficeI18nTemplatePath($template->getName());
  633.         }
  635.         // Module front-office template, if any
  636.         $templates =
  637.             $templateHelper->getList(
  638.                 TemplateDefinition::FRONT_OFFICE,
  639.                 $module->getAbsoluteTemplateBasePath()
  640.             );
  642.         foreach ($templates as $template) {
  643.             $translationDirs[$module->getFrontOfficeTemplateTranslationDomain($template->getName())] =
  644.                 $module->getAbsoluteFrontOfficeI18nTemplatePath($template->getName());
  645.         }
  647.         // Module pdf template, if any
  648.         $templates =
  649.             $templateHelper->getList(
  650.                 TemplateDefinition::PDF,
  651.                 $module->getAbsoluteTemplateBasePath()
  652.             );
  654.         foreach ($templates as $template) {
  655.             $translationDirs[$module->getPdfTemplateTranslationDomain($template->getName())] =
  656.                 $module->getAbsolutePdfI18nTemplatePath($template->getName());
  657.         }
  659.         // Module email template, if any
  660.         $templates =
  661.             $templateHelper->getList(
  662.                 TemplateDefinition::EMAIL,
  663.                 $module->getAbsoluteTemplateBasePath()
  664.             );
  666.         foreach ($templates as $template) {
  667.             $translationDirs[$module->getEmailTemplateTranslationDomain($template->getName())] =
  668.                 $module->getAbsoluteEmailI18nTemplatePath($template->getName());
  669.         }
  670.     }
  672.     private function loadTranslation(ContainerBuilder $container, array $dirs): void
  673.     {
  674.         $translator = $container->getDefinition(Translator::class);
  676.         foreach ($dirs as $domain => $dir) {
  677.             try {
  678.                 $finder = Finder::create()
  679.                     ->files()
  680.                     ->depth(0)
  681.                     ->in($dir);
  683.                 /** @var \DirectoryIterator $file */
  684.                 foreach ($finder as $file) {
  685.                     [$locale, $format] = explode('.', $file->getBaseName(), 2);
  687.                     $translator->addMethodCall('addResource', [$format, (string) $file, $locale, $domain]);
  688.                 }
  689.             } catch (\InvalidArgumentException $ex) {
  690.                 // Ignore missing I18n directories
  691.                 Tlog::getInstance()->addWarning("loadTranslation: missing $dir directory");
  692.             }
  693.         }
  694.     }
  696.     /**
  697.      * Builds the service container.
  698.      *
  699.      * @throws \Exception
  700.      *
  701.      * @return ContainerBuilder The compiled service container
  702.      */
  703.     protected function buildContainer(): ContainerBuilder
  704.     {
  705.         $container = parent::buildContainer();
  707.         $this->loadConfiguration($container);
  709.         return $container;
  710.     }
  712.     /**
  713.      * Gets the cache directory.
  714.      *
  715.      * @return string The cache directory
  716.      *
  717.      * @api
  718.      */
  719.     public function getCacheDir(): string
  720.     {
  721.         if (\defined('THELIA_ROOT')) {
  722.             return THELIA_CACHE_DIR.$this->environment;
  723.         }
  725.         return parent::getCacheDir();
  726.     }
  728.     /**
  729.      * Gets the log directory.
  730.      *
  731.      * @return string The log directory
  732.      *
  733.      * @api
  734.      */
  735.     public function getLogDir(): string
  736.     {
  737.         if (\defined('THELIA_ROOT')) {
  738.             return THELIA_LOG_DIR;
  739.         }
  741.         return parent::getLogDir();
  742.     }
  744.     /**
  745.      * Returns the kernel parameters.
  746.      *
  747.      * @return array An array of kernel parameters
  748.      */
  749.     protected function getKernelParameters(): array
  750.     {
  751.         $parameters = parent::getKernelParameters();
  753.         // Todo replace this by real runtime env
  754.         $parameters['kernel.runtime_environment'] = $this->environment;
  756.         $parameters['thelia.root_dir'] = THELIA_ROOT;
  757.         $parameters['thelia.core_dir'] = \dirname(__DIR__); // This class is in core/lib/Thelia/Core.
  758.         $parameters['thelia.module_dir'] = THELIA_MODULE_DIR;
  760.         $parameters['thelia.db_host'] = $_SERVER['DB_HOST'] ?? null;
  761.         $parameters['thelia.db_port'] = $_SERVER['DB_PORT'] ?? null;
  762.         $parameters['thelia.db_name'] = $_SERVER['DB_NAME'] ?? null;
  763.         $parameters['thelia.db_user'] = $_SERVER['DB_USER'] ?? null;
  764.         $parameters['thelia.db_password'] = $_SERVER['DB_PASSWORD'] ?? null;
  766.         return $parameters;
  767.     }
  769.     /**
  770.      * {@inheritdoc}
  771.      */
  772.     public function registerBundles(): iterable
  773.     {
  774.         $contents = [
  775.             Bundle\TheliaBundle::class => ['all' => true],
  776.         ];
  778.         if (file_exists(THELIA_ROOT.'config/bundles.php')) {
  779.             $contents = array_merge($contents, require THELIA_ROOT.'config/bundles.php');
  780.         }
  782.         foreach ($contents as $class => $envs) {
  783.             if ($envs[$this->environment] ?? $envs['all'] ?? false) {
  784.                 yield new $class();
  785.             }
  786.         }
  787.     }
  788. }