local/modules/TheliaSmarty/Template/SmartyParser.php line 534

  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 TheliaSmarty\Template;
  15. use Imagine\Exception\InvalidArgumentException;
  16. use Smarty;
  17. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  18. use Symfony\Component\HttpFoundation\Request;
  19. use Symfony\Component\HttpFoundation\RequestStack;
  20. use Thelia\Core\HttpFoundation\Session\Session;
  21. use Thelia\Core\Template\Exception\ResourceNotFoundException;
  22. use Thelia\Core\Template\ParserContext;
  23. use Thelia\Core\Template\ParserInterface;
  24. use Thelia\Core\Template\TemplateDefinition;
  25. use Thelia\Core\Template\TemplateHelperInterface;
  26. use Thelia\Core\Translation\Translator;
  27. use Thelia\Log\Tlog;
  28. use Thelia\Model\ConfigQuery;
  29. use Thelia\Model\Lang;
  31. /**
  32.  * @author Franck Allimant <franck@cqfdev.fr>
  33.  * @author Etienne Roudeix <eroudeix@openstudio.fr>
  34.  */
  35. class SmartyParser extends \Smarty implements ParserInterface
  36. {
  37.     public $plugins = [];
  39.     /** @var EventDispatcherInterface */
  40.     protected $dispatcher;
  42.     /** @var ParserContext */
  43.     protected $parserContext;
  45.     /** @var TemplateHelperInterface */
  46.     protected $templateHelper;
  48.     /** @var RequestStack */
  49.     protected $requestStack;
  51.     protected $backOfficeTemplateDirectories = [];
  52.     protected $frontOfficeTemplateDirectories = [];
  54.     protected $templateDirectories = [];
  56.     /** @var TemplateDefinition */
  57.     protected $templateDefinition;
  59.     /** @var bool if true, resources will also be searched in the default template */
  60.     protected $fallbackToDefaultTemplate = false;
  62.     /** @var int */
  63.     protected $status = 200;
  65.     /** @var string */
  66.     protected $env;
  68.     /** @var bool */
  69.     protected $debug;
  71.     /** @var array The template stack */
  72.     protected $tplStack = [];
  74.     /** @var bool */
  75.     protected $useMethodCallWrapper = false;
  77.     /**
  78.      * @param string $kernelEnvironment
  79.      * @param bool   $kernelDebug
  80.      *
  81.      * @throws \SmartyException
  82.      */
  83.     public function __construct(
  84.         RequestStack $requestStack,
  85.         EventDispatcherInterface $dispatcher,
  86.         ParserContext $parserContext,
  87.         TemplateHelperInterface $templateHelper,
  88.         $kernelEnvironment = 'prod',
  89.         $kernelDebug = false
  90.     ) {
  91.         parent::__construct();
  93.         $this->requestStack = $requestStack;
  94.         $this->dispatcher = $dispatcher;
  95.         $this->parserContext = $parserContext;
  96.         $this->templateHelper = $templateHelper;
  97.         $this->env = $kernelEnvironment;
  98.         $this->debug = $kernelDebug;
  100.         // Use method call compatibility wrapper ?
  101.         $this->useMethodCallWrapper = version_compare(self::SMARTY_VERSION, '3.1.33', '>=');
  103.         // Configure basic Smarty parameters
  105.         $compile_dir = THELIA_CACHE_DIR.DS.$kernelEnvironment.DS.'smarty'.DS.'compile';
  106.         if (!is_dir($compile_dir)) {
  107.             @mkdir($compile_dir, 0777, true);
  108.         }
  110.         $cache_dir = THELIA_CACHE_DIR.DS.$kernelEnvironment.DS.'smarty'.DS.'cache';
  111.         if (!is_dir($cache_dir)) {
  112.             @mkdir($cache_dir, 0777, true);
  113.         }
  115.         $this->setCompileDir($compile_dir);
  116.         $this->setCacheDir($cache_dir);
  118.         // Prevent smarty ErrorException: Notice: Undefined index bla bla bla...
  119.         $this->error_reporting = \E_ALL ^ \E_NOTICE;
  121.         // The default HTTP status
  122.         $this->status = 200;
  124.         $this->registerFilter('output', [$this, 'trimWhitespaces']);
  125.         $this->registerFilter('variable', [__CLASS__, 'theliaEscape']);
  126.     }
  128.     /**
  129.      * Return the current request or null if no request exists.
  130.      *
  131.      * @return Request|null
  132.      */
  133.     public function getRequest()
  134.     {
  135.         return $this->requestStack->getCurrentRequest();
  136.     }
  138.     /**
  139.      * Trim whitespaces from the HTML output, preserving required ones in pre, textarea, javascript.
  140.      * This methois uses 3 levels of trimming :.
  141.      *
  142.      *    - 0 : whitespaces are not trimmed, code remains as is.
  143.      *    - 1 : only blank lines are trimmed, code remains indented and human-readable (the default)
  144.      *    - 2 or more : all unnecessary whitespace are removed. Code is very hard to read.
  145.      *
  146.      * The trim level is defined by the configuration variable html_output_trim_level
  147.      *
  148.      * @param string $source the HTML source
  149.      *
  150.      * @return string
  151.      */
  152.     public function trimWhitespaces($source, /* @noinspection PhpUnusedParameterInspection */ \Smarty_Internal_Template $template)
  153.     {
  154.         $compressionMode = ConfigQuery::read('html_output_trim_level', 1);
  156.         if ($compressionMode == 0) {
  157.             return $source;
  158.         }
  160.         $store = [];
  161.         $_store = 0;
  162.         $_offset = 0;
  164.         // Unify Line-Breaks to \n
  165.         $source = preg_replace("/\015\012|\015|\012/", "\n", $source);
  167.         // capture Internet Explorer Conditional Comments
  168.         if ($compressionMode == 1) {
  169.             $expressions = [
  170.                 // remove spaces between attributes (but not in attribute values!)
  171.                 '#(([a-z0-9]\s*=\s*(["\'])[^\3]*?\3)|<[a-z0-9_]+)\s+([a-z/>])#is' => '\1 \4',
  172.                 '/(^[\n]*|[\n]+)[\s\t]*[\n]+/' => "\n",
  173.             ];
  174.         } elseif ($compressionMode >= 2) {
  175.             if (preg_match_all('#<!--\[[^\]]+\]>.*?<!\[[^\]]+\]-->#is', $source, $matches, \PREG_OFFSET_CAPTURE | \PREG_SET_ORDER)) {
  176.                 foreach ($matches as $match) {
  177.                     $store[] = $match[0][0];
  178.                     $_length = \strlen($match[0][0]);
  179.                     $replace = '@!@SMARTY:'.$_store.':SMARTY@!@';
  180.                     $source = substr_replace($source, $replace, $match[0][1] - $_offset, $_length);
  182.                     $_offset += $_length - \strlen($replace);
  183.                     ++$_store;
  184.                 }
  185.             }
  187.             // Strip all HTML-Comments
  188.             // yes, even the ones in <script> - see http://stackoverflow.com/a/808850/515124
  189.             $source = preg_replace('#<!--.*?-->#ms', '', $source);
  191.             $expressions = [
  192.                 // replace multiple spaces between tags by a single space
  193.                 // can't remove them entirely, becaue that might break poorly implemented CSS display:inline-block elements
  194.                 '#(:SMARTY@!@|>)\s+(?=@!@SMARTY:|<)#s' => '\1 \2',
  195.                 // remove spaces between attributes (but not in attribute values!)
  196.                 '#(([a-z0-9]\s*=\s*(["\'])[^\3]*?\3)|<[a-z0-9_]+)\s+([a-z/>])#is' => '\1 \4',
  197.                 // note: for some very weird reason trim() seems to remove spaces inside attributes.
  198.                 // maybe a \0 byte or something is interfering?
  199.                 '#^\s+<#Ss' => '<',
  200.                 '#>\s+$#Ss' => '>',
  201.             ];
  202.         } else {
  203.             $expressions = [];
  204.         }
  206.         // capture html elements not to be messed with
  207.         $_offset = 0;
  208.         if (preg_match_all('#<(script|pre|textarea)[^>]*>.*?</\\1>#is', $source, $matches, \PREG_OFFSET_CAPTURE | \PREG_SET_ORDER)) {
  209.             foreach ($matches as $match) {
  210.                 $store[] = $match[0][0];
  211.                 $_length = \strlen($match[0][0]);
  212.                 $replace = '@!@SMARTY:'.$_store.':SMARTY@!@';
  213.                 $source = substr_replace($source, $replace, $match[0][1] - $_offset, $_length);
  215.                 $_offset += $_length - \strlen($replace);
  216.                 ++$_store;
  217.             }
  218.         }
  220.         // Protect output against a potential regex execution error (e.g., PREG_BACKTRACK_LIMIT_ERROR)
  221.         if (null !== $tmp = preg_replace(array_keys($expressions), array_values($expressions), $source)) {
  222.             $source = $tmp;
  223.             unset($tmp);
  224.         } else {
  225.             Tlog::getInstance()->error('Failed to trim whitespaces from parser output: '.preg_last_error());
  226.         }
  228.         // capture html elements not to be messed with
  229.         $_offset = 0;
  230.         if (preg_match_all('#@!@SMARTY:([0-9]+):SMARTY@!@#is', $source, $matches, \PREG_OFFSET_CAPTURE | \PREG_SET_ORDER)) {
  231.             foreach ($matches as $match) {
  232.                 $store[] = $match[0][0];
  233.                 $_length = \strlen($match[0][0]);
  234.                 $replace = array_shift($store);
  235.                 $source = substr_replace($source, $replace, $match[0][1] + $_offset, $_length);
  237.                 $_offset += \strlen($replace) - $_length;
  238.                 ++$_store;
  239.             }
  240.         }
  242.         return $source;
  243.     }
  245.     /**
  246.      * Add a template directory to the current template list.
  247.      *
  248.      * @param int    $templateType      the template type (a TemplateDefinition type constant)
  249.      * @param string $templateName      the template name
  250.      * @param string $templateDirectory path to the template directory
  251.      * @param string $key               ???
  252.      * @param bool   $addAtBeginning    if true, the template definition should be added at the beginning of the template directory list
  253.      */
  254.     public function addTemplateDirectory($templateType, $templateName, $templateDirectory, $key, $addAtBeginning = false): void
  255.     {
  256.         Tlog::getInstance()->addDebug("Adding template directory $templateDirectory, type:$templateType name:$templateName, key: $key");
  258.         if (true === $addAtBeginning && isset($this->templateDirectories[$templateType][$templateName])) {
  259.             // When using array_merge, the key was set to 0. Use + instead.
  260.             $this->templateDirectories[$templateType][$templateName] =
  261.                 [$key => $templateDirectory] + $this->templateDirectories[$templateType][$templateName]
  262.             ;
  263.         } else {
  264.             $this->templateDirectories[$templateType][$templateName][$key] = $templateDirectory;
  265.         }
  266.     }
  268.     /**
  269.      * Return the registered template directories for a given template type.
  270.      *
  271.      * @param int $templateType
  272.      *
  273.      * @throws InvalidArgumentException
  274.      *
  275.      * @return mixed:
  276.      */
  277.     public function getTemplateDirectories($templateType)
  278.     {
  279.         if (!isset($this->templateDirectories[$templateType])) {
  280.             throw new InvalidArgumentException('Failed to get template type %', $templateType);
  281.         }
  283.         return $this->templateDirectories[$templateType];
  284.     }
  286.     public static function theliaEscape($content, /* @noinspection PhpUnusedParameterInspection */ $smarty)
  287.     {
  288.         if (\is_scalar($content)) {
  289.             return htmlspecialchars($content, \ENT_QUOTES, \Smarty::$_CHARSET);
  290.         }
  292.         return $content;
  293.     }
  295.     /**
  296.      * Set a new template definition, and save the current one.
  297.      *
  298.      * @param bool $fallbackToDefaultTemplate if true, resources will be also searched in the "default" template
  299.      */
  300.     public function pushTemplateDefinition(TemplateDefinition $templateDefinition, $fallbackToDefaultTemplate = false): void
  301.     {
  302.         if (null !== $this->templateDefinition) {
  303.             $this->tplStack[] = [$this->templateDefinition, $this->fallbackToDefaultTemplate];
  304.         }
  306.         $this->setTemplateDefinition($templateDefinition, $fallbackToDefaultTemplate);
  307.     }
  309.     /**
  310.      * Restore the previous stored template definition, if one exists.
  311.      */
  312.     public function popTemplateDefinition(): void
  313.     {
  314.         if (\count($this->tplStack) > 0) {
  315.             [$templateDefinition, $fallbackToDefaultTemplate] = array_pop($this->tplStack);
  317.             $this->setTemplateDefinition($templateDefinition, $fallbackToDefaultTemplate);
  318.         }
  319.     }
  321.     /**
  322.      * Configure the parser to use the template defined by $templateDefinition.
  323.      *
  324.      * @param bool $fallbackToDefaultTemplate if true, resources will be also searched in the "default" template
  325.      */
  326.     public function setTemplateDefinition(TemplateDefinition $templateDefinition, $fallbackToDefaultTemplate = false): void
  327.     {
  328.         $this->templateDefinition = $templateDefinition;
  330.         $this->fallbackToDefaultTemplate = $fallbackToDefaultTemplate;
  332.         // Clear the current Smarty template path list
  333.         $this->setTemplateDir([]);
  335.         // -------------------------------------------------------------------------------------------------------------
  336.         // Add current template and its parent to the registered template list
  337.         // using "*template-assets" keys.
  338.         // -------------------------------------------------------------------------------------------------------------
  340.         $templateList = ['' => $templateDefinition] + $templateDefinition->getParentList();
  342.         /** @var TemplateDefinition $template */
  343.         foreach (array_reverse($templateList) as $template) {
  344.             // Add template directories  in the current template, in order to get assets
  345.             $this->addTemplateDirectory(
  346.                 $templateDefinition->getType(),
  347.                 $template->getName(), // $templateDefinition->getName(), // We add the template definition in the main template directory
  348.                 $template->getAbsolutePath(),
  349.                 self::TEMPLATE_ASSETS_KEY, // $templateKey,
  350.                 true
  351.             );
  352.         }
  354.         // -------------------------------------------------------------------------------------------------------------
  355.         // Add template and its parent pathes to the Smarty template path list
  356.         // using "*template-assets" keys.
  357.         // -------------------------------------------------------------------------------------------------------------
  359.         /**
  360.          * @var string             $keyPrefix
  361.          * @var TemplateDefinition $template
  362.          */
  363.         foreach ($templateList as $keyPrefix => $template) {
  364.             $templateKey = $keyPrefix.self::TEMPLATE_ASSETS_KEY;
  366.             // Add the template directory to the Smarty search path
  367.             $this->addTemplateDir($template->getAbsolutePath(), $templateKey);
  369.             // Also add the configuration directory
  370.             $this->addConfigDir(
  371.                 $template->getAbsolutePath().DS.'configs',
  372.                 $templateKey
  373.             );
  374.         }
  376.         // -------------------------------------------------------------------------------------------------------------
  377.         // Add all modules template directories foreach of the template list to the Smarty search path.
  378.         // -------------------------------------------------------------------------------------------------------------
  380.         $type = $templateDefinition->getType();
  382.         foreach ($templateList as $keyPrefix => $template) {
  383.             if (isset($this->templateDirectories[$type][$template->getName()])) {
  384.                 foreach ($this->templateDirectories[$type][$template->getName()] as $key => $directory) {
  385.                     if (null === $this->getTemplateDir($key)) {
  386.                         $this->addTemplateDir($directory, $key);
  387.                         $this->addConfigDir($directory.DS.'configs', $key);
  388.                     }
  389.                 }
  390.             }
  391.         }
  393.         // -------------------------------------------------------------------------------------------------------------
  394.         // Add the "default" modules template directories if we have to fallback to "default"
  395.         // -------------------------------------------------------------------------------------------------------------
  397.         if ($fallbackToDefaultTemplate) {
  398.             if (isset($this->templateDirectories[$type]['default'])) {
  399.                 foreach ($this->templateDirectories[$type]['default'] as $key => $directory) {
  400.                     if (null === $this->getTemplateDir($key)) {
  401.                         $this->addTemplateDir($directory, $key);
  402.                         $this->addConfigDir($directory.DS.'configs', $key);
  403.                     }
  404.                 }
  405.             }
  406.         }
  407.     }
  409.     /**
  410.      * Get template definition.
  411.      *
  412.      * @param bool|string $webAssetTemplateName false to use the current template path, or a template name to
  413.      *                                          load assets from this template instead of the current one
  414.      *
  415.      * @return TemplateDefinition
  416.      */
  417.     public function getTemplateDefinition($webAssetTemplateName = false)
  418.     {
  419.         // Deep clone of template definition. We could change the template descriptor of template definition,
  420.         // and we don't want to change the current template definition.
  422.         /** @var TemplateDefinition $ret */
  423.         $ret = unserialize(serialize($this->templateDefinition));
  425.         if (false !== $webAssetTemplateName) {
  426.             $customPath = str_replace($ret->getName(), $webAssetTemplateName, $ret->getPath());
  427.             $ret->setName($webAssetTemplateName);
  428.             $ret->setPath($customPath);
  429.         }
  431.         return $ret;
  432.     }
  434.     /**
  435.      * Check if template definition is not null.
  436.      *
  437.      * @return bool
  438.      */
  439.     public function hasTemplateDefinition()
  440.     {
  441.         return $this->templateDefinition !== null;
  442.     }
  444.     /**
  445.      * Get the current status of the fallback to "default" feature.
  446.      *
  447.      * @return bool
  448.      */
  449.     public function getFallbackToDefaultTemplate()
  450.     {
  451.         return $this->fallbackToDefaultTemplate;
  452.     }
  454.     /**
  455.      * @return string the template path
  456.      */
  457.     public function getTemplatePath()
  458.     {
  459.         return $this->templateDefinition->getPath();
  460.     }
  462.     /**
  463.      * Return a rendered template, either from file or from a string.
  464.      *
  465.      * @param string $resourceType    either 'string' (rendering from a string) or 'file' (rendering a file)
  466.      * @param string $resourceContent the resource content (a text, or a template file name)
  467.      * @param array  $parameters      an associative array of names / value pairs
  468.      * @param bool   $compressOutput  if true, te output is compressed using trimWhitespaces. If false, no compression occurs
  469.      *
  470.      * @throws \Exception
  471.      * @throws \SmartyException
  472.      *
  473.      * @return string the rendered template text
  474.      */
  475.     protected function internalRenderer($resourceType, $resourceContent, array $parameters, $compressOutput = true)
  476.     {
  477.         // If we have to diable the output compression, just unregister the output filter temporarly
  478.         if ($compressOutput == false) {
  479.             $this->unregisterFilter('output', [$this, 'trimWhitespaces']);
  480.         }
  482.         // Prepare common template variables
  483.         /** @var Session $session */
  484.         $session = $this->getRequest()->getSession();
  486.         $lang = $session ? $session->getLang() : Lang::getDefaultLanguage();
  488.         $parameters = array_merge($parameters, [
  489.             'locale' => $lang->getLocale(),
  490.             'lang_code' => $lang->getCode(),
  491.             'lang_id' => $lang->getId(),
  492.             'current_url' => $this->getRequest()->getUri(),
  493.             'app' => (object) [
  494.                 'environment' => $this->env,
  495.                 'request' => $this->getRequest(),
  496.                 'session' => $session,
  497.                 'debug' => $this->debug,
  498.             ],
  499.         ]);
  501.         // Assign the parserContext variables
  502.         foreach ($this->parserContext as $var => $value) {
  503.             $this->assign($var, $value);
  504.         }
  506.         $this->assign($parameters);
  508.         if (ConfigQuery::read('smarty_mute_undefined_or_null', 0)) {
  509.             $this->muteUndefinedOrNullWarnings();
  510.         }
  512.         $output = $this->fetch($resourceType.':'.$resourceContent);
  514.         if (!$compressOutput) {
  515.             $this->registerFilter('output', [$this, 'trimWhitespaces']);
  516.         }
  518.         return $output;
  519.     }
  521.     /**
  522.      * Return a rendered template file.
  523.      *
  524.      * @param string $realTemplateName the template name (from the template directory)
  525.      * @param array  $parameters       an associative array of names / value pairs
  526.      * @param bool   $compressOutput   if true, te output is compressed using trimWhitespaces. If false, no compression occurs
  527.      *
  528.      * @throws ResourceNotFoundException if the template cannot be found
  529.      * @throws \Exception
  530.      * @throws \SmartyException
  531.      *
  532.      * @return string the rendered template text
  533.      */
  534.     public function render($realTemplateName, array $parameters = [], $compressOutput = true)
  535.     {
  536.         if (false === $this->templateExists($realTemplateName) || false === $this->checkTemplate($realTemplateName)) {
  537.             throw new ResourceNotFoundException(Translator::getInstance()->trans('Template file %file cannot be found.', ['%file' => $realTemplateName]));
  538.         }
  540.         return $this->internalRenderer('file', $realTemplateName, $parameters, $compressOutput);
  541.     }
  543.     private function checkTemplate($fileName)
  544.     {
  545.         $templates = $this->getTemplateDir();
  547.         $found = true;
  549.         /* @noinspection PhpUnusedLocalVariableInspection */
  550.         foreach ($templates as $key => $value) {
  551.             $absolutePath = rtrim(realpath(\dirname($value.$fileName)), '/');
  552.             $templateDir = rtrim(realpath($value), '/');
  553.             if (!empty($absolutePath) && strpos($absolutePath, $templateDir) !== 0) {
  554.                 $found = false;
  555.             }
  556.         }
  558.         return $found;
  559.     }
  561.     /**
  562.      * Return a rendered template text.
  563.      *
  564.      * @param string $templateText   the template text
  565.      * @param array  $parameters     an associative array of names / value pairs
  566.      * @param bool   $compressOutput if true, te output is compressed using trimWhitespaces. If false, no compression occurs
  567.      *
  568.      * @throws \Exception
  569.      * @throws \SmartyException
  570.      *
  571.      * @return string the rendered template text
  572.      */
  573.     public function renderString($templateText, array $parameters = [], $compressOutput = true)
  574.     {
  575.         return $this->internalRenderer('string', $templateText, $parameters, $compressOutput);
  576.     }
  578.     /**
  579.      * @return int the status of the response
  580.      */
  581.     public function getStatus()
  582.     {
  583.         return $this->status;
  584.     }
  586.     /**
  587.      * status HTTP of the response.
  588.      *
  589.      * @param int $status
  590.      */
  591.     public function setStatus($status): void
  592.     {
  593.         $this->status = $status;
  594.     }
  596.     public function addPlugins(AbstractSmartyPlugin $plugin): void
  597.     {
  598.         $this->plugins[] = $plugin;
  599.     }
  601.     /**
  602.      * From Smarty 3.1.33, we cannot pass parameters by reference to plugin mehods, and declarations like the
  603.      * following will throw the error "Warning: Parameter 2 to <method> expected to be a reference, value given",
  604.      * because Smarty uses call_user_func_array() to call plugins methods.
  605.      *
  606.      *     public function categoryDataAccess($params, &$smarty)
  607.      *
  608.      * We use now a wrapper to provide compatibility with this declaration style
  609.      *
  610.      * @see AbstractSmartyPlugin::__call() for details
  611.      *
  612.      * @throws \SmartyException
  613.      */
  614.     public function registerPlugins(): void
  615.     {
  616.         /** @var AbstractSmartyPlugin $register_plugin */
  617.         foreach ($this->plugins as $register_plugin) {
  618.             $plugins = $register_plugin->getPluginDescriptors();
  620.             if (!\is_array($plugins)) {
  621.                 $plugins = [$plugins];
  622.             }
  624.             /** @var SmartyPluginDescriptor $plugin */
  625.             foreach ($plugins as $plugin) {
  626.                 // Use the wrapper to ensure Smarty 3.1.33 compatibility
  627.                 $methodName = $this->useMethodCallWrapper && $plugin->getType() === 'function' ?
  628.                     AbstractSmartyPlugin::WRAPPED_METHOD_PREFIX.$plugin->getMethod() :
  629.                     $plugin->getMethod()
  630.                 ;
  632.                 $this->registerPlugin(
  633.                     $plugin->getType(),
  634.                     $plugin->getName(),
  635.                     [
  636.                         $plugin->getClass(),
  637.                         $methodName,
  638.                     ]
  639.                 );
  640.             }
  641.         }
  642.     }
  644.     /**
  645.      * @return \Thelia\Core\Template\TemplateHelperInterface the parser template helper instance
  646.      */
  647.     public function getTemplateHelper()
  648.     {
  649.         return $this->templateHelper;
  650.     }
  651. }