src/Core/Header.php

   1 <?php
   2 /**
   3  * OpenEMR <https://open-emr.org>.
   4  *
   5  * @license https://github.com/openemr/openemr/blob/master/LICENSE GNU General Public License 3
   6  */
   7
   8 namespace OpenEMR\Core;
   9
  10 use Symfony\Component\Yaml\Yaml;
  11 use Symfony\Component\Yaml\Exception\ParseException;
  12
  13 /**
  14  * Class Header.
  15  *
  16  * Helper class to generate some `<script>` and `<link>` elements based on a
  17  * configuration file. This file would be a good place to include other helpers
  18  * for creating a `<head>` element, but for now it sufficently handles the
  19  * `setupHeader()`
  20  *
  21  * @package OpenEMR
  22  * @subpackage Core
  23  * @author Robert Down <robertdown@live.com>
  24  * @copyright Copyright (c) 2017 Robert Down
  25  */
  26 class Header
  27 {
  28     private static $scripts;
  29     private static $links;
  30
  31     /**
  32      * Setup various <head> elements.
  33      *
  34      * See root_dir/config/config.yaml for available assets
  35      *
  36      * Example usage in a PHP view script:
  37      * ```php
  38      * // Top of script with require_once statements
  39      * use OpenEMR\Core\Header;
  40      *
  41      * // Inside of <head>
  42      * // If no special assets are needed:
  43      * Header::setupHeader();
  44      *
  45      * // If 1 special asset is needed:
  46      * Header::setupHeader('key-of-asset');
  47      *
  48      * // If 2 or more assets are needed:
  49      * Header::setupHeader(['array', 'of', 'keys']);
  50      *
  51      * // If wish to not include a normally autoloaded asset
  52      * Header::setupHeader('no_main-theme');
  53      * ```
  54      *
  55      * Inside of a smarty template, use | (pipe) delimited string of key names
  56      * ```php
  57      * {headerTemplate}
  58      * {headerTemplate assets='key-of-asset'}  (1 optional assets)
  59      * {headerTemplate assets='array|of|keys'}  (multiple optional assets. ie. via | delimiter)
  60      * ```
  61      *
  62      * The above example will render `<script>` tags and `<link>` tag which
  63      * bring in the requested assets from config.yaml
  64      *
  65      * @param array|string $assets Asset(s) to include
  66      * @throws ParseException If unable to parse the config file
  67      * @return string
  68      */
  69     public static function setupHeader($assets = [])
  70     {
  71         try {
  72             echo self::includeAsset($assets);
  73         } catch (\InvalidArgumentException $e) {
  74             error_log(errorLogEscape($e->getMessage()));
  75         }
  76     }
  77
  78     /**
  79      * Include an asset from a config file.
  80      *
  81      * Static function to read in a YAML file into an array, check if the
  82      * $assets keys are in the config file, and from the config file generate
  83      * the HTML for a `<script>` or `<link>` tag.
  84      *
  85      * This is a private function, use Header::setupHeader() instead
  86      *
  87      * @param array|string $assets Asset(s) to include
  88      * @throws ParseException If unable to parse the config file
  89      * @return string
  90      */
  91     private static function includeAsset($assets = [])
  92     {
  93
  94         if (is_string($assets)) {
  95             $assets = [$assets];
  96         }
  97
  98         // @TODO Hard coded the path to the config file, not good RD 2017-05-27
  99         $map = self::readConfigFile("{$GLOBALS['fileroot']}/config/config.yaml");
 100         self::$scripts = [];
 101         self::$links = [];
 102
 103         self::parseConfigFile($map, $assets);
 104
 105         /* adding custom assets in addition */
 106         if (is_file("{$GLOBALS['fileroot']}/custom/assets/custom.yaml")) {
 107             $customMap = self::readConfigFile("{$GLOBALS['fileroot']}/custom/assets/custom.yaml");
 108             self::parseConfigFile($customMap);
 109         }
 110
 111         $linksStr = implode("", self::$links);
 112         $scriptsStr = implode("", self::$scripts);
 113         return "\n{$linksStr}\n{$scriptsStr}\n";
 114     }
 115
 116     /**
 117      * Parse assets from config file
 118      *
 119      * @param array $map Assets to parse into self::$scripts and self::$links
 120      * @param array $selectedAssets
 121      * @return void
 122      */
 123     private static function parseConfigFile($map, $selectedAssets = array())
 124     {
 125         foreach ($map as $k => $opts) {
 126             $autoload = (isset($opts['autoload'])) ? $opts['autoload'] : false;
 127             $allowNoLoad= (isset($opts['allowNoLoad'])) ? $opts['allowNoLoad'] : false;
 128             $alreadyBuilt = (isset($opts['alreadyBuilt'])) ? $opts['alreadyBuilt'] : false;
 129             $loadInFile = (isset($opts['loadInFile'])) ? $opts['loadInFile'] : false;
 130             $rtl = (isset($opts['rtl'])) ? $opts['rtl'] : false;
 131
 132             if ($autoload === true || in_array($k, $selectedAssets) || ($loadInFile && $loadInFile === self::getCurrentFile())) {
 133                 if ($allowNoLoad === true) {
 134                     if (in_array("no_" . $k, $selectedAssets)) {
 135                         continue;
 136                     }
 137                 }
 138
 139                 $tmp = self::buildAsset($opts, $alreadyBuilt);
 140
 141                 foreach ($tmp['scripts'] as $s) {
 142                     self::$scripts[] = $s;
 143                 }
 144
 145                 foreach ($tmp['links'] as $l) {
 146                     self::$links[] = $l;
 147                 }
 148
 149                 if ($rtl && $_SESSION['language_direction'] == 'rtl') {
 150                     $tmpRtl = self::buildAsset($rtl, $alreadyBuilt);
 151                     foreach ($tmpRtl['scripts'] as $s) {
 152                         self::$scripts[] = $s;
 153                     }
 154
 155                     foreach ($tmpRtl['links'] as $l) {
 156                         self::$links[] = $l;
 157                     }
 158                 }
 159             }
 160         }
 161     }
 162
 163     /**
 164      * Build an html element from config options.
 165      *
 166      * @var array $opts Options
 167      * @var boolean $alreadyBuilt - This means the path with cache busting segment has already been built
 168      * @return array Array with `scripts` and `links` keys which contain arrays of elements
 169      */
 170     private static function buildAsset($opts = array(), $alreadyBuilt = false)
 171     {
 172         $script = (isset($opts['script'])) ? $opts['script'] : false;
 173         $link = (isset($opts['link'])) ? $opts['link'] : false;
 174         $path = (isset($opts['basePath'])) ? $opts['basePath'] : '';
 175         $basePath = self::parsePlaceholders($path);
 176
 177         $scripts = [];
 178         $links = [];
 179
 180         if ($script) {
 181             $script = self::parsePlaceholders($script);
 182             if ($alreadyBuilt) {
 183                 $path = $script;
 184             } else {
 185                 $path = self::createFullPath($basePath, $script);
 186             }
 187             $scripts[] = self::createElement($path, 'script', $alreadyBuilt);
 188         }
 189
 190         if ($link) {
 191             if (!is_string($link) && !is_array($link)) {
 192                 throw new \InvalidArgumentException("Link must be of type string or array");
 193             }
 194
 195             if (is_string($link)) {
 196                 $link = [$link];
 197             }
 198
 199             foreach ($link as $l) {
 200                 $l = self::parsePlaceholders($l);
 201                 if ($alreadyBuilt) {
 202                     $path = $l;
 203                 } else {
 204                     $path = self::createFullPath($basePath, $l);
 205                 }
 206                 $links[] = self::createElement($path, 'link', $alreadyBuilt);
 207             }
 208         }
 209
 210         return ['scripts' => $scripts, 'links' => $links];
 211     }
 212
 213     /**
 214      * Parse a string for $GLOBAL key placeholders %key-name%.
 215      *
 216      * Perform a regex match all in the given subject for anything wrapped in
 217      * percent signs `%some-key%` and if that string exists in the $GLOBALS
 218      * array, will replace the occurence with the value of that key.
 219      *
 220      * @param string $subject String containing placeholders (%key-name%)
 221      * @return string The new string with properly replaced keys
 222      */
 223     public static function parsePlaceholders($subject)
 224     {
 225         $re = '/%(.*)%/';
 226         $matches = [];
 227         preg_match_all($re, $subject, $matches, PREG_SET_ORDER, 0);
 228
 229         foreach ($matches as $match) {
 230             if (array_key_exists($match[1], $GLOBALS)) {
 231                 $subject = str_replace($match[0], $GLOBALS["{$match[1]}"], $subject);
 232             }
 233         }
 234
 235         return $subject;
 236     }
 237
 238     /**
 239      * Create the actual HTML element.
 240      *
 241      * @param string $path File path to load
 242      * @param string $type Must be `script` or `link`
 243      * @return string mixed HTML element
 244      */
 245     private static function createElement($path, $type, $alreadyBuilt)
 246     {
 247
 248         $script = "<script type=\"text/javascript\" src=\"%path%\"></script>\n";
 249         $link = "<link rel=\"stylesheet\" href=\"%path%\" type=\"text/css\">\n";
 250
 251         $template = ($type == 'script') ? $script : $link;
 252         if (!$alreadyBuilt) {
 253             $v = $GLOBALS['v_js_includes'];
 254             $path = $path . "?v={$v}";
 255         }
 256         return str_replace("%path%", $path, $template);
 257     }
 258
 259     /**
 260      * Create a full path from given parts.
 261      *
 262      * @param string $base Base path
 263      * @param string $path specific path / filename
 264      * @return string The full path
 265      */
 266     private static function createFullPath($base, $path)
 267     {
 268         return $base . $path;
 269     }
 270
 271     /**
 272      * Read a config file and turn it into an array.
 273      *
 274      * @param string $file Full path to filename
 275      * @return array Array of assets
 276      */
 277     private static function readConfigFile($file)
 278     {
 279         try {
 280             $config = Yaml::parse(file_get_contents($file));
 281             return $config['assets'];
 282         } catch (ParseException $e) {
 283             error_log(errorLogEscape($e->getMessage()));
 284             // @TODO need to handle this better. RD 2017-05-24
 285         }
 286     }
 287
 288     /**
 289      * Return relative path to current file
 290      *
 291      * @return string The  current file
 292      */
 293     private static function getCurrentFile()
 294     {
 295         //remove web root and query string
 296         return str_replace($GLOBALS['webroot'].'/', '', strtok($_SERVER["REQUEST_URI"], '?'));
 297     }
 298 }