core/lib/Thelia/Core/Hook/BaseHook.php line 110

  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\Hook;
  15. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  16. use Thelia\Core\Event\Hook\HookRenderEvent;
  17. use Thelia\Core\HttpFoundation\Request;
  18. use Thelia\Core\HttpFoundation\Session\Session;
  19. use Thelia\Core\Template\Assets\AssetResolverInterface;
  20. use Thelia\Core\Template\ParserInterface;
  21. use Thelia\Core\Translation\Translator;
  22. use Thelia\Model\Cart;
  23. use Thelia\Model\Currency;
  24. use Thelia\Model\Customer;
  25. use Thelia\Model\Lang;
  26. use Thelia\Model\ModuleQuery;
  27. use Thelia\Model\Order;
  28. use Thelia\Module\BaseModule;
  29. use TheliaSmarty\Template\SmartyParser;
  31. /**
  32.  * The base class for hook. If you provide hooks in your module you have to extends
  33.  * this class.
  34.  *
  35.  * These class provides some helper functions to retrieve object from the current session
  36.  * of the current user. It also provides a render function that allows you to get the right
  37.  * template file from different locations and allows you to override templates in your current
  38.  * template.
  39.  *
  40.  * Class BaseHook
  41.  *
  42.  * @author  Julien Chanséaume <jchanseaume@openstudio.fr>
  43.  */
  44. abstract class BaseHook implements BaseHookInterface
  45. {
  46.     public const INJECT_TEMPLATE_METHOD_NAME = 'insertTemplate';
  48.     /** @var BaseModule */
  49.     public $module;
  51.     /** @var array list of templates automatically injected */
  52.     protected $templates = [];
  54.     /** @var \Thelia\Core\Template\ParserInterface */
  55.     public $parser;
  57.     /** @var TranslatorInterface */
  58.     public $translator;
  60.     /** @var AssetResolverInterface */
  61.     public $assetsResolver;
  63.     /** @var EventDispatcherInterface */
  64.     public $dispatcher;
  66.     /** @var Request */
  67.     protected $request;
  69.     /** @var Session */
  70.     protected $session;
  72.     /** @var Customer */
  73.     protected $customer;
  75.     /** @var Cart */
  76.     protected $cart;
  78.     /** @var Order */
  79.     protected $order;
  81.     /** @var Lang */
  82.     protected $lang;
  84.     /** @var Currency */
  85.     protected $currency;
  87.     public function __construct(SmartyParser $parser = null, AssetResolverInterface $resolver = null, EventDispatcherInterface $eventDispatcher = null)
  88.     {
  89.         if (null !== $parser) {
  90.             $this->parser = $parser;
  91.         }
  92.         if (null !== $resolver) {
  93.             $this->assetsResolver = $resolver;
  94.         }
  95.         if (null !== $eventDispatcher) {
  96.             $this->dispatcher = $eventDispatcher;
  97.         }
  99.         $moduleCode = explode('\\', static::class)[0];
  100.         $module = ModuleQuery::create()->findOneByCode($moduleCode);
  101.         $this->module = $module;
  102.         $this->translator = Translator::getInstance();
  103.     }
  105.     /**
  106.      * This function is called when hook uses the automatic insert template.
  107.      *
  108.      * @param string $code
  109.      */
  110.     public function insertTemplate(HookRenderEvent $event, $code): void
  111.     {
  112.         if (\array_key_exists($code, $this->templates)) {
  113.             $templates = explode(';', $this->templates[$code]);
  115.             // Concatenate arguments and template variables,
  116.             // giving the precedence to arguments.
  117.             $allArguments = $event->getTemplateVars() + $event->getArguments();
  119.             foreach ($templates as $template) {
  120.                 [$type, $filepath] = $this->getTemplateParams($template);
  122.                 if ('render' === $type) {
  123.                     $event->add($this->render($filepath, $allArguments));
  124.                     continue;
  125.                 }
  127.                 if ('dump' === $type) {
  128.                     $event->add($this->render($filepath));
  129.                     continue;
  130.                 }
  132.                 if ('css' === $type) {
  133.                     $event->add($this->addCSS($filepath));
  134.                     continue;
  135.                 }
  137.                 if ('js' === $type) {
  138.                     $event->add($this->addJS($filepath));
  139.                     continue;
  140.                 }
  142.                 if (method_exists($this, $type)) {
  143.                     $this->{$type}($filepath, $allArguments);
  144.                 }
  145.             }
  146.         }
  147.     }
  149.     /**
  150.      * helper function allowing you to render a template using a template engine.
  151.      *
  152.      * @param string $templateName the template path of the template
  153.      * @param array  $parameters   an array of parameters to assign to a template engine
  154.      *
  155.      * @return string the content generated by a template engine
  156.      */
  157.     public function render($templateName, array $parameters = [])
  158.     {
  159.         $templateDir = $this->assetsResolver->resolveAssetSourcePath($this->module->getCode(), false, $templateName, $this->parser);
  161.         if (null !== $templateDir) {
  162.             // retrieve the template
  163.             $content = $this->parser->render($templateDir.DS.$templateName, $parameters);
  164.         } else {
  165.             $content = sprintf('ERR: Unknown template %s for module %s', $templateName, $this->module->getCode());
  166.         }
  168.         return $content;
  169.     }
  171.     /**
  172.      * helper function allowing you to get the content of a file.
  173.      *
  174.      * @param string $fileName the template path of the template
  175.      *
  176.      * @return string the content of the file
  177.      */
  178.     public function dump($fileName)
  179.     {
  180.         $fileDir = $this->assetsResolver->resolveAssetSourcePath($this->module->getCode(), false, $fileName, $this->parser);
  182.         if (null !== $fileDir) {
  183.             $content = file_get_contents($fileDir.DS.$fileName);
  184.             if (false === $content) {
  185.                 $content = '';
  186.             }
  187.         } else {
  188.             $content = sprintf('ERR: Unknown file %s for module %s', $fileName, $this->module->getCode());
  189.         }
  191.         return $content;
  192.     }
  194.     /**
  195.      * helper function allowing you to generate the HTML link tag.
  196.      *
  197.      * @param string $fileName   the path to the css file
  198.      * @param array  $attributes the attributes of the tag
  199.      * @param array  $filters    an array of assets processing filters (less, sass, etc.)
  200.      *
  201.      * @return string the link tag
  202.      */
  203.     public function addCSS($fileName, $attributes = [], $filters = [])
  204.     {
  205.         $tag = '';
  207.         $url = $this->assetsResolver->resolveAssetURL($this->module->getCode(), $fileName, 'css', $this->parser, $filters);
  209.         if ('' !== $url) {
  210.             $tags = [];
  211.             $tags[] = '<link rel="stylesheet" type="text/css" ';
  212.             $tags[] = ' href="'.$url.'" ';
  213.             foreach ($attributes as $name => $val) {
  214.                 if (\is_string($name) && !\in_array($name, ['href', 'rel', 'type'])) {
  215.                     $tags[] = $name.'="'.$val.'" ';
  216.                 }
  217.             }
  218.             $tags[] = '/>';
  219.             $tag = implode('', $tags);
  220.         }
  222.         return $tag;
  223.     }
  225.     /**
  226.      * helper function allowing you to generate the HTML script tag.
  227.      *
  228.      * @param string $fileName   the path to the js file
  229.      * @param array  $attributes the attributes of the tag
  230.      * @param array  $filters    an array of assets processing filters (cofeescript, compress, etc.)
  231.      *
  232.      * @return string the script tag
  233.      */
  234.     public function addJS($fileName, $attributes = [], $filters = [])
  235.     {
  236.         $tag = '';
  238.         $url = $this->assetsResolver->resolveAssetURL($this->module->getCode(), $fileName, 'js', $this->parser, $filters);
  240.         if ('' !== $url) {
  241.             $tags = [];
  242.             $tags[] = '<script type="text/javascript" ';
  243.             $tags[] = ' src="'.$url.'" ';
  244.             foreach ($attributes as $name => $val) {
  245.                 if (\is_string($name) && !\in_array($name, ['src', 'type'])) {
  246.                     $tags[] = $name.'="'.$val.'" ';
  247.                 }
  248.             }
  249.             $tags[] = '></script>';
  250.             $tag = implode('', $tags);
  251.         }
  253.         return $tag;
  254.     }
  256.     /**
  257.      * @param \Thelia\Module\BaseModule $module
  258.      */
  259.     public function setModule($module): void
  260.     {
  261.         $this->module = $module;
  262.     }
  264.     /**
  265.      * @return \Thelia\Module\BaseModule
  266.      */
  267.     public function getModule()
  268.     {
  269.         return $this->module;
  270.     }
  272.     public function setParser(ParserInterface $parser): void
  273.     {
  274.         $this->parser = $parser;
  275.     }
  277.     /**
  278.      * @return \Thelia\Core\Template\ParserInterface
  279.      */
  280.     public function getParser()
  281.     {
  282.         return $this->parser;
  283.     }
  285.     /**
  286.      * Translates the given message.
  287.      *
  288.      * @param string $id         The message id (may also be an object that can be cast to string)
  289.      * @param array  $parameters An array of parameters for the message
  290.      * @param string $domain     The domain for the message
  291.      * @param string $locale     The locale
  292.      *
  293.      * @return string The translated string
  294.      *
  295.      * @api
  296.      */
  297.     protected function trans($id, array $parameters = [], $domain = null, $locale = null)
  298.     {
  299.         return $this->translator->trans($id, $parameters, $domain, $locale);
  300.     }
  302.     /**
  303.      * get the request.
  304.      *
  305.      * @return Request
  306.      */
  307.     protected function getRequest()
  308.     {
  309.         if (null === $this->request) {
  310.             $this->request = $this->getParser()->getRequest();
  311.         }
  313.         return $this->request;
  314.     }
  316.     /**
  317.      * get the session.
  318.      *
  319.      * @return Session
  320.      */
  321.     protected function getSession()
  322.     {
  323.         if (null === $this->session) {
  324.             if (null !== $this->getRequest()) {
  325.                 $this->session = $this->request->getSession();
  326.             }
  327.         }
  329.         return $this->session;
  330.     }
  332.     /**
  333.      * Get the view argument for the request.
  334.      *
  335.      * It allows you to identify the page currently displayed. eg: index, category, ...
  336.      *
  337.      * @return string the current view
  338.      */
  339.     protected function getView()
  340.     {
  341.         $ret = '';
  342.         if (null !== $this->getRequest()) {
  343.             $ret = $this->getRequest()->attributes->get('_view', '');
  344.         }
  346.         return $ret;
  347.     }
  349.     /**
  350.      * Get the cart from the session.
  351.      *
  352.      * @return \Thelia\Model\Cart|null
  353.      */
  354.     protected function getCart()
  355.     {
  356.         if (null === $this->cart) {
  357.             $this->cart = $this->getSession() ? $this->getSession()->getSessionCart($this->dispatcher) : null;
  358.         }
  360.         return $this->cart;
  361.     }
  363.     /**
  364.      * Get the order from the session.
  365.      *
  366.      * @return \Thelia\Model\Order|null
  367.      */
  368.     protected function getOrder()
  369.     {
  370.         if (null === $this->order) {
  371.             $this->order = $this->getSession() ? $this->getSession()->getOrder() : null;
  372.         }
  374.         return $this->order;
  375.     }
  377.     /**
  378.      * Get the current currency used or if not present the default currency for the shop.
  379.      *
  380.      * @return \Thelia\Model\Currency
  381.      */
  382.     protected function getCurrency()
  383.     {
  384.         if (null === $this->currency) {
  385.             $this->currency = $this->getSession() ? $this->getSession()->getCurrency(true) : Currency::getDefaultCurrency();
  386.         }
  388.         return $this->currency;
  389.     }
  391.     /**
  392.      * Get the current customer logged in. If no customer is logged return null.
  393.      *
  394.      * @return \Thelia\Model\Customer|null
  395.      */
  396.     protected function getCustomer()
  397.     {
  398.         if (null === $this->customer) {
  399.             $this->customer = $this->getSession() ? $this->getSession()->getCustomerUser() : null;
  400.         }
  402.         return $this->customer;
  403.     }
  405.     /**
  406.      * Get the current lang used or if not present the default lang for the shop.
  407.      *
  408.      * @return \Thelia\Model\Lang
  409.      */
  410.     protected function getLang()
  411.     {
  412.         if (null === $this->lang) {
  413.             $this->lang = $this->getSession() ? $this->getSession()->getLang(true) : $this->lang = Lang::getDefaultLanguage();
  414.         }
  416.         return $this->lang;
  417.     }
  419.     /**
  420.      * Add a new template for automatic render.
  421.      *
  422.      * @param string $hookCode the code of the hook (the name of the event used to render) : 'hook.{type}.{hook code}'
  423.      * @param string $value    list of the template to render or add.
  424.      *                         eg: 'render:mytemplate.html;css:assets/css/mycss.css;js:assets/js/myjs.js'
  425.      */
  426.     public function addTemplate($hookCode, $value): void
  427.     {
  428.         if (\array_key_exists($hookCode, $this->templates)) {
  429.             throw new \InvalidArgumentException(sprintf("The hook '%s' is already used in this class.", $hookCode));
  430.         }
  432.         $this->templates[$hookCode] = $value;
  433.     }
  435.     /**
  436.      * @return array templates
  437.      */
  438.     public function getTemplates()
  439.     {
  440.         return $this->templates;
  441.     }
  443.     /**
  444.      * @return array
  445.      */
  446.     protected function getTemplateParams($template)
  447.     {
  448.         $templateParams = explode(':', $template);
  450.         if (\count($templateParams) > 1) {
  451.             $type = $templateParams[0];
  452.             $filepath = $templateParams[1];
  453.         } else {
  454.             $type = 'render';
  455.             $filepath = $templateParams[0];
  456.         }
  458.         return [$type, $filepath];
  459.     }
  461.     /**
  462.      *  A hook is basically an Event, this function returns an array of hooks this hook subscriber wants to listen to.
  463.      *
  464.      *  Example:
  465.      *  [
  466.      *      'hook.event.name' => [
  467.      *          [
  468.      *              type => "back",
  469.      *              method => "onModuleConfiguration"
  470.      *          ],
  471.      *          [
  472.      *              type => "front",
  473.      *              template => "render:module_configuration.html"
  474.      *          ],
  475.      *          [
  476.      *              type => "front",
  477.      *              method => "displaySomething"
  478.      *          ],
  479.      *      ],
  480.      *      'another.hook' => [[...]]
  481.      *  ]
  482.      *
  483.      * @return array
  484.      */
  485.     public static function getSubscribedHooks()
  486.     {
  487.         return [];
  488.     }
  489. }