Plugin.inc.php

<?php
 
// Define the well-known file name for filter configuration data.
define('PLUGIN_FILTER_DATAFILE', 'filterConfig.xml');
define('PLUGIN_TEMPLATE_RESOURCE_PREFIX', 'plugins');
 
abstract class Plugin {
   var $pluginPath;
 
   var $pluginCategory;
 
   var $request;
 
   function __construct() {
   }
 
   /*
    * Public Plugin API (Registration and Initialization)
    */
   function register($category, $path, $mainContextId = null) {
      $this->pluginPath = $path;
      $this->pluginCategory = $category;
      if ($this->getInstallSchemaFile() || $this->getInstallMigration()) {
         HookRegistry::register ('Installer::postInstall', array($this, 'updateSchema'));
      }
      if ($this->getInstallSitePluginSettingsFile()) {
         HookRegistry::register ('Installer::postInstall', array($this, 'installSiteSettings'));
      }
      if ($this->getInstallControlledVocabFiles()) {
         HookRegistry::register ('Installer::postInstall', array($this, 'installControlledVocabs'));
      }
      if ($this->getInstallEmailTemplatesFile()) {
         HookRegistry::register ('Installer::postInstall', array($this, 'installEmailTemplates'));
         HookRegistry::register ('PKPLocale::installLocale', array($this, 'installLocale'));
      }
      if ($this->getInstallEmailTemplateDataFile()) {
         HookRegistry::register ('Installer::postInstall', array($this, 'installEmailTemplateData'));
      }
      if ($this->getInstallDataFile()) {
         HookRegistry::register ('Installer::postInstall', array($this, 'installData'));
      }
      if ($this->getContextSpecificPluginSettingsFile()) {
         HookRegistry::register ('Context::add', array($this, 'installContextSpecificSettings'));
      }
 
      HookRegistry::register ('Installer::postInstall', array($this, 'installFilters'));
 
      $this->_registerTemplateResource();
      return true;
   }
 
   //
   // Plugin Display
   //
 
   abstract function getName();
 
   abstract function getDisplayName();
 
   abstract function getDescription();
 
   //
   // Plugin Behavior and Management
   //
 
   function getSeq() {
      return 0;
   }
 
   function isSitePlugin() {
      return false;
   }
 
   function manage($args, $request) {
      throw new Exception('Unhandled management action!');
   }
 
   function getHideManagement() {
      return false;
   }
 
   //
   // Plugin Installation
   //
 
   function getInstallSchemaFile() {
      return null;
   }
 
   function getInstallMigration() {
      return null;
   }
 
   function getInstallDataFile() {
      return null;
   }
 
   function getInstallSitePluginSettingsFile() {
      return null;
   }
 
   function getInstallControlledVocabFiles() {
      return array();
   }
 
   function getContextSpecificPluginSettingsFile() {
      return null;
   }
 
   function getInstallEmailTemplatesFile() {
      return null;
   }
 
   function getInstallEmailTemplateDataFile() {
      return null;
   }
 
   function getInstallFilterConfigFiles() {
      // Construct the well-known filter configuration file names.
      $filterConfigFile = $this->getPluginPath().'/filter/'.PLUGIN_FILTER_DATAFILE;
      $filterConfigFiles = array(
         './lib/pkp/'.$filterConfigFile,
         './'.$filterConfigFile
      );
      return $filterConfigFiles;
   }
 
   /*
    * Protected helper methods (can be used by custom plugins but
    * should not be overridden by custom plugins)
    */
   function getCategory() {
      return $this->pluginCategory;
   }
 
   function getPluginPath() {
      return $this->pluginPath;
   }
 
   function getDirName() {
      return basename($this->pluginPath);
   }
 
   public function getTemplateResource($template = null, $inCore = false) {
      $pluginPath = $this->getPluginPath();
      if ($inCore) {
         $pluginPath = PKP_LIB_PATH . DIRECTORY_SEPARATOR . $pluginPath;
      }
      $plugin = basename($pluginPath);
      $category = basename(dirname($pluginPath));
      // Slash characters (/) are not allowed in resource names, so use dashes (-) instead.
      $resourceName = strtr(join('/', array(PLUGIN_TEMPLATE_RESOURCE_PREFIX, $pluginPath, $category, $plugin)),'/','-');
      return $resourceName . ($template!==null?":$template":'');
   }
 
   function getTemplatePath($inCore = false) {
      $templatePath = ($inCore?PKP_LIB_PATH . DIRECTORY_SEPARATOR:'') . $this->getPluginPath() . DIRECTORY_SEPARATOR . 'templates';
      if (is_dir($templatePath)) return $templatePath;
      return null;
   }
 
   protected function _registerTemplateResource($inCore = false) {
      if ($templatePath = $this->getTemplatePath($inCore)) {
         $templateMgr = TemplateManager::getManager();
         $pluginTemplateResource = new PKPTemplateResource($templatePath);
         $templateMgr->registerResource($this->getTemplateResource(null, $inCore), $pluginTemplateResource);
      }
   }
 
   public function _overridePluginTemplates($hookName, $args) {
      $filePath =& $args[0];
      $template = $args[1];
      $checkFilePath = $filePath;
 
      // If there's a templates/ prefix on the template, clean up the test path.
      if (strpos($filePath, 'plugins/') === 0) $checkFilePath = 'templates/' . $checkFilePath;
 
      // If there's a lib/pkp/ prefix on the template, test without it.
      $libPkpPrefix = 'lib' . DIRECTORY_SEPARATOR . 'pkp' . DIRECTORY_SEPARATOR;
      if (strpos($checkFilePath, $libPkpPrefix) === 0) $checkFilePath = substr($filePath, strlen($libPkpPrefix));
 
      // Check if an overriding plugin exists in the plugin path.
      if ($overriddenFilePath = $this->_findOverriddenTemplate($checkFilePath)) {
         $filePath = $overriddenFilePath;
      }
 
      return false;
   }
 
   private function _findOverriddenTemplate($path) {
      $fullPath = sprintf('%s/%s', $this->getPluginPath(), $path);
 
      if (file_exists($fullPath)) {
         return $fullPath;
      }
 
      // Backward compatibility for OJS prior to 3.1.2; changed path to templates for plugins.
      if (($fullPath = preg_replace("/templates\/(?!.*templates\/)/", "", $fullPath)) && file_exists($fullPath)) {
         if (Config::getVar('debug', 'deprecation_warnings')) {
            trigger_error('Deprecated: The template at ' . $fullPath . ' has moved and will not be found in the future.');
         }
         return $fullPath;
      }
 
      // Recursive check for templates in ancestors of a current theme plugin
      if (is_a($this, 'ThemePlugin')
         && $this->parent
         && $fullPath = $this->parent->_findOverriddenTemplate($path)) {
         return $fullPath;
      }
 
      return null;
   }
 
   function addLocaleData($locale = null) {
      if ($locale == '') $locale = AppLocale::getLocale();
      $localeFilenames = $this->getLocaleFilename($locale);
      if ($localeFilenames) {
         if (is_scalar($localeFilenames)) $localeFilenames = array($localeFilenames);
         foreach($localeFilenames as $localeFilename) {
            AppLocale::registerLocaleFile($locale, $localeFilename);
         }
         return true;
      }
      return false;
   }
 
   function getSetting($contextId, $name) {
      if (!defined('RUNNING_UPGRADE') && !Config::getVar('general', 'installed')) return null;
 
      // Construct the argument list and call the plug-in settings DAO
      $arguments = array(
         $contextId,
         $this->getName(),
         $name,
      );
 
      $pluginSettingsDao = DAORegistry::getDAO('PluginSettingsDAO'); /* @var $pluginSettingsDao PluginSettingsDAO */
      return call_user_func_array(array(&$pluginSettingsDao, 'getSetting'), $arguments);
   }
 
   function updateSetting($contextId, $name, $value, $type = null) {
 
      // Construct the argument list and call the plug-in settings DAO
      $arguments = array(
         $contextId,
         $this->getName(),
         $name,
         $value,
         $type,
      );
 
      $pluginSettingsDao = DAORegistry::getDAO('PluginSettingsDAO'); /* @var $pluginSettingsDao PluginSettingsDAO */
      call_user_func_array(array(&$pluginSettingsDao, 'updateSetting'), $arguments);
   }
 
   function import($class) {
      require_once($this->getPluginPath() . '/' . str_replace('.', '/', $class) . '.inc.php');
   }
 
   /*
    * Protected helper methods (for internal use only, should not
    * be used by custom plug-ins)
    *
    * NB: These methods may change without notice in the future!
    */
   function getLocaleFilename($locale) {
      $masterLocale = MASTER_LOCALE;
      $baseLocaleFilename = $this->getPluginPath() . "/locale/$locale/locale.po";
      $baseMasterLocaleFilename = $this->getPluginPath() . "/locale/$masterLocale/locale.po";
      $libPkpFilename = "lib/pkp/$baseLocaleFilename";
      $masterLibPkpFilename = "lib/pkp/$baseMasterLocaleFilename";
      $filenames = array();
      if (file_exists($baseMasterLocaleFilename)) $filenames[] = $baseLocaleFilename;
      if (file_exists($masterLibPkpFilename)) $filenames[] = $libPkpFilename;
 
      // This compatibility code for XML file fallback will eventually be removed.
      // See https://github.com/pkp/pkp-lib/issues/5090.
      $baseMasterXmlLocaleFilename = preg_replace('/\.po$/', '.xml', $baseMasterLocaleFilename);
      if (file_exists($baseMasterXmlLocaleFilename)) $filenames[] = preg_replace('/\.po$/', '.xml', $baseLocaleFilename);
      $masterXmlLibPkpLocaleFilename = preg_replace('/\.po$/', '.xml', $baseMasterLocaleFilename);
      if (file_exists($masterXmlLibPkpLocaleFilename)) $filenames[] = preg_replace('/\.po$/', '.xml', $libPkpFilename);
 
      return $filenames;
   }
 
   function installData($hookName, $args) {
      $installer =& $args[0];
      $result =& $args[1];
 
      // Treat single and multiple data files uniformly.
      $dataFiles = $this->getInstallDataFile();
      if (is_scalar($dataFiles)) $dataFiles = array($dataFiles);
 
      // Install all data files.
      foreach($dataFiles as $dataFile) {
         $sql = $installer->dataXMLParser->parseData($dataFile);
         if ($sql) {
            $result = $installer->executeSQL($sql);
         } else {
            AppLocale::requireComponents(LOCALE_COMPONENT_PKP_INSTALLER);
            $installer->setError(INSTALLER_ERROR_DB, str_replace('{$file}', $this->getInstallDataFile(), __('installer.installParseDBFileError')));
            $result = false;
         }
         if (!$result) return false;
      }
      return false;
   }
 
   function installSiteSettings($hookName, $args) {
      // All contexts are set to zero for site-wide plug-in settings
      $application = Application::get();
      $contextDepth = $application->getContextDepth();
      if ($contextDepth >0) {
         $arguments = array_fill(0, $contextDepth, 0);
      } else {
         $arguments = array();
      }
      $arguments[] = $this->getName();
      $arguments[] = $this->getInstallSitePluginSettingsFile();
      $pluginSettingsDao = DAORegistry::getDAO('PluginSettingsDAO'); /* @var $pluginSettingsDao PluginSettingsDAO */
      call_user_func_array(array(&$pluginSettingsDao, 'installSettings'), $arguments);
 
      return false;
   }
 
   function installControlledVocabs($hookName, $args) {
      // All contexts are set to zero for site-wide plug-in settings
      $controlledVocabDao = DAORegistry::getDAO('ControlledVocabDAO'); /* @var $controlledVocabDao ControlledVocabDAO */
      foreach ($this->getInstallControlledVocabFiles() as $file) {
         $controlledVocabDao->installXML($file);
      }
      return false;
   }
   function installContextSpecificSettings($hookName, $args) {
      $context = $args[0];
      $pluginSettingsDao = DAORegistry::getDAO('PluginSettingsDAO'); /* @var $pluginSettingsDao PluginSettingsDAO */
      $pluginSettingsDao->installSettings($context->getId(), $this->getName(), $this->getContextSpecificPluginSettingsFile());
      return false;
   }
 
   function installEmailTemplates($hookName, $args) {
      $installer =& $args[0]; /* @var $installer Installer */
      $result =& $args[1];
 
      // Load email template data as required from the locale files.
      $emailTemplateDao = DAORegistry::getDAO('EmailTemplateDAO'); /* @var $emailTemplateDao EmailTemplateDAO */
      $emailTemplateLocales = [];
      foreach ($installer->installedLocales as $locale) {
         $emailFile = $this->getPluginPath() . "/locale/$locale/emails.po";
         if (!file_exists($emailFile)) continue;
         AppLocale::registerLocaleFile($locale, $emailFile);
         $emailTemplateLocales[] = $locale;
      }
      $sql = $emailTemplateDao->installEmailTemplates($this->getInstallEmailTemplatesFile(), $emailTemplateLocales, true, null, true);
 
      if ($sql === false) {
         // The template file seems to be invalid.
         $installer->setError(INSTALLER_ERROR_DB, str_replace('{$file}', $this->getInstallEmailTemplatesFile(), __('installer.installParseEmailTemplatesFileError')));
         $result = false;
      } else {
         // Are there any yet uninstalled email templates?
         assert(is_array($sql));
         if (!empty($sql)) {
            // Install templates.
            $result = $installer->executeSQL($sql);
         }
      }
      return false;
   }
 
   function installEmailTemplateData($hookName, $args) {
      $installer =& $args[0];
      $result =& $args[1];
 
      $emailTemplateDao = DAORegistry::getDAO('EmailTemplateDAO'); /* @var $emailTemplateDao EmailTemplateDAO */
      foreach ($installer->installedLocales as $locale) {
         $filename = str_replace('{$installedLocale}', $locale, $this->getInstallEmailTemplateDataFile());
         if (!file_exists($filename)) continue;
         $sql = $emailTemplateDao->installEmailTemplateData($filename, $locale, true);
         if ($sql) {
            $result = $installer->executeSQL($sql);
         } else {
            $installer->setError(INSTALLER_ERROR_DB, str_replace('{$file}', $this->getInstallDataFile(), __('installer.installParseEmailTemplatesFileError')));
            $result = false;
         }
      }
      return false;
   }
 
   function installLocale($hookName, $args) {
      $locale =& $args[0];
      $filename = str_replace('{$installedLocale}', $locale, $this->getInstallEmailTemplateDataFile());
      $emailTemplateDao = DAORegistry::getDAO('EmailTemplateDAO'); /* @var $emailTemplateDao EmailTemplateDAO */
 
      // Since pkp/pkp-lib#5461, there are two ways to specify localized email data in plugins.
      // Install locale data specified in the old form. (Deprecated!)
      if ($this->getInstallEmailTemplateDataFile()) $emailTemplateDao->installEmailTemplateData($filename, $locale);
 
      // Install locale data specified in the new form.
      if (file_exists($emailFile = $this->getPluginPath() . "/locale/$locale/emails.po")) {
         AppLocale::registerLocaleFile($locale, $emailFile);
         $emailTemplateDao->installEmailTemplateLocaleData($this->getInstallEmailTemplatesFile(), [$locale]);
      }
      return false;
   }
 
   function installFilters($hookName, $args) {
      $installer =& $args[0]; /* @var $installer Installer */
      $result =& $args[1]; /* @var $result boolean */
 
      // Get the filter configuration file name(s).
      $filterConfigFiles = $this->getInstallFilterConfigFiles();
      if (is_scalar($filterConfigFiles)) $filterConfigFiles = array($filterConfigFiles);
 
      // Run through the config file positions and see
      // whether one of these exists and needs to be installed.
      foreach($filterConfigFiles as $filterConfigFile) {
         // Is there a filter configuration?
         if (!file_exists($filterConfigFile)) continue;
 
         // Install the filter configuration.
         $result = $installer->installFilterConfig($filterConfigFile);
         if (!$result) {
            // The filter configuration file seems to be invalid.
            $installer->setError(INSTALLER_ERROR_DB, str_replace('{$file}', $filterConfigFile, __('installer.installParseFilterConfigFileError')));
         }
      }
 
      // Do not stop installation.
      return false;
   }
 
   function updateSchema($hookName, $args) {
      $installer =& $args[0];
      $result =& $args[1];
 
      // Deprecated: Create schema using ADODB XML Schema
      if ($schemaFile = $this->getInstallSchemaFile()) {
         $schemaXMLParser = new adoSchema($installer->dbconn);
         $sql = $schemaXMLParser->parseSchema($schemaFile);
         if ($sql) {
            $result = $installer->executeSQL($sql);
         } else {
            $installer->setError(INSTALLER_ERROR_DB, str_replace('{$file}', $this->getInstallSchemaFile(), __('installer.installParseDBFileError')));
            $result = false;
         }
      }
      // Preferred: Create schema using Migrations
      if ($migration = $this->getInstallMigration()) try {
         $migration->up();
      } catch (Exception $e) {
         $installer->setError(INSTALLER_ERROR_DB, __('installer.installMigrationError', ['class' => get_class($migration)]));
         $result = false;
      }
      return false;
   }
 
   function smartyPluginUrl($params, $smarty) {
      $path = array($this->getCategory(), $this->getName());
      if (is_array($params['path'])) {
         $params['path'] = array_merge($path, $params['path']);
      } elseif (!empty($params['path'])) {
         $params['path'] = array_merge($path, array($params['path']));
      } else {
         $params['path'] = $path;
      }
      return $smarty->smartyUrl($params, $smarty);
   }
 
   function getCurrentVersion() {
      $versionDao = DAORegistry::getDAO('VersionDAO'); /* @var $versionDao VersionDAO */
      $pluginPath = $this->getPluginPath();
      $product = basename($pluginPath);
      $category = basename(dirname($pluginPath));
      $installedPlugin = $versionDao->getCurrentVersion('plugins.'.$category, $product, true);
 
      if ($installedPlugin) {
         return $installedPlugin;
      } else {
         return false;
      }
   }
 
   function &getRequest() {
      if (!$this->request) {
         $this->request =& Registry::get('request');
      }
      return $this->request;
   }
 
   /*
    * Private helper methods
    */
   function getActions($request, $actionArgs) {
      return array();
   }
 
   function getCanEnable() {
      return false;
   }
 
   function getCanDisable() {
      return false;
   }
 
   function getEnabled() {
      return true;
   }
}