src/Core/Renderer.php

   1 <?php
   2 /**
   3  * @copyright Copyright (C) 2010-2023, the Friendica project
   4  *
   5  * @license GNU AGPL version 3 or any later version
   6  *
   7  * This program is free software: you can redistribute it and/or modify
   8  * it under the terms of the GNU Affero General Public License as
   9  * published by the Free Software Foundation, either version 3 of the
  10  * License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU Affero General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Affero General Public License
  18  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  19  *
  20  */
  21
  22 namespace Friendica\Core;
  23
  24 use Exception;
  25 use Friendica\DI;
  26 use Friendica\Network\HTTPException\ServiceUnavailableException;
  27 use Friendica\Render\TemplateEngine;
  28
  29 /**
  30  * This class handles Renderer related functions.
  31  */
  32 class Renderer
  33 {
  34         /**
  35          * An array of registered template engines ('name'=>'class name')
  36          */
  37         public static $template_engines = [];
  38
  39         /**
  40          * An array of instanced template engines ('name'=>'instance')
  41          */
  42         public static $template_engine_instance = [];
  43
  44         /**
  45          * An array for all theme-controllable parameters
  46          *
  47          * Mostly unimplemented yet. Only options 'template_engine' and
  48          * beyond are used.
  49          */
  50         public static $theme = [
  51                 'videowidth'      => 425,
  52                 'videoheight'     => 350,
  53                 'stylesheet'      => '',
  54                 'template_engine' => 'smarty3',
  55         ];
  56
  57         private static $ldelim = [
  58                 'internal' => '',
  59                 'smarty3'  => '{{'
  60         ];
  61         private static $rdelim = [
  62                 'internal' => '',
  63                 'smarty3'  => '}}'
  64         ];
  65
  66         /**
  67          * Returns the rendered template output from the template string and variables
  68          *
  69          * @param string $template
  70          * @param array  $vars
  71          * @return string
  72          * @throws ServiceUnavailableException
  73          */
  74         public static function replaceMacros(string $template, array $vars = []): string
  75         {
  76                 DI::profiler()->startRecording('rendering');
  77
  78                 // pass $baseurl to all templates if it isn't set
  79                 $vars = array_merge(['$baseurl' => DI::baseUrl(), '$APP' => DI::app()], $vars);
  80
  81                 $t = self::getTemplateEngine();
  82
  83                 try {
  84                         $output = $t->replaceMacros($template, $vars);
  85                 } catch (Exception $e) {
  86                         DI::logger()->critical($e->getMessage(), ['template' => $template, 'vars' => $vars]);
  87                         $message = DI::app()->isSiteAdmin() ?
  88                                 $e->getMessage() :
  89                                 DI::l10n()->t('Friendica can\'t display this page at the moment, please contact the administrator.');
  90                         throw new ServiceUnavailableException($message);
  91                 }
  92
  93                 DI::profiler()->stopRecording();
  94
  95                 return $output;
  96         }
  97
  98         /**
  99          * Load a given template $s
 100          *
 101          * @param string $file   Template to load.
 102          * @param string $subDir Subdirectory (Optional)
 103          *
 104          * @return string Template
 105          * @throws ServiceUnavailableException
 106          */
 107         public static function getMarkupTemplate(string $file, string $subDir = ''): string
 108         {
 109                 DI::profiler()->startRecording('file');
 110                 $t = self::getTemplateEngine();
 111
 112                 try {
 113                         $template = $t->getTemplateFile($file, $subDir);
 114                 } catch (Exception $e) {
 115                         DI::logger()->critical($e->getMessage(), ['file' => $file, 'subDir' => $subDir]);
 116                         $message = DI::app()->isSiteAdmin() ?
 117                                 $e->getMessage() :
 118                                 DI::l10n()->t('Friendica can\'t display this page at the moment, please contact the administrator.');
 119                         throw new ServiceUnavailableException($message);
 120                 }
 121
 122                 DI::profiler()->stopRecording();
 123
 124                 return $template;
 125         }
 126
 127         /**
 128          * Register template engine class
 129          *
 130          * @param string $class
 131          *
 132          * @return void
 133          * @throws ServiceUnavailableException
 134          */
 135         public static function registerTemplateEngine(string $class)
 136         {
 137                 $v = get_class_vars($class);
 138
 139                 if (!empty($v['name'])) {
 140                         $name = $v['name'];
 141                         self::$template_engines[$name] = $class;
 142                 } else {
 143                         $admin_message = DI::l10n()->t('template engine cannot be registered without a name.');
 144                         DI::logger()->critical($admin_message, ['class' => $class]);
 145                         $message = DI::app()->isSiteAdmin() ?
 146                                 $admin_message :
 147                                 DI::l10n()->t('Friendica can\'t display this page at the moment, please contact the administrator.');
 148                         throw new ServiceUnavailableException($message);
 149                 }
 150         }
 151
 152         /**
 153          * Return template engine instance.
 154          *
 155          * If $name is not defined, return engine defined by theme,
 156          * or default
 157          *
 158          * @return TemplateEngine Template Engine instance
 159          * @throws ServiceUnavailableException
 160          */
 161         public static function getTemplateEngine(): TemplateEngine
 162         {
 163                 $template_engine = (self::$theme['template_engine'] ?? '') ?: 'smarty3';
 164
 165                 if (isset(self::$template_engines[$template_engine])) {
 166                         if (isset(self::$template_engine_instance[$template_engine])) {
 167                                 return self::$template_engine_instance[$template_engine];
 168                         } else {
 169                                 $a = DI::app();
 170                                 $class = self::$template_engines[$template_engine];
 171                                 $obj = new $class($a->getCurrentTheme(), $a->getThemeInfo());
 172                                 self::$template_engine_instance[$template_engine] = $obj;
 173                                 return $obj;
 174                         }
 175                 }
 176
 177                 $admin_message = DI::l10n()->t('template engine is not registered!');
 178                 DI::logger()->critical($admin_message, ['template_engine' => $template_engine]);
 179                 $message = DI::app()->isSiteAdmin() ?
 180                         $admin_message :
 181                         DI::l10n()->t('Friendica can\'t display this page at the moment, please contact the administrator.');
 182                 throw new ServiceUnavailableException($message);
 183         }
 184
 185         /**
 186          * Returns the active template engine.
 187          *
 188          * @return string the active template engine
 189          */
 190         public static function getActiveTemplateEngine(): string
 191         {
 192                 return self::$theme['template_engine'];
 193         }
 194
 195         /**
 196          * sets the active template engine
 197          *
 198          * @param string $engine the template engine (default is Smarty3)
 199          *
 200          * @return void
 201          */
 202         public static function setActiveTemplateEngine(string $engine = 'smarty3')
 203         {
 204                 self::$theme['template_engine'] = $engine;
 205         }
 206
 207         /**
 208          * Gets the right delimiter for a template engine
 209          *
 210          * Currently:
 211          * Internal = ''
 212          * Smarty3 = '{{'
 213          *
 214          * @param string $engine The template engine (default is Smarty3)
 215          *
 216          * @return string the right delimiter
 217          */
 218         public static function getTemplateLeftDelimiter(string $engine = 'smarty3'): string
 219         {
 220                 return self::$ldelim[$engine];
 221         }
 222
 223         /**
 224          * Gets the left delimiter for a template engine
 225          *
 226          * Currently:
 227          * Internal = ''
 228          * Smarty3 = '}}'
 229          *
 230          * @param string $engine The template engine (default is Smarty3)
 231          *
 232          * @return string the left delimiter
 233          */
 234         public static function getTemplateRightDelimiter(string $engine = 'smarty3'): string
 235         {
 236                 return self::$rdelim[$engine];
 237         }
 238 }