Form.inc.php

<?php
 
import('lib.pkp.classes.form.FormError');
import('lib.pkp.classes.form.FormBuilderVocabulary');
 
// Import all form validators for convenient use in sub-classes
import('lib.pkp.classes.form.validation.FormValidatorUsername');
import('lib.pkp.classes.form.validation.FormValidatorArray');
import('lib.pkp.classes.form.validation.FormValidatorArrayCustom');
import('lib.pkp.classes.form.validation.FormValidatorBoolean');
import('lib.pkp.classes.form.validation.FormValidatorControlledVocab');
import('lib.pkp.classes.form.validation.FormValidatorCustom');
import('lib.pkp.classes.form.validation.FormValidatorReCaptcha');
import('lib.pkp.classes.form.validation.FormValidatorEmail');
import('lib.pkp.classes.form.validation.FormValidatorInSet');
import('lib.pkp.classes.form.validation.FormValidatorLength');
import('lib.pkp.classes.form.validation.FormValidatorLocale');
import('lib.pkp.classes.form.validation.FormValidatorLocaleEmail');
import('lib.pkp.classes.form.validation.FormValidatorCSRF');
import('lib.pkp.classes.form.validation.FormValidatorPost');
import('lib.pkp.classes.form.validation.FormValidatorRegExp');
import('lib.pkp.classes.form.validation.FormValidatorUrl');
import('lib.pkp.classes.form.validation.FormValidatorLocaleUrl');
import('lib.pkp.classes.form.validation.FormValidatorISSN');
import('lib.pkp.classes.form.validation.FormValidatorORCID');
 
class Form {
 
   var $_template;
 
   var $_data;
 
   var $_checks;
 
   var $_errors;
 
   var $errorsArray;
 
   var $errorFields;
 
   var $formSectionErrors;
 
   var $cssValidation;
 
   var $requiredLocale;
 
   var $supportedLocales;
 
   var $defaultLocale;
 
   function __construct($template = null, $callHooks = true, $requiredLocale = null, $supportedLocales = null) {
 
      if ($requiredLocale === null) $requiredLocale = AppLocale::getPrimaryLocale();
      $this->requiredLocale = $requiredLocale;
      if ($supportedLocales === null) $supportedLocales = AppLocale::getSupportedFormLocales();
      $this->supportedLocales = $supportedLocales;
 
      $this->defaultLocale = AppLocale::getLocale();
 
      $this->_template = $template;
      $this->_data = array();
      $this->_checks = array();
      $this->_errors = array();
      $this->errorsArray = array();
      $this->errorFields = array();
      $this->formSectionErrors = array();
 
      if ($callHooks === true) {
         // Call hooks based on the calling entity, assuming
         // this method is only called by a subclass. Results
         // in hook calls named e.g. "papergalleyform::Constructor"
         // Note that class names are always lower case.
         HookRegistry::call(strtolower_codesafe(get_class($this)) . '::Constructor', array($this, &$template));
      }
   }
 
 
   //
   // Setters and Getters
   //
   function setTemplate($template) {
      $this->_template = $template;
   }
 
   function getTemplate() {
      return $this->_template;
   }
 
   function getRequiredLocale() {
      return $this->requiredLocale;
   }
 
   //
   // Public Methods
   //
   function display($request = null, $template = null) {
      $this->fetch($request, $template, true);
   }
 
   function fetch($request, $template = null, $display = false) {
      // Set custom template.
      if (!is_null($template)) $this->_template = $template;
 
      // Call hooks based on the calling entity, assuming
      // this method is only called by a subclass. Results
      // in hook calls named e.g. "papergalleyform::display"
      // Note that class names are always lower case.
      $returner = null;
      if (HookRegistry::call(strtolower_codesafe(get_class($this)) . '::display', array($this, &$returner))) {
         return $returner;
      }
 
      $templateMgr = TemplateManager::getManager($request);
      $templateMgr->setCacheability(CACHEABILITY_NO_STORE);
 
 
      // Attach this form object to the Form Builder Vocabulary for validation to work
      $fbv = $templateMgr->getFBV();
      $fbv->setForm($this);
 
      $templateMgr->assign(array_merge(
         $this->_data,
         array(
            'isError' => !$this->isValid(),
            'errors' => $this->getErrorsArray(),
            'formLocales' => $this->supportedLocales,
            'formLocale' => $this->getDefaultFormLocale(),
         )
      ));
 
      if ($display) {
         $templateMgr->display($this->_template);
         $returner = null;
      } else {
         $returner = $templateMgr->fetch($this->_template);
      }
 
      // Reset the FBV's form in case template manager fetches another template not within a form.
      $fbv->setForm(null);
 
      return $returner;
   }
 
   function getData($key) {
      return isset($this->_data[$key]) ? $this->_data[$key] : null;
   }
 
   function setData($key, $value = null) {
      if (is_array($key)) foreach($key as $aKey => $aValue) {
         $this->setData($aKey, $aValue);
      } else {
         $this->_data[$key] = $value;
      }
   }
 
   function initData() {
      // Call hooks based on the calling entity, assuming
      // this method is only called by a subclass. Results
      // in hook calls named e.g. "papergalleyform::initData"
      // Note that class and function names are always lower
      // case.
      HookRegistry::call(strtolower_codesafe(get_class($this) . '::initData'), array($this));
   }
 
   function readInputData() {
      // Default implementation does nothing.
   }
 
   function validate($callHooks = true) {
      if (!isset($this->errorsArray)) {
         $this->getErrorsArray();
      }
 
      foreach ($this->_checks as $check) {
         if (!isset($this->errorsArray[$check->getField()]) && !$check->isValid()) {
            if (method_exists($check, 'getErrorFields') && method_exists($check, 'isArray') && call_user_func(array(&$check, 'isArray'))) {
               $errorFields = call_user_func(array(&$check, 'getErrorFields'));
               for ($i=0, $count=count($errorFields); $i < $count; $i++) {
                  $this->addError($errorFields[$i], $check->getMessage());
                  $this->errorFields[$errorFields[$i]] = 1;
               }
            } else {
               $this->addError($check->getField(), $check->getMessage());
               $this->errorFields[$check->getField()] = 1;
            }
         }
      }
 
      if ($callHooks === true) {
         // Call hooks based on the calling entity, assuming
         // this method is only called by a subclass. Results
         // in hook calls named e.g. "papergalleyform::validate"
         // Note that class and function names are always lower
         // case.
         $value = null;
         if (HookRegistry::call(strtolower_codesafe(get_class($this) . '::validate'), array($this, &$value))) {
            return $value;
         }
      }
 
      if (!defined('SESSION_DISABLE_INIT')) {
         $request = Application::get()->getRequest();
         $user = $request->getUser();
 
         if (!$this->isValid() && $user) {
            // Create a form error notification.
            import('classes.notification.NotificationManager');
            $notificationManager = new NotificationManager();
            $notificationManager->createTrivialNotification(
               $user->getId(), NOTIFICATION_TYPE_FORM_ERROR, array('contents' => $this->getErrorsArray())
            );
         }
      }
 
      return $this->isValid();
   }
 
   function execute(...$functionArgs) {
      // Call hooks based on the calling entity, assuming
      // this method is only called by a subclass. Results
      // in hook calls named e.g. "papergalleyform::execute"
      // Note that class and function names are always lower
      // case.
      $returner = null;
      HookRegistry::call(strtolower_codesafe(get_class($this) . '::execute'), array_merge(array($this), $functionArgs, array(&$returner)));
      return $returner;
   }
 
   function getLocaleFieldNames() {
      // Call hooks based on the calling entity, assuming
      // this method is only called by a subclass. Results
      // in hook calls named e.g. "papergalleyform::getLocaleFieldNames"
      // Note that class and function names are always lower
      // case.
      $returner = array();
      HookRegistry::call(strtolower_codesafe(get_class($this) . '::getLocaleFieldNames'), array($this, &$returner));
      return $returner;
   }
 
   function getDefaultFormLocale() {
      $formLocale = $this->defaultLocale;
      if (!isset($this->supportedLocales[$formLocale])) $formLocale = $this->requiredLocale;
      return $formLocale;
   }
 
   function setDefaultFormLocale($defaultLocale) {
      $this->defaultLocale = $defaultLocale;
   }
 
   function addSupportedFormLocale($supportedLocale) {
      if (!in_array($supportedLocale, $this->supportedLocales)) {
         $site = Application::get()->getRequest()->getSite();
         $siteSupportedLocales = $site->getSupportedLocaleNames();
         if (array_key_exists($supportedLocale, $siteSupportedLocales)) {
            $this->supportedLocales[$supportedLocale] = $siteSupportedLocales[$supportedLocale];
         }
      }
   }
 
   function readUserVars($vars) {
      // Call hooks based on the calling entity, assuming
      // this method is only called by a subclass. Results
      // in hook calls named e.g. "papergalleyform::readUserVars"
      // Note that class and function names are always lower
      // case.
      HookRegistry::call(strtolower_codesafe(get_class($this) . '::readUserVars'), array($this, &$vars));
      $request = Application::get()->getRequest();
      foreach ($vars as $k) {
         $this->setData($k, $request->getUserVar($k));
      }
   }
 
   function addCheck($formValidator) {
      $this->_checks[] =& $formValidator;
   }
 
   function addError($field, $message) {
      $this->_errors[] = new FormError($field, $message);
   }
 
   function addErrorField($field) {
      $this->errorFields[$field] = 1;
   }
 
   function isValid() {
      return empty($this->_errors);
   }
 
   function getErrorsArray() {
      $this->errorsArray = array();
      foreach ($this->_errors as $error) {
         if (!isset($this->errorsArray[$error->getField()])) {
            $this->errorsArray[$error->getField()] = $error->getMessage();
         }
      }
      return $this->errorsArray;
   }
 
   //
   // Private helper methods
   //
   function _decomposeArray($name, $value, $stack) {
      $returner = '';
      if (is_array($value)) {
         foreach ($value as $key => $subValue) {
            $newStack = $stack;
            $newStack[] = $key;
            $returner .= $this->_decomposeArray($name, $subValue, $newStack);
         }
      } else {
         $name = htmlentities($name, ENT_COMPAT, LOCALE_ENCODING);
         $value = htmlentities($value, ENT_COMPAT, LOCALE_ENCODING);
         $returner .= '<input type="hidden" name="' . $name;
         while (($item = array_shift($stack)) !== null) {
            $item = htmlentities($item, ENT_COMPAT, LOCALE_ENCODING);
            $returner .= '[' . $item . ']';
         }
         $returner .= '" value="' . $value . "\" />\n";
      }
      return $returner;
   }
}