PKPTemplateManager.inc.php

<?php
 
/* This definition is required by Smarty */
define('SMARTY_DIR', Core::getBaseDir() . '/lib/pkp/lib/vendor/smarty/smarty/libs/');
 
require_once('./lib/pkp/lib/vendor/smarty/smarty/libs/plugins/modifier.escape.php'); // Seems to be needed?
 
define('CACHEABILITY_NO_CACHE',     'no-cache');
define('CACHEABILITY_NO_STORE',     'no-store');
define('CACHEABILITY_PUBLIC',    'public');
define('CACHEABILITY_MUST_REVALIDATE', 'must-revalidate');
define('CACHEABILITY_PROXY_REVALIDATE',   'proxy-revalidate');
 
define('STYLE_SEQUENCE_CORE', 0);
define('STYLE_SEQUENCE_NORMAL', 10);
define('STYLE_SEQUENCE_LATE', 15);
define('STYLE_SEQUENCE_LAST', 20);
 
define('CDN_JQUERY_VERSION', '3.3.1');
define('CDN_JQUERY_UI_VERSION', '1.12.0');
 
define('CSS_FILENAME_SUFFIX', 'css');
 
define('PAGE_WIDTH_NARROW', 'narrow');
define('PAGE_WIDTH_NORMAL', 'normal');
define('PAGE_WIDTH_WIDE', 'wide');
define('PAGE_WIDTH_FULL', 'full');
 
import('lib.pkp.classes.template.PKPTemplateResource');
 
class PKPTemplateManager extends Smarty {
   private $_styleSheets = [];
 
   private $_javaScripts = [];
 
   private $_htmlHeaders = [];
 
   private $_constants = [];
 
   private $_localeKeys = [];
 
   private $_state = [];
 
   private $_cacheability;
 
   private $_fbv;
 
   private $_request;
 
   function __construct() {
      parent::__construct();
 
      // Set up Smarty configuration
      $baseDir = Core::getBaseDir();
      $cachePath = CacheManager::getFileCachePath();
 
      $this->compile_dir = $cachePath . DIRECTORY_SEPARATOR . 't_compile';
      $this->config_dir = $cachePath . DIRECTORY_SEPARATOR . 't_config';
      $this->cache_dir = $cachePath . DIRECTORY_SEPARATOR . 't_cache';
 
      $this->_cacheability = CACHEABILITY_NO_STORE; // Safe default
 
      // Register the template resources.
      $this->registerResource('core', new PKPTemplateResource($coreTemplateDir = 'lib' . DIRECTORY_SEPARATOR . 'pkp' . DIRECTORY_SEPARATOR . 'templates'));
      $this->registerResource('app', new PKPTemplateResource(['templates', $coreTemplateDir]));
      $this->default_resource_type = 'app';
 
      $this->error_reporting = E_ALL & ~E_NOTICE;
   }
 
   function initialize($request) {
      assert(is_a($request, 'PKPRequest'));
      $this->_request = $request;
 
      $locale = AppLocale::getLocale();
      $application = Application::get();
      $router = $request->getRouter();
      assert(is_a($router, 'PKPRouter'));
 
      AppLocale::requireComponents(LOCALE_COMPONENT_APP_COMMON, LOCALE_COMPONENT_PKP_COMMON);
      $currentContext = $request->getContext();
 
      $this->assign([
         'defaultCharset' => Config::getVar('i18n', 'client_charset'),
         'baseUrl' => $request->getBaseUrl(),
         'currentContext' => $currentContext,
         'currentLocale' => $locale,
         'currentLocaleLangDir' => AppLocale::getLocaleDirection($locale),
         'applicationName' => __($application->getNameKey()),
      ]);
 
      // Assign date and time format
      if ($currentContext) {
         $this->assign(array(
            'dateFormatShort' => $currentContext->getLocalizedDateFormatShort(),
            'dateFormatLong' => $currentContext->getLocalizedDateFormatLong(),
            'datetimeFormatShort' => $currentContext->getLocalizedDateTimeFormatShort(),
            'datetimeFormatLong' => $currentContext->getLocalizedDateTimeFormatLong(),
            'timeFormat' => $currentContext->getLocalizedTimeFormat(),
         ));
      } else {
         $this->assign(array(
            'dateFormatShort' => Config::getVar('general', 'date_format_short'),
            'dateFormatLong' => Config::getVar('general', 'date_format_long'),
            'datetimeFormatShort' => Config::getVar('general', 'datetime_format_short'),
            'datetimeFormatLong' => Config::getVar('general', 'datetime_format_long'),
            'timeFormat' => Config::getVar('general', 'time_format'),
         ));
      }
 
      // Assign meta tags
      if ($currentContext) {
         $favicon = $currentContext->getLocalizedFavicon();
         if (!empty($favicon)) {
            $publicFileManager = new PublicFileManager();
            $faviconDir = $request->getBaseUrl() . '/' . $publicFileManager->getContextFilesPath($currentContext->getId());
            $this->addHeader('favicon', '<link rel="icon" href="' . $faviconDir . '/' . $favicon['uploadName'] . '">');
         }
      }
 
      if (Config::getVar('general', 'installed')) {
         $activeTheme = null;
         $contextOrSite = $currentContext ? $currentContext : $request->getSite();
         $allThemes = PluginRegistry::getPlugins('themes');
         foreach ($allThemes as $theme) {
            if ($contextOrSite->getData('themePluginPath') === $theme->getDirName()) {
               $activeTheme = $theme;
               break;
            }
         }
         $this->assign(['activeTheme' => $activeTheme]);
      }
 
      if (is_a($router, 'PKPPageRouter')) {
         $this->assign([
            'requestedPage' => $router->getRequestedPage($request),
            'requestedOp' => $router->getRequestedOp($request),
         ]);
 
         // A user-uploaded stylesheet
         if ($currentContext) {
            $contextStyleSheet = $currentContext->getData('styleSheet');
            if ($contextStyleSheet) {
               import('classes.file.PublicFileManager');
               $publicFileManager = new PublicFileManager();
               $this->addStyleSheet(
                  'contextStylesheet',
                  $request->getBaseUrl() . '/' . $publicFileManager->getContextFilesPath($currentContext->getId()) . '/' . $contextStyleSheet['uploadName'],
                  ['priority' => STYLE_SEQUENCE_LATE]
               );
            }
         }
 
         // Register recaptcha on relevant pages
         if (Config::getVar('captcha', 'recaptcha') && Config::getVar('captcha', 'captcha_on_register')) {
            $this->addJavaScript(
               'recaptcha',
               'https://www.recaptcha.net/recaptcha/api.js?hl=' . substr(AppLocale::getLocale(),0,2),
               [
                  'contexts' => ['frontend-user-register', 'frontend-user-registerUser'],
               ]
            );
         }
 
         // Register meta tags
         if (Config::getVar('general', 'installed')) {
            if (($request->getRequestedPage()=='' || $request->getRequestedPage() == 'index') && $currentContext && $currentContext->getLocalizedData('searchDescription')) {
               $this->addHeader('searchDescription', '<meta name="description" content="' . $currentContext->getLocalizedData('searchDescription') . '">');
            }
 
            $this->addHeader(
               'generator',
               '<meta name="generator" content="' . __($application->getNameKey()) . ' ' . $application->getCurrentVersion()->getVersionString(false) . '">',
               [
                  'contexts' => ['frontend', 'backend'],
               ]
            );
 
            if ($currentContext) {
               $customHeaders = $currentContext->getLocalizedData('customHeaders');
               if (!empty($customHeaders)) {
                  $this->addHeader('customHeaders', $customHeaders);
               }
            }
         }
 
         if ($currentContext && !$currentContext->getEnabled()) {
            $this->addHeader(
               'noindex',
               '<meta name="robots" content="noindex,nofollow">',
               [
                  'contexts' => ['frontend', 'backend'],
               ]
            );
         }
 
         // Register Navigation Menus
         import('classes.core.Services');
         $nmService = Services::get('navigationMenu');
 
         if (Config::getVar('general', 'installed')) {
            \HookRegistry::register('LoadHandler', [$nmService, '_callbackHandleCustomNavigationMenuItems']);
         }
      }
 
      // Register custom functions
      $this->registerPlugin('modifier', 'translate', 'AppLocale::translate');
      $this->registerPlugin('modifier','strip_unsafe_html', 'PKPString::stripUnsafeHtml');
      $this->registerPlugin('modifier','String_substr', 'PKPString::substr');
      $this->registerPlugin('modifier','dateformatPHP2JQueryDatepicker', 'PKPString::dateformatPHP2JQueryDatepicker');
      $this->registerPlugin('modifier','to_array', [$this, 'smartyToArray']);
      $this->registerPlugin('modifier','compare', [$this, 'smartyCompare']);
      $this->registerPlugin('modifier','concat', [$this, 'smartyConcat']);
      $this->registerPlugin('modifier','strtotime', [$this, 'smartyStrtotime']);
      $this->registerPlugin('modifier','explode', [$this, 'smartyExplode']);
      $this->registerPlugin('modifier','escape', [$this, 'smartyEscape']);
      $this->registerPlugin('function','csrf', [$this, 'smartyCSRF']);
      $this->registerPlugin('function', 'translate', [$this, 'smartyTranslate']);
      $this->registerPlugin('function','null_link_action', [$this, 'smartyNullLinkAction']);
      $this->registerPlugin('function','help', [$this, 'smartyHelp']);
      $this->registerPlugin('function','flush', [$this, 'smartyFlush']);
      $this->registerPlugin('function','call_hook', [$this, 'smartyCallHook']);
      $this->registerPlugin('function','html_options_translate', [$this, 'smartyHtmlOptionsTranslate']);
      $this->registerPlugin('block','iterate', [$this, 'smartyIterate']);
      $this->registerPlugin('function','page_links', [$this, 'smartyPageLinks']);
      $this->registerPlugin('function','page_info', [$this, 'smartyPageInfo']);
      $this->registerPlugin('function','pluck_files', [$this, 'smartyPluckFiles']);
 
      $this->registerPlugin('function','title', [$this, 'smartyTitle']);
      $this->registerPlugin('function', 'url', [$this, 'smartyUrl']);
 
      // load stylesheets/scripts/headers from a given context
      $this->registerPlugin('function', 'load_stylesheet', [$this, 'smartyLoadStylesheet']);
      $this->registerPlugin('function', 'load_script', [$this, 'smartyLoadScript']);
      $this->registerPlugin('function', 'load_header', [$this, 'smartyLoadHeader']);
 
      // load NavigationMenu Areas from context
      $this->registerPlugin('function', 'load_menu', [$this, 'smartyLoadNavigationMenuArea']);
 
      // Load form builder vocabulary
      $fbv = $this->getFBV();
      $this->registerPlugin('block', 'fbvFormSection', [$fbv, 'smartyFBVFormSection']);
      $this->registerPlugin('block', 'fbvFormArea', [$fbv, 'smartyFBVFormArea']);
      $this->registerPlugin('function', 'fbvFormButtons', [$fbv, 'smartyFBVFormButtons']);
      $this->registerPlugin('function', 'fbvElement', [$fbv, 'smartyFBVElement']);
      $this->registerPlugin('function', 'fieldLabel', [$fbv, 'smartyFieldLabel']);
      $this->assign('fbvStyles', $fbv->getStyles());
 
      // ajax load into a div or any element
      $this->registerPlugin('function', 'load_url_in_el', [$this, 'smartyLoadUrlInEl']);
      $this->registerPlugin('function', 'load_url_in_div', [$this, 'smartyLoadUrlInDiv']);
 
      // Always pass these ListBuilder constants to the browser
      // because a ListBuilder may be loaded in an ajax request
      // and won't have an opportunity to pass its constants to
      // the template manager. This is not a recommended practice,
      // but these are the only constants from a controller that are
      // required on the frontend. We can remove them once the
      // ListBuilderHandler is no longer needed.
      import('lib.pkp.classes.controllers.listbuilder.ListbuilderHandler');
      $this->setConstants([
         'LISTBUILDER_SOURCE_TYPE_TEXT',
         'LISTBUILDER_SOURCE_TYPE_SELECT',
         'LISTBUILDER_OPTGROUP_LABEL',
      ]);
 
      if (!defined('SESSION_DISABLE_INIT')) {
         $this->assign([
            'isUserLoggedIn' => Validation::isLoggedIn(),
            'isUserLoggedInAs' => Validation::isLoggedInAs(),
            'itemsPerPage' => Config::getVar('interface', 'items_per_page'),
            'numPageLinks' => Config::getVar('interface', 'page_links'),
            'siteTitle' => $request->getSite()->getLocalizedData('title'),
         ]);
 
         $user = $request->getUser();
         if ($user) {
            $this->assign([
               'currentUser' => $user,
            ]);
 
            // Assign the user name to be used in the sitenav
            $this->assign([
               'loggedInUsername' => $user->getUserName(),
            ]);
         }
      }
 
      if (Config::getVar('general', 'installed')) {
         // Respond to the sidebar hook
         if ($currentContext) {
            $this->assign('hasSidebar', !empty($currentContext->getData('sidebar')));
         } else {
            $this->assign('hasSidebar', !empty($request->getSite()->getData('sidebar')));
         }
         HookRegistry::register('Templates::Common::Sidebar', [$this, 'displaySidebar']);
 
         // Clear the cache whenever the active theme is changed
         HookRegistry::register('Context::edit', [$this, 'clearThemeTemplateCache']);
         HookRegistry::register('Site::edit', [$this, 'clearThemeTemplateCache']);
      }
   }
 
 
   function setCacheability($cacheability = CACHEABILITY_PUBLIC) {
      $this->_cacheability = $cacheability;
   }
 
   public function compileLess($name, $lessFile, $args = []) {
      $less = new Less_Parser([
         'relativeUrls' => false,
         'compress' => true,
      ]);
 
      $request = $this->_request;
 
      // Allow plugins to intervene
      HookRegistry::call('PageHandler::compileLess', [&$less, &$lessFile, &$args, $name, $request]);
 
      // Read the stylesheet
      $less->parseFile($lessFile);
 
      // Add extra LESS files before compiling
      if (isset($args['addLess']) && is_array($args['addLess'])) {
         foreach ($args['addLess'] as $addless) {
            $less->parseFile($addless);
         }
      }
 
      // Add extra LESS variables before compiling
      if (isset($args['addLessVariables'])) {
         foreach ((array) $args['addLessVariables'] as $addlessVariables) {
            $less->parse($addlessVariables);
         }
      }
 
      // Set the @baseUrl variable
      $baseUrl = !empty($args['baseUrl']) ? $args['baseUrl'] : $request->getBaseUrl(true);
      $less->parse("@baseUrl: '$baseUrl';");
 
      return $less->getCSS();
   }
 
   public function cacheLess($path, $styles) {
      if (file_put_contents($path, $styles) === false) {
         error_log("Unable to write \"$path\".");
         return false;
      }
 
      return true;
   }
 
   public function getCachedLessFilePath($name) {
      $cacheDirectory = CacheManager::getFileCachePath();
      $context = $this->_request->getContext();
      $contextId = is_a($context, 'Context') ? $context->getId() : 0;
      return $cacheDirectory . DIRECTORY_SEPARATOR . $contextId . '-' . $name . '.css';
   }
 
   function addStyleSheet($name, $style, $args = []) {
 
      $args = array_merge(
         [
            'priority' => STYLE_SEQUENCE_NORMAL,
            'contexts' => ['frontend'],
            'inline'   => false,
         ],
         $args
      );
 
      $args['contexts'] = (array) $args['contexts'];
      foreach($args['contexts'] as $context) {
         $this->_styleSheets[$context][$args['priority']][$name] = [
            'style' => $style,
            'inline' => $args['inline'],
         ];
      }
   }
 
   function addJavaScript($name, $script, $args = []) {
 
      $args = array_merge(
         [
            'priority' => STYLE_SEQUENCE_NORMAL,
            'contexts' => ['frontend'],
            'inline'   => false,
         ],
         $args
      );
 
      $args['contexts'] = (array) $args['contexts'];
      foreach($args['contexts'] as $context) {
         $this->_javaScripts[$context][$args['priority']][$name] = [
            'script' => $script,
            'inline' => $args['inline'],
         ];
      }
   }
 
   function addHeader($name, $header, $args = []) {
 
      $args = array_merge(
         [
            'priority' => STYLE_SEQUENCE_NORMAL,
            'contexts' => ['frontend'],
         ],
         $args
      );
 
      $args['contexts'] = (array) $args['contexts'];
      foreach($args['contexts'] as $context) {
         $this->_htmlHeaders[$context][$args['priority']][$name] = [
            'header' => $header,
         ];
      }
   }
 
   function setConstants($names) {
      foreach ($names as $name) {
         $this->_constants[$name] = constant($name);
      }
   }
 
   function setLocaleKeys($keys) {
      foreach ($keys as $key) {
         if (!array_key_exists($key, $this->_localeKeys)) {
            $this->_localeKeys[$key] = __($key);
         }
      }
   }
 
   function getState($key) {
      return array_key_exists($key, $this->_state)
         ? $this->_state[$key]
         : null;
   }
 
   function setState($data) {
      $this->_state = array_merge($this->_state, $data);
   }
 
   function registerJSLibrary() {
      $baseUrl = $this->_request->getBaseUrl();
      $localeChecks = [AppLocale::getLocale(), strtolower(substr(AppLocale::getLocale(), 0, 2))];
 
      // Common $args array used for all our core JS files
      $args = [
         'priority' => STYLE_SEQUENCE_CORE,
         'contexts' => 'backend',
      ];
 
      // Load jQuery validate separately because it can not be linted
      // properly by our build script
      $this->addJavaScript(
         'jqueryValidate',
         $baseUrl . '/lib/pkp/js/lib/jquery/plugins/validate/jquery.validate.min.js',
         $args
      );
      $jqvLocalePath = 'lib/pkp/js/lib/jquery/plugins/validate/localization/messages_';
      foreach ($localeChecks as $localeCheck) {
         if (file_exists($jqvLocalePath . $localeCheck .'.js')) {
            $this->addJavaScript('jqueryValidateLocale', $baseUrl . '/' . $jqvLocalePath . $localeCheck . '.js', $args);
         }
      }
 
      $this->addJavaScript(
         'plUpload',
         $baseUrl . '/lib/pkp/lib/vendor/moxiecode/plupload/js/plupload.full.min.js',
         $args
      );
      $this->addJavaScript(
         'jQueryPlUpload',
         $baseUrl . '/lib/pkp/lib/vendor/moxiecode/plupload/js/jquery.ui.plupload/jquery.ui.plupload.js',
         $args
      );
      $plLocalePath = 'lib/pkp/lib/vendor/moxiecode/plupload/js/i18n/';
      foreach ($localeChecks as $localeCheck) {
         if (file_exists($plLocalePath . $localeCheck . '.js')) {
            $this->addJavaScript('plUploadLocale', $baseUrl . '/' . $plLocalePath . $localeCheck . '.js', $args);
         }
      }
 
      // Load new component library bundle
      $this->addJavaScript(
         'pkpApp',
         $baseUrl . '/js/build.js',
         [
            'priority' => STYLE_SEQUENCE_LATE,
            'contexts' => ['backend']
         ]
      );
 
      // Load minified file if it exists
      if (Config::getVar('general', 'enable_minified')) {
         $this->addJavaScript(
            'pkpLib',
            $baseUrl . '/js/pkp.min.js',
            [
               'priority' => STYLE_SEQUENCE_CORE,
               'contexts' => ['backend']
            ]
         );
         return;
      }
 
      // Otherwise retrieve and register all script files
      $minifiedScripts = array_filter(array_map('trim', file('registry/minifiedScripts.txt')), function($s) {
         return strlen($s) && $s[0] != '#'; // Exclude empty and commented (#) lines
      });
      foreach ($minifiedScripts as $key => $script) {
         $this->addJavaScript( 'pkpLib' . $key, "$baseUrl/$script", $args);
      }
   }
 
   function registerJSLibraryData() {
 
      $context = $this->_request->getContext();
 
      // Instantiate the namespace
      $output = '$.pkp = $.pkp || {};';
 
      // Load data intended for general use by the app
      import('lib.pkp.classes.security.Role');
 
      $app_data = [
         'cdnEnabled' => Config::getVar('general', 'enable_cdn'),
         'currentLocale' => AppLocale::getLocale(),
         'primaryLocale' => AppLocale::getPrimaryLocale(),
         'baseUrl' => $this->_request->getBaseUrl(),
         'contextPath' => isset($context) ? $context->getPath() : '',
         'apiBasePath' => '/api/v1',
         'pathInfoEnabled' => Config::getVar('general', 'disable_path_info') ? false : true,
         'restfulUrlsEnabled' => Config::getVar('general', 'restful_urls') ? true : false,
         'tinyMceContentCSS' => $this->_request->getBaseUrl() . '/plugins/generic/tinymce/styles/content.css',
         'tinyMceContentFont' => Config::getVar('general', 'enable_cdn') ? $this->_request->getBaseUrl() .  '/plugins/generic/tinymce/styles/content-font.css' : '',
      ];
 
      $output .= '$.pkp.app = ' . json_encode($app_data) . ';';
 
      // Load exposed constants
      $output .= '$.pkp.cons = ' . json_encode($this->_constants) . ';';
 
      // Allow plugins to load data within their own namespace
      $output .= '$.pkp.plugins = {};';
 
      $this->addJavaScript(
         'pkpLibData',
         $output,
         [
            'priority' => STYLE_SEQUENCE_CORE,
            'contexts' => 'backend',
            'inline'   => true,
         ]
      );
   }
 
   function setupBackendPage() {
 
      $request = Application::get()->getRequest();
      $dispatcher = $request->getDispatcher();
      $router = $request->getRouter();
 
      if (empty($this->get_template_vars('pageComponent'))) {
         $this->assign('pageComponent', 'Page');
      }
 
      $this->setConstants([
         'REALLY_BIG_NUMBER',
         'UPLOAD_MAX_FILESIZE',
         'WORKFLOW_STAGE_ID_PUBLISHED',
         'WORKFLOW_STAGE_ID_SUBMISSION',
         'WORKFLOW_STAGE_ID_INTERNAL_REVIEW',
         'WORKFLOW_STAGE_ID_EXTERNAL_REVIEW',
         'WORKFLOW_STAGE_ID_EDITING',
         'WORKFLOW_STAGE_ID_PRODUCTION',
         'INSERT_TAG_VARIABLE_TYPE_PLAIN_TEXT',
         'ROLE_ID_MANAGER',
         'ROLE_ID_SITE_ADMIN',
         'ROLE_ID_AUTHOR',
         'ROLE_ID_REVIEWER',
         'ROLE_ID_ASSISTANT',
         'ROLE_ID_READER',
         'ROLE_ID_SUB_EDITOR',
         'ROLE_ID_SUBSCRIPTION_MANAGER',
      ]);
 
      // Common locale keys available in the browser for every page
      $this->setLocaleKeys([
         'common.cancel',
         'common.clearSearch',
         'common.close',
         'common.commaListSeparator',
         'common.confirm',
         'common.delete',
         'common.edit',
         'common.error',
         'common.filter',
         'common.filterAdd',
         'common.filterRemove',
         'common.loading',
         'common.no',
         'common.noItemsFound',
         'common.none',
         'common.ok',
         'common.orderUp',
         'common.orderDown',
         'common.pageNumber',
         'common.pagination.goToPage',
         'common.pagination.label',
         'common.pagination.next',
         'common.pagination.previous',
         'common.remove',
         'common.required',
         'common.save',
         'common.saving',
         'common.search',
         'common.selectWithName',
         'common.unknownError',
         'common.view',
         'common.viewLess',
         'common.viewMore',
         'common.viewWithName',
         'common.yes',
         'form.dataHasChanged',
         'form.errorA11y',
         'form.errorGoTo',
         'form.errorMany',
         'form.errorOne',
         'form.errors',
         'form.multilingualLabel',
         'form.multilingualProgress',
         'form.saved',
         'help.help',
         'navigation.backTo',
         'validator.required'
      ]);
 
      // Register the jQuery script
      $min = Config::getVar('general', 'enable_minified') ? '.min' : '';
      if (Config::getVar('general', 'enable_cdn')) {
         $jquery = '//ajax.googleapis.com/ajax/libs/jquery/' . CDN_JQUERY_VERSION . '/jquery' . $min . '.js';
         $jqueryUI = '//ajax.googleapis.com/ajax/libs/jqueryui/' . CDN_JQUERY_UI_VERSION . '/jquery-ui' . $min . '.js';
      } else {
         $jquery = $request->getBaseUrl() . '/lib/pkp/lib/vendor/components/jquery/jquery' . $min . '.js';
         $jqueryUI = $request->getBaseUrl() . '/lib/pkp/lib/vendor/components/jqueryui/jquery-ui' . $min . '.js';
      }
      $this->addJavaScript(
         'jquery',
         $jquery,
         [
            'priority' => STYLE_SEQUENCE_CORE,
            'contexts' => 'backend',
         ]
      );
      $this->addJavaScript(
         'jqueryUI',
         $jqueryUI,
         [
            'priority' => STYLE_SEQUENCE_CORE,
            'contexts' => 'backend',
         ]
      );
 
      // Load Noto Sans font from Google Font CDN
      // To load extended latin or other character sets, see:
      // https://www.google.com/fonts#UsePlace:use/Collection:Noto+Sans
      if (Config::getVar('general', 'enable_cdn')) {
         $this->addStyleSheet(
            'pkpLibNotoSans',
            '//fonts.googleapis.com/css?family=Noto+Sans:400,400italic,700,700italic',
            [
               'priority' => STYLE_SEQUENCE_CORE,
               'contexts' => 'backend',
            ]
         );
      }
 
      // Register the pkp-lib JS library
      $this->registerJSLibraryData();
      $this->registerJSLibrary();
 
      // FontAwesome - http://fontawesome.io/
      if (Config::getVar('general', 'enable_cdn')) {
         $url = 'https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.css';
      } else {
         $url = $request->getBaseUrl() . '/lib/pkp/styles/fontawesome/fontawesome.css';
      }
      $this->addStyleSheet(
         'fontAwesome',
         $url,
         [
            'priority' => STYLE_SEQUENCE_CORE,
            'contexts' => 'backend',
         ]
      );
 
      // Stylesheet compiled from Vue.js single-file components
      $this->addStyleSheet(
         'build',
         $request->getBaseUrl() . '/styles/build.css',
         [
            'priority' => STYLE_SEQUENCE_CORE,
            'contexts' => 'backend',
         ]
      );
 
      // The legacy stylesheet for the backend
      $this->addStyleSheet(
         'pkpLib',
         $dispatcher->url($request, ROUTE_COMPONENT, null, 'page.PageHandler', 'css'),
         [
            'priority' => STYLE_SEQUENCE_CORE,
            'contexts' => 'backend',
         ]
      );
 
      // If there's a locale-specific stylesheet, add it.
      if (($localeStyleSheet = AppLocale::getLocaleStyleSheet(AppLocale::getLocale())) != null) {
         $this->addStyleSheet(
            'pkpLibLocale',
            $request->getBaseUrl() . '/' . $localeStyleSheet,
            [
               'contexts' => ['backend'],
            ]
         );
      }
 
      // Set up required state properties
      $this->setState([
         'menu' => [],
      ]);
 
      if (Config::getVar('general', 'installed') && !defined('SESSION_DISABLE_INIT')) {
 
         if ($request->getUser()) {
 
            // Get a count of unread tasks
            $notificationDao = DAORegistry::getDAO('NotificationDAO'); /* @var $notificationDao NotificationDAO */
            import('lib.pkp.controllers.grid.notifications.TaskNotificationsGridHandler');
            $unreadTasksCount = (int) $notificationDao->getNotificationCount(false, $request->getUser()->getId(), null, NOTIFICATION_LEVEL_TASK);
 
            // Get a URL to load the tasks grid
            $tasksUrl = $request->getDispatcher()->url($request, ROUTE_COMPONENT, null, 'page.PageHandler', 'tasks');
 
            // Load system notifications in SiteHandler.js
            $notificationDao = DAORegistry::getDAO('NotificationDAO'); /* @var $notificationDao NotificationDAO */
            $notifications = $notificationDao->getByUserId($request->getUser()->getId(), NOTIFICATION_LEVEL_TRIVIAL);
 
            // Load context switcher
            if (in_array(ROLE_ID_SITE_ADMIN, $this->get_template_vars('userRoles'))) {
               $args = [];
            } else {
               $args = ['userId' => $request->getUser()->getId()];
            }
            $availableContexts = Services::get('context')->getManySummary($args);
            if ($request->getContext()) {
               $availableContexts = array_filter($availableContexts, function($context) use ($request) {
                  return $context->id !== $request->getContext()->getId();
               });
            }
            $requestedPage = $router->getRequestedPage($request);
            foreach ($availableContexts as $availableContext) {
               // Site admins redirected to the same page. Everyone else to submission lists
               if ($requestedPage !== 'admin' && in_array(ROLE_ID_SITE_ADMIN, $this->get_template_vars('userRoles'))) {
                  $availableContext->url = $dispatcher->url($request, ROUTE_PAGE, $availableContext->urlPath, $request->getRequestedPage(), $request->getRequestedOp(), $request->getRequestedArgs($request));
               } else {
                  $availableContext->url = $dispatcher->url($request, ROUTE_PAGE, $availableContext->urlPath, 'submissions');
               }
            }
 
            // Create main navigation menu
            $userRoles = (array) $router->getHandler()->getAuthorizedContextObject(ASSOC_TYPE_USER_ROLES);
 
            $menu = [];
 
            if ($request->getContext()) {
               if (count(array_intersect([ROLE_ID_MANAGER, ROLE_ID_SUB_EDITOR, ROLE_ID_ASSISTANT, ROLE_ID_REVIEWER, ROLE_ID_AUTHOR], $userRoles))) {
                  $menu['submissions'] = [
                     'name' => __('navigation.submissions'),
                     'url' => $router->url($request, null, 'submissions'),
                     'isCurrent' => $router->getRequestedPage($request) === 'submissions',
                  ];
               } elseif (count($userRoles) === 1 && in_array(ROLE_ID_READER, $userRoles)) {
                  AppLocale::requireComponents(LOCALE_COMPONENT_APP_AUTHOR);
                  $menu['submit'] = [
                     'name' => __('author.submit'),
                     'url' => $router->url($request, null, 'submission', 'wizard'),
                     'isCurrent' => $router->getRequestedPage($request) === 'submission',
                  ];
               }
 
               if (count(array_intersect([ROLE_ID_MANAGER, ROLE_ID_SUB_EDITOR], $userRoles))) {
                  $menu['statistics'] = [
                     'name' => __('navigation.tools.statistics'),
                     'submenu' => [
                        'publications' => [
                           'name' => __('common.publications'),
                           'url' => $router->url($request, null, 'stats', 'publications', 'publications'),
                           'isCurrent' => $router->getRequestedPage($request) === 'stats' && $router->getRequestedOp($request) === 'publications',
                        ],
                        'editorial' => [
                           'name' => __('stats.editorialActivity'),
                           'url' => $router->url($request, null, 'stats', 'editorial', 'editorial'),
                           'isCurrent' => $router->getRequestedPage($request) === 'stats' && $router->getRequestedOp($request) === 'editorial',
                        ],
                        'users' => [
                           'name' => __('manager.users'),
                           'url' => $router->url($request, null, 'stats', 'users', 'users'),
                           'isCurrent' => $router->getRequestedPage($request) === 'stats' && $router->getRequestedOp($request) === 'users',
                        ]
                     ]
                  ];
               }
 
               if (in_array(ROLE_ID_MANAGER, $userRoles)) {
                  if ($request->getContext()->getData('enableAnnouncements')) {
                     $menu['announcements'] = [
                        'name' => __('announcement.announcements'),
                        'url' => $router->url($request, null, 'management', 'settings', 'announcements'),
                        'isCurrent' => $router->getRequestedPage($request) === 'management' && in_array('announcements', (array) $router->getRequestedArgs($request)),
                     ];
                  }
                  $menu['statistics']['submenu'] += [
                     'reports' => [
                        'name' => __('manager.statistics.reports'),
                        'url' => $router->url($request, null, 'management', 'tools', null, null, 'statistics'),
                        'isCurrent' => $router->getRequestedPage($request) === 'management' && $router->getRequestedAnchor($request) === 'statistics',
                     ]
                  ];
                  $menu['settings'] = [
                     'name' => __('navigation.settings'),
                     'submenu' => [
                        'context' => [
                           'name' => __('context.context'),
                           'url' => $router->url($request, null, 'management', 'settings', 'context'),
                           'isCurrent' => $router->getRequestedPage($request) === 'management' && in_array('context', (array) $router->getRequestedArgs($request)),
                        ],
                        'website' => [
                           'name' => __('manager.website'),
                           'url' => $router->url($request, null, 'management', 'settings', 'website'),
                           'isCurrent' => $router->getRequestedPage($request) === 'management' && in_array('website', (array) $router->getRequestedArgs($request)),
                        ],
                        'workflow' => [
                           'name' => __('manager.workflow'),
                           'url' => $router->url($request, null, 'management', 'settings', 'workflow'),
                           'isCurrent' => $router->getRequestedPage($request) === 'management' && in_array('workflow', (array) $router->getRequestedArgs($request)),
                        ],
                        'distribution' => [
                           'name' => __('manager.distribution'),
                           'url' => $router->url($request, null, 'management', 'settings', 'distribution'),
                           'isCurrent' => $router->getRequestedPage($request) === 'management' && in_array('distribution', (array) $router->getRequestedArgs($request)),
                        ],
                        'access' => [
                           'name' => __('navigation.access'),
                           'url' => $router->url($request, null, 'management', 'settings', 'access'),
                           'isCurrent' => $router->getRequestedPage($request) === 'management' && in_array('access', (array) $router->getRequestedArgs($request)),
                        ]
                     ]
                  ];
                  $menu['tools'] = [
                     'name' => __('navigation.tools'),
                     'url' => $router->url($request, null, 'management', 'tools'),
                     'isCurrent' => $router->getRequestedPage($request) === 'management' && $router->getRequestedOp($request) === 'tools',
                  ];
               }
 
               if (in_array(ROLE_ID_SITE_ADMIN, $userRoles)) {
                  $menu['admin'] = [
                     'name' => __('navigation.admin'),
                     'url' => $router->url($request, 'index', 'admin'),
                     'isCurrent' => $router->getRequestedPage($request) === 'admin',
                  ];
               }
            }
 
            $this->setState([
               'menu' => $menu,
               'tasksUrl' => $tasksUrl,
               'unreadTasksCount' => $unreadTasksCount,
            ]);
 
            $this->assign([
               'availableContexts' => $availableContexts,
               'hasSystemNotifications' => $notifications->getCount() > 0,
            ]);
         }
      }
 
      HookRegistry::call('TemplateManager::setupBackendPage');
   }
 
   function fetch($template = null, $cache_id = null, $compile_id = null, $parent = null) {
 
      // If no compile ID was assigned, get one.
      if (!$compile_id) $compile_id = $this->getCompileId($template);
 
      // Give hooks an opportunity to override
      $result = null;
      if (HookRegistry::call('TemplateManager::fetch', [$this, $template, $cache_id, $compile_id, &$result])) return $result;
 
      return parent::fetch($template, $cache_id, $compile_id, $parent);
   }
 
   function fetchAjax($id, $url, $element = 'div') {
      return new JSONMessage(true, $this->smartyLoadUrlInEl(
         [
            'url' => $url,
            'id' => $id,
            'el' => $element,
         ],
         $this
      ));
   }
 
   function getCompileId($resourceName) {
 
      if ( Config::getVar('general', 'installed' ) ) {
         $context = $this->_request->getContext();
         if (is_a($context, 'Context')) {
            $resourceName .= $context->getData('themePluginPath');
         }
      }
 
      return sha1($resourceName);
   }
 
   function fetchJson($template, $status = true) {
      import('lib.pkp.classes.core.JSONMessage');
      return new JSONMessage($status, $this->fetch($template));
   }
 
   function display($template = null, $cache_id = null, $compile_id = null, $parent = null) {
 
      // Output global constants and locale keys used in new component library
      $output = '';
      if (!empty($this->_constants)) {
         $output .= 'pkp.const = ' . json_encode($this->_constants) . ';';
      }
      if (!empty($this->_localeKeys)) {
         $output .= 'pkp.localeKeys = ' . json_encode($this->_localeKeys) . ';';
      }
 
      // Load current user data
      if (Config::getVar('general', 'installed')) {
         $user = $this->_request->getUser();
         if ($user) {
            $userGroupDao = DAORegistry::getDAO('UserGroupDAO'); /* @var $userGroupDao UserGroupDAO */
            $userGroupsResult = $userGroupDao->getByUserId($user->getId());
            $userRoles = [];
            while ($userGroup = $userGroupsResult->next()) {
               $userRoles[] = (int) $userGroup->getRoleId();
            }
            $currentUser = [
               'csrfToken' => $this->_request->getSession()->getCSRFToken(),
               'id' => (int) $user->getId(),
               'roles' => array_values(array_unique($userRoles)),
            ];
            $output .= 'pkp.currentUser = ' . json_encode($currentUser) . ';';
         }
      }
 
      $this->addJavaScript(
         'pkpAppData',
         $output,
         [
            'priority' => STYLE_SEQUENCE_LATE,
            'contexts' => ['backend'],
            'inline' => true,
         ]
      );
 
      // Give any hooks registered against the TemplateManager
      // the opportunity to modify behavior; otherwise, display
      // the template as usual.
      $output = null;
      if (HookRegistry::call('TemplateManager::display', [$this, &$template, &$output])) {
         echo $output;
         return;
      }
 
      // Pass the initial state data for this page
      $this->assign('state', $this->_state);
 
      // Explicitly set the character encoding. Required in
      // case server is using Apache's AddDefaultCharset
      // directive (which can prevent browser auto-detection
      // of the proper character set).
      header('Content-Type: text/html; charset=' . Config::getVar('i18n', 'client_charset'));
      header('Cache-Control: ' . $this->_cacheability);
 
      // If no compile ID was assigned, get one.
      if (!$compile_id) $compile_id = $this->getCompileId($template);
 
      // Actually display the template.
      parent::display($template, $cache_id, $compile_id, $parent);
   }
 
 
   function clearTemplateCache() {
      $this->clearCompiledTemplate();
      $this->clearAllCache();
   }
 
   public function clearCssCache() {
      $cacheDirectory = CacheManager::getFileCachePath();
      $files = scandir($cacheDirectory);
      array_map('unlink', glob(CacheManager::getFileCachePath() . DIRECTORY_SEPARATOR . '*.' . CSS_FILENAME_SUFFIX));
   }
 
   public function clearThemeTemplateCache($hookName, $args) {
      $newContextOrSite = $args[0];
      $contextOrSite = $args[1];
      if ($newContextOrSite->getData('themePluginPath') !== $contextOrSite->getData('themePluginPath')) {
         $this->clearTemplateCache();
         $this->clearCssCache();
      }
   }
 
   static function &getManager($request = null) {
      if (!isset($request)) {
         $request = Registry::get('request');
         if (Config::getVar('debug', 'deprecation_warnings')) trigger_error('Deprecated call without request object.');
      }
      assert(is_a($request, 'PKPRequest'));
 
      $instance =& Registry::get('templateManager', true, null); // Reference required
 
      if ($instance === null) {
         $instance = new TemplateManager();
         $themes = PluginRegistry::getPlugins('themes');
         if (empty($themes)) {
            $themes = PluginRegistry::loadCategory('themes', true);
         }
         $instance->initialize($request);
      }
 
      return $instance;
   }
 
   function getFBV() {
      if(!$this->_fbv) {
         import('lib.pkp.classes.form.FormBuilderVocabulary');
         $this->_fbv = new FormBuilderVocabulary();
      }
      return $this->_fbv;
   }
 
   public function displaySidebar($hookName, $args) {
      $params =& $args[0];
      $smarty =& $args[1];
      $output =& $args[2];
 
      if ($this->_request->getContext()) {
         $blocks = $this->_request->getContext()->getData('sidebar');
      } else {
         $blocks = $this->_request->getSite()->getData('sidebar');
      }
 
      if (empty($blocks)) {
         return false;
      }
 
      $plugins = PluginRegistry::loadCategory('blocks', true);
      if (empty($plugins)) {
         return false;
      }
 
      foreach ($blocks as $pluginName) {
         if (!empty($plugins[$pluginName])) {
            $output .= $plugins[$pluginName]->getContents($smarty, $this->_request);
         }
      }
 
      return false;
   }
 
 
   //
   // Custom template functions, modifiers, etc.
   //
 
   function smartyTranslate($params, $smarty) {
      if (isset($params) && !empty($params)) {
         if (!isset($params['key'])) return __('');
 
         $key = $params['key'];
         unset($params['key']);
         if (isset($params['params']) && is_array($params['params'])) {
            $paramsArray = $params['params'];
            unset($params['params']);
            $params = array_merge($params, $paramsArray);
         }
         return __($key, $params);
      }
   }
 
   function smartyNullLinkAction($params, $smarty) {
      assert(isset($params['id']));
 
      $id = $params['id'];
      $key = isset($params['key'])?$params['key']:null;
      $hoverTitle = isset($params['hoverTitle'])?true:false;
      $image = isset($params['image'])?$params['image']:null;
      $translate = isset($params['translate'])?false:true;
 
      import('lib.pkp.classes.linkAction.request.NullAction');
      import('lib.pkp.classes.linkAction.LinkAction');
      $key = $translate ? __($key) : $key;
      $this->assign('action', new LinkAction(
         $id, new NullAction(), $key, $image
      ));
 
      $this->assign('hoverTitle', $hoverTitle);
      return $this->fetch('linkAction/linkAction.tpl');
   }
 
   function smartyHelp($params, $smarty) {
      assert(isset($params['file']));
 
      $params = array_merge(
         [
            'file' => null, // The name of the Markdown file
            'section' => null, // The (optional) anchor within the Markdown file
            'textKey' => 'help.help', // An (optional) locale key for the link
            'text' => null, // An (optional) literal text for the link
            'class' => null, // An (optional) CSS class string for the link
         ],
         $params
      );
 
      $this->assign([
         'helpFile' => $params['file'],
         'helpSection' => $params['section'],
         'helpTextKey' => $params['textKey'],
         'helpText' => $params['text'],
         'helpClass' => $params['class'],
      ]);
 
      return $this->fetch('common/helpLink.tpl');
   }
 
   function smartyHtmlOptionsTranslate($params, $smarty) {
      if (isset($params['options'])) {
         if (isset($params['translateValues'])) {
            // Translate values AND output
            $newOptions = [];
            foreach ($params['options'] as $k => $v) {
               $newOptions[__($k)] = __($v);
            }
            $params['options'] = $newOptions;
         } else {
            // Just translate output
            $params['options'] = array_map('AppLocale::translate', $params['options']);
         }
      }
 
      if (isset($params['output'])) {
         $params['output'] = array_map('AppLocale::translate', $params['output']);
      }
 
      if (isset($params['values']) && isset($params['translateValues'])) {
         $params['values'] = array_map('AppLocale::translate', $params['values']);
      }
 
      require_once('lib/pkp/lib/vendor/smarty/smarty/libs/plugins/function.html_options.php');
      return smarty_function_html_options($params, $smarty);
   }
 
   function smartyIterate($params, $content, $smarty, &$repeat) {
      $iterator = $smarty->getTemplateVars($params['from']);
 
      if (isset($params['key'])) {
         if (empty($content)) $smarty->assign($params['key'], 1);
         else $smarty->assign($params['key'], $smarty->getTemplateVars($params['key'])+1);
      }
 
      // If the iterator is empty, we're finished.
      if (!$iterator || $iterator->eof()) {
         if (!$repeat) return $content;
         $repeat = false;
         return '';
      }
 
      $repeat = true;
 
      if (isset($params['key'])) {
         list($key, $value) = $iterator->nextWithKey();
         $smarty->assign($params['item'], $value);
         $smarty->assign($params['key'], $key);
      } else {
         $smarty->assign($params['item'], $iterator->next());
      }
      return $content;
   }
 
   function smartyPageInfo($params, $smarty) {
      $iterator = $params['iterator'];
 
      if (isset($params['itemsPerPage'])) {
         $itemsPerPage = $params['itemsPerPage'];
      } else {
         $itemsPerPage = $smarty->getTemplateVars('itemsPerPage');
         if (!is_numeric($itemsPerPage)) $itemsPerPage=25;
      }
 
      $page = $iterator->getPage();
      $pageCount = $iterator->getPageCount();
      $itemTotal = $iterator->getCount();
 
      if ($pageCount<1) return '';
 
      $from = (($page - 1) * $itemsPerPage) + 1;
      $to = min($itemTotal, $page * $itemsPerPage);
 
      return __('navigation.items', [
         'from' => ($to===0?0:$from),
         'to' => $to,
         'total' => $itemTotal
      ]);
   }
 
   function smartyFlush($params, $smarty) {
      $smarty->flush();
   }
 
   function flush() {
      while (ob_get_level()) {
         ob_end_flush();
      }
      flush();
   }
 
   function smartyCallHook($params, $smarty) {
      $output = null;
      HookRegistry::call($params['name'], [&$params, $smarty, &$output]);
      return $output;
   }
 
   function smartyUrl($parameters, $smarty) {
      if ( !isset($parameters['context']) ) {
         // Extract the variables named in $paramList, and remove them
         // from the parameters array. Variables remaining in params will be
         // passed along to Request::url as extra parameters.
         $context = [];
         $application = Application::get();
         $contextList = $application->getContextList();
         foreach ($contextList as $contextName) {
            if (isset($parameters[$contextName])) {
               $context[$contextName] = $parameters[$contextName];
               unset($parameters[$contextName]);
            } else {
               $context[$contextName] = null;
            }
         }
         $parameters['context'] = $context;
      }
 
      // Extract the reserved variables named in $paramList, and remove them
      // from the parameters array. Variables remaining in parameters will be passed
      // along to Request::url as extra parameters.
      $paramList = ['params', 'router', 'context', 'page', 'component', 'op', 'path', 'anchor', 'escape'];
      foreach ($paramList as $parameter) {
         if (isset($parameters[$parameter])) {
            $$parameter = $parameters[$parameter];
            unset($parameters[$parameter]);
         } else {
            $$parameter = null;
         }
      }
 
      // Merge parameters specified in the {url paramName=paramValue} format with
      // those optionally supplied in {url params=$someAssociativeArray} format
      $parameters = array_merge($parameters, (array) $params);
 
      // Set the default router
      if (is_null($router)) {
         if (is_a($this->_request->getRouter(), 'PKPComponentRouter')) {
            $router = ROUTE_COMPONENT;
         } else {
            $router = ROUTE_PAGE;
         }
      }
 
      // Check the router
      $dispatcher = Application::get()->getDispatcher();
      $routerShortcuts = array_keys($dispatcher->getRouterNames());
      assert(in_array($router, $routerShortcuts));
 
      // Identify the handler
      switch($router) {
         case ROUTE_PAGE:
            $handler = $page;
            break;
 
         case ROUTE_COMPONENT:
            $handler = $component;
            break;
 
         default:
            // Unknown router type
            assert(false);
      }
 
      // Let the dispatcher create the url
      return $dispatcher->url($this->_request, $router, $context, $handler, $op, $path, $parameters, $anchor, !isset($escape) || $escape);
   }
 
   function smartyTitle($parameters, $smarty) {
      $page = $parameters['value'] ?? '';
      if ($smarty->get_template_vars('currentContext')) {
         $siteTitle = $smarty->get_template_vars('currentContext')->getLocalizedData('name');
      } elseif ($smarty->get_template_vars('siteTitle')) {
         $siteTitle = $smarty->get_template_vars('siteTitle');
      } else {
         $siteTitle = __('common.software');
      }
 
      if (empty($parameters['value'])) {
         return $siteTitle;
      }
 
      return $parameters['value'] . __('common.titleSeparator') . $siteTitle;
   }
 
   function smartyPageLinks($params, $smarty) {
      $iterator = $params['iterator'];
      $name = $params['name'];
      if (isset($params['params']) && is_array($params['params'])) {
         $extraParams = $params['params'];
         unset($params['params']);
         $params = array_merge($params, $extraParams);
      }
      if (isset($params['anchor'])) {
         $anchor = $params['anchor'];
         unset($params['anchor']);
      } else {
         $anchor = null;
      }
      if (isset($params['all_extra'])) {
         $allExtra = ' ' . $params['all_extra'];
         unset($params['all_extra']);
      } else {
         $allExtra = '';
      }
 
      unset($params['iterator']);
      unset($params['name']);
 
      $numPageLinks = $smarty->getTemplateVars('numPageLinks');
      if (!is_numeric($numPageLinks)) $numPageLinks=10;
 
      $page = $iterator->getPage();
      $pageCount = $iterator->getPageCount();
 
      $pageBase = max($page - floor($numPageLinks / 2), 1);
      $paramName = $name . 'Page';
 
      if ($pageCount<=1) return '';
 
      $value = '';
 
      $router = $this->_request->getRouter();
      $requestedArgs = null;
      if (is_a($router, 'PageRouter')) {
         $requestedArgs = $router->getRequestedArgs($this->_request);
      }
 
      if ($page>1) {
         $params[$paramName] = 1;
         $value .= '<a href="' . $this->_request->url(null, null, null, $requestedArgs, $params, $anchor) . '"' . $allExtra . '>&lt;&lt;</a>&nbsp;';
         $params[$paramName] = $page - 1;
         $value .= '<a href="' . $this->_request->url(null, null, null, $requestedArgs, $params, $anchor) . '"' . $allExtra . '>&lt;</a>&nbsp;';
      }
 
      for ($i=$pageBase; $i<min($pageBase+$numPageLinks, $pageCount+1); $i++) {
         if ($i == $page) {
            $value .= "<strong>$i</strong>&nbsp;";
         } else {
            $params[$paramName] = $i;
            $value .= '<a href="' . $this->_request->url(null, null, null, $requestedArgs, $params, $anchor) . '"' . $allExtra . '>' . $i . '</a>&nbsp;';
         }
      }
      if ($page < $pageCount) {
         $params[$paramName] = $page + 1;
         $value .= '<a href="' . $this->_request->url(null, null, null, $requestedArgs, $params, $anchor) . '"' . $allExtra . '>&gt;</a>&nbsp;';
         $params[$paramName] = $pageCount;
         $value .= '<a href="' . $this->_request->url(null, null, null, $requestedArgs, $params, $anchor) . '"' . $allExtra . '>&gt;&gt;</a>&nbsp;';
      }
 
      return $value;
   }
 
   function smartyToArray() {
      return func_get_args();
   }
 
   function smartyConcat() {
      $args = func_get_args();
      return implode('', $args);
   }
 
   function smartyCompare($a, $b, $strict = false, $invert = false) {
      $result = $strict?$a===$b:$a==$b;
      return $invert?!$result:$result;
   }
 
   function smartyStrtotime($string) {
      return strtotime($string);
   }
 
   function smartyExplode($string, $separator) {
      return explode($separator, $string);
   }
 
   function smartyEscape($string, $esc_type = 'html', $char_set = 'ISO-8859-1') {
      $pattern = "/(:|\.|\[|\]|,|=|@)/";
      $replacement = "\\\\\\\\$1";
      switch ($esc_type) {
         // Because jQuery uses CSS syntax for selecting elements
         // some characters are interpreted as CSS notation.
         // In order to tell jQuery to treat these characters literally rather
         // than as CSS notation, they must be escaped by placing two backslashes
         // in front of them.
         case 'jqselector':
            $result = smarty_modifier_escape($string, 'html', $char_set);
            $result = preg_replace($pattern, $replacement, $result);
            return $result;
 
         case 'jsid':
            $result = smarty_modifier_escape($string, 'javascript', $char_set);
            $result = preg_replace($pattern, $replacement, $result);
            return $result;
 
         default:
            return smarty_modifier_escape($string, $esc_type, $char_set);
      }
   }
 
   function smartyLoadUrlInEl($params, $smarty) {
      // Required Params
      if (!isset($params['el'])) {
         throw new Exception("el parameter is missing from load_url_in_el");
      }
      if (!isset($params['url'])) {
         throw new Exception("url parameter is missing from load_url_in_el");
      }
      if (!isset($params['id'])) {
         throw new Exception("id parameter is missing from load_url_in_el");
      }
 
      $this->assign([
         'inEl' => $params['el'],
         'inElUrl' => $params['url'],
         'inElElId' => $params['id'],
         'inElClass' => isset($params['class'])?$params['class']:null,
         'refreshOn' => isset($params['refreshOn'])?$params['refreshOn']:null,
      ]);
 
      if (isset($params['placeholder'])) {
         $this->assign('inElPlaceholder', $params['placeholder']);
      } elseif (isset($params['loadMessageId'])) {
         $loadMessageId = $params['loadMessageId'];
         $this->assign('inElPlaceholder', __($loadMessageId, $params));
      } else {
         $this->assign('inElPlaceholder', $this->fetch('common/loadingContainer.tpl'));
      }
 
      return $this->fetch('common/urlInEl.tpl');
   }
 
   function smartyLoadUrlInDiv($params, $smarty) {
      $params['el'] = 'div';
      return $this->smartyLoadUrlInEl( $params, $smarty );
   }
 
   function smartyCSRF($params, $smarty) {
      $csrfToken = $this->_request->getSession()->getCSRFToken();
      switch (isset($params['type'])?$params['type']:null) {
         case 'raw': return $csrfToken;
         case 'json': return json_encode($csrfToken);
         case 'html':
         default:
            return '<input type="hidden" name="csrfToken" value="' . htmlspecialchars($csrfToken) . '">';
      }
   }
 
   function smartyLoadStylesheet($params, $smarty) {
 
      if (empty($params['context'])) {
         $params['context'] = 'frontend';
      }
 
      if (!defined('SESSION_DISABLE_INIT')) {
         $versionDao = DAORegistry::getDAO('VersionDAO'); /* @var $versionDao VersionDAO */
         $appVersion = $versionDao->getCurrentVersion()->getVersionString();
      } else $appVersion = null;
 
      $stylesheets = $this->getResourcesByContext($this->_styleSheets, $params['context']);
 
      ksort($stylesheets);
 
      $output = '';
      foreach($stylesheets as $priorityList) {
         foreach($priorityList as $style) {
            if (!empty($style['inline'])) {
               $output .= '<style type="text/css">' . $style['style'] . '</style>';
            } else {
               if ($appVersion && strpos($style['style'], '?') === false) {
                  $style['style'] .= '?v=' . $appVersion;
               }
               $output .= '<link rel="stylesheet" href="' . $style['style'] . '" type="text/css" />';
            }
         }
      }
 
      return $output;
   }
 
   function loadHtmlGalleyStyles($htmlContent, $embeddedFiles) {
 
      if (empty($htmlContent)) {
         return $htmlContent;
      }
 
      $hasEmbeddedStyle = false;
      foreach ($embeddedFiles as $embeddedFile) {
         if ($embeddedFile->getFileType() === 'text/css') {
            $hasEmbeddedStyle = true;
            break;
         }
      }
 
      if ($hasEmbeddedStyle) {
         return $htmlContent;
      }
 
      $links = '';
      $styles = $this->getResourcesByContext($this->_styleSheets, 'htmlGalley');
 
      if (!empty($styles)) {
         ksort($styles);
         foreach ($styles as $priorityGroup) {
            foreach ($priorityGroup as $htmlStyle) {
               $links .= '<link rel="stylesheet" href="' . $htmlStyle['style'] . '" type="text/css">' . "\n";
            }
         }
      }
 
      return str_ireplace('<head>', '<head>' . "\n" . $links, $htmlContent);
   }
 
   function smartyLoadScript($params, $smarty) {
 
      if (empty($params['context'])) {
         $params['context'] = 'frontend';
      }
 
      if (!defined('SESSION_DISABLE_INIT')) {
         $versionDao = DAORegistry::getDAO('VersionDAO'); /* @var $versionDao VersionDAO */
         $appVersion = defined('SESSION_DISABLE_INIT') ? null : $versionDao->getCurrentVersion()->getVersionString();
      } else $appVersion = null;
 
      $scripts = $this->getResourcesByContext($this->_javaScripts, $params['context']);
 
      ksort($scripts);
 
      $output = '';
      foreach($scripts as $priorityList) {
         foreach($priorityList as $name => $data) {
            if ($data['inline']) {
               $output .= '<script type="text/javascript">' . $data['script'] . '</script>';
            } else {
               if ($appVersion && strpos($data['script'], '?') === false) {
                  $data['script'] .= '?v=' . $appVersion;
               }
               $output .= '<script src="' . $data['script'] . '" type="text/javascript"></script>';
            }
         }
      }
 
      return $output;
   }
 
   function smartyLoadHeader($params, $smarty) {
 
      if (empty($params['context'])) {
         $params['context'] = 'frontend';
      }
 
      $headers = $this->getResourcesByContext($this->_htmlHeaders, $params['context']);
 
      ksort($headers);
 
      $output = '';
      foreach($headers as $priorityList) {
         foreach($priorityList as $name => $data) {
            $output .= "\n" . $data['header'];
         }
      }
 
      return $output;
   }
 
   function smartyLoadNavigationMenuArea($params, $smarty) {
      $areaName = $params['name'];
      $declaredMenuTemplatePath = $params['path'];
      $currentContext = $this->_request->getContext();
      $contextId = CONTEXT_ID_NONE;
      if ($currentContext) {
         $contextId = $currentContext->getId();
      }
 
      // Don't load menus for an area that's not registered by the active theme
      $themePlugins = PluginRegistry::getPlugins('themes');
      if (empty($themePlugins)) {
         $themePlugins = PluginRegistry::loadCategory('themes', true);
      }
      $activeThemeNavigationAreas = [];
      foreach ($themePlugins as $themePlugin) {
         if ($themePlugin->isActive()) {
            $areas = $themePlugin->getMenuAreas();
            if (!in_array($areaName, $areas)) {
               return '';
            }
         }
      }
 
      $menuTemplatePath = 'frontend/components/navigationMenu.tpl';
      if (isset($declaredMenuTemplatePath)) {
         $menuTemplatePath = $declaredMenuTemplatePath;
      }
 
      $navigationMenuDao = DAORegistry::getDAO('NavigationMenuDAO'); /* @var $navigationMenuDao NavigationMenuDAO */
 
      $output = '';
      $navigationMenus = $navigationMenuDao->getByArea($contextId, $areaName)->toArray();
      if (isset($navigationMenus[0])) {
         $navigationMenu = $navigationMenus[0];
         import('classes.core.Services');
         Services::get('navigationMenu')->getMenuTree($navigationMenu);
      }
 
 
      $this->assign([
         'navigationMenu' => $navigationMenu,
         'id' => $params['id'],
         'ulClass' => $params['ulClass'],
         'liClass' => $params['liClass'],
      ]);
 
      return $this->fetch($menuTemplatePath);
   }
 
   function getResourcesByContext($resources, $context) {
      $matches = [];
 
      if (array_key_exists($context, $resources)) {
         $matches = $resources[$context];
      }
 
      $page = $this->getTemplateVars('requestedPage');
      $page = empty( $page ) ? 'index' : $page;
      $op = $this->getTemplateVars('requestedOp');
      $op = empty( $op ) ? 'index' : $op;
 
      $contexts = [
         join('-', [$context, $page]),
         join('-', [$context, $page, $op]),
      ];
 
      foreach($contexts as $context) {
         if (array_key_exists($context, $resources)) {
            foreach ($resources[$context] as $priority => $priorityList) {
               if (!array_key_exists($priority, $matches)) {
                  $matches[$priority] = [];
               }
               $matches[$priority] = array_merge($matches[$priority], $resources[$context][$priority]);
            }
            $matches += $resources[$context];
         }
      }
 
      return $matches;
   }
 
   function smartyPluckFiles($params, $smarty) {
 
      // The variable to assign the result to.
      if (empty($params['assign'])) {
         error_log('Smarty: {pluck_files} function called without required `assign` param. Called in ' . __FILE__ . ':' . __LINE__);
         return;
      }
 
      // $params['files'] should be an array of SubmissionFile objects
      if (!is_array($params['files'])) {
         error_log('Smarty: {pluck_files} function called without required `files` param. Called in ' . __FILE__ . ':' . __LINE__);
         $smarty->assign($params['assign'], []);
         return;
      }
 
      // $params['by'] is one of an approved list of attributes to select by
      if (empty($params['by'])) {
         error_log('Smarty: {pluck_files} function called without required `by` param. Called in ' . __FILE__ . ':' . __LINE__);
         $smarty->assign($params['assign'], []);
         return;
      }
 
      // The approved list of `by` attributes
      // chapter Any files assigned to a chapter ID. A value of `any` will return files assigned to any chapter. A value of 0 will return files not assigned to chapter
      // publicationFormat Any files in a given publicationFormat ID
      // component Any files of a component type by class name: SubmissionFile|SubmissionArtworkFile|SupplementaryFile
      // fileExtension Any files with a file extension in all caps: PDF
      // genre Any files with a genre ID (file genres are configurable but typically refer to Manuscript, Bibliography, etc)
      if (!in_array($params['by'], ['chapter', 'publicationFormat', 'component', 'fileExtension', 'genre'])) {
         error_log('Smarty: {pluck_files} function called without a valid `by` param. Called in ' . __FILE__ . ':' . __LINE__);
         $smarty->assign($params['assign'], []);
         return;
      }
 
      // The value to match against. See docs for `by` param
      if (!isset($params['value'])) {
         error_log('Smarty: {pluck_files} function called without required `value` param. Called in ' . __FILE__ . ':' . __LINE__);
         $smarty->assign($params['assign'], []);
         return;
      }
 
      $matching_files = [];
 
      $genreDao = DAORegistry::getDAO('GenreDAO'); /* @var $genreDao GenreDAO */
      foreach ($params['files'] as $file) {
         switch ($params['by']) {
 
            case 'chapter':
               $genre = $genreDao->getById($file->getGenreId());
               if (!$genre->getDependent() && method_exists($file, 'getChapterId')) {
                  if ($params['value'] === 'any' && $file->getChapterId()) {
                     $matching_files[] = $file;
                  } elseif($file->getChapterId() == $params['value']) {
                     $matching_files[] = $file;
                  } elseif ($params['value'] == 0 && !$file->getChapterId()) {
                     $matching_files[] = $file;
                  }
               }
               break;
 
            case 'publicationFormat':
               if ($file->getAssocId() == $params['value']) {
                  $matching_files[] = $file;
               }
               break;
 
            case 'component':
               if (get_class($file) == $params['value']) {
                  $matching_files[] = $file;
               }
               break;
 
            case 'fileExtension':
               if ($file->getExtension() == $params['value']) {
                  $matching_files[] = $file;
               }
               break;
 
            case 'genre':
               if ($file->getGenreId() == $params['value']) {
                  $matching_files[] = $file;
               }
               break;
         }
      }
 
      $smarty->assign($params['assign'], $matching_files);
   }
 
   public function get_template_vars($varname = null) {
      if (Config::getVar('debug', 'deprecation_warnings')) trigger_error('Deprecated call to Smarty2 function ' .  __FUNCTION__);
      return $this->getTemplateVars($varname);
   }
 
   public function register_function($name, $impl, $cacheable = true, $cache_attrs = null) {
      if (Config::getVar('debug', 'deprecation_warnings')) trigger_error('Deprecated call to Smarty2 function ' .  __FUNCTION__);
      $this->registerPlugin('function', $name, $impl, $cacheable, $cache_attrs);
   }
}