first commit

lib/pkp/classes/form/validation/FormValidator.php

@@ -0,0 +1,193 @@
+<?php
+/**
+ * @defgroup form_validation Form Validation
+ */
+
+/**
+ * @file classes/form/validation/FormValidator.php
+ *
+ * Copyright (c) 2014-2021 Simon Fraser University
+ * Copyright (c) 2000-2021 John Willinsky
+ * Distributed under the GNU GPL v3. For full terms see the file docs/COPYING.
+ *
+ * @class FormValidator
+ *
+ * @ingroup form_validation
+ *
+ * @brief Class to represent a form validation check.
+ */
+
+namespace PKP\form\validation;
+use PKP\form\Form;
+use PKP\validation\Validator;
+
+class FormValidator
+{
+    // The two allowed states for the type field
+    public const FORM_VALIDATOR_OPTIONAL_VALUE = 'optional';
+    public const FORM_VALIDATOR_REQUIRED_VALUE = 'required';
+
+    /** @var Form The Form associated with the check */
+    public $_form;
+
+    /** @var string The name of the field */
+    public $_field;
+
+    /** @var string The type of check ("required" or "optional") */
+    public $_type;
+
+    /** @var string The error message associated with a validation failure */
+    public $_message;
+
+    /** @var Validator The validator used to validate the field */
+    public $_validator;
+
+    /**
+     * Constructor.
+     *
+     * @param Form $form the associated form
+     * @param string $field the name of the associated field
+     * @param string $type the type of check, either "required" or "optional"
+     * @param string $message the error message for validation failures (i18n key)
+     * @param Validator $validator the validator used to validate this form field (optional)
+     */
+    public function __construct(&$form, $field, $type, $message, $validator = null)
+    {
+        $this->_form = & $form;
+        $this->_field = $field;
+        $this->_type = $type;
+        $this->_message = $message;
+        $this->_validator = & $validator;
+
+        $form->cssValidation[$field] = [];
+        if ($type == self::FORM_VALIDATOR_REQUIRED_VALUE) {
+            array_push($form->cssValidation[$field], 'required');
+        }
+    }
+
+
+    //
+    // Setters and Getters
+    //
+    /**
+     * Get the field associated with the check.
+     *
+     * @return string
+     */
+    public function getField()
+    {
+        return $this->_field;
+    }
+
+    /**
+     * Get the error message associated with a failed validation check.
+     *
+     * @return string
+     */
+    public function getMessage()
+    {
+        return __($this->_message);
+    }
+
+    /**
+     * Get the form associated with the check
+     *
+     * @return Form
+     */
+    public function &getForm()
+    {
+        return $this->_form;
+    }
+
+    /**
+     * Get the validator associated with the check
+     *
+     * @return Validator
+     */
+    public function &getValidator()
+    {
+        return $this->_validator;
+    }
+
+    /**
+     * Get the type of the validated field ('optional' or 'required')
+     *
+     * @return string
+     */
+    public function getType()
+    {
+        return $this->_type;
+    }
+
+
+    //
+    // Public methods
+    //
+    /**
+     * Check if field value is valid.
+     * Default check is that field is either optional or not empty.
+     *
+     * @return bool
+     */
+    public function isValid()
+    {
+        if ($this->isEmptyAndOptional()) {
+            return true;
+        }
+
+        $validator = & $this->getValidator();
+        if (is_null($validator)) {
+            // Default check: field must not be empty.
+            $fieldValue = $this->getFieldValue();
+            if (is_scalar($fieldValue)) {
+                return $fieldValue !== '';
+            } else {
+                return $fieldValue !== [];
+            }
+        } else {
+            // Delegate to the validator for the field value check.
+            return $validator->isValid($this->getFieldValue());
+        }
+    }
+
+    //
+    // Protected helper methods
+    //
+    /**
+     * Get field value
+     */
+    public function getFieldValue()
+    {
+        $form = & $this->getForm();
+        $fieldValue = $form->getData($this->getField());
+        if (is_null($fieldValue) || is_scalar($fieldValue)) {
+            $fieldValue = trim((string)$fieldValue);
+        }
+        return $fieldValue;
+    }
+
+    /**
+     * Check if field value is empty and optional.
+     *
+     * @return bool
+     */
+    public function isEmptyAndOptional()
+    {
+        if ($this->getType() != self::FORM_VALIDATOR_OPTIONAL_VALUE) {
+            return false;
+        }
+
+        $fieldValue = $this->getFieldValue();
+        if (is_scalar($fieldValue)) {
+            return $fieldValue == '';
+        } else {
+            return empty($fieldValue);
+        }
+    }
+}
+
+if (!PKP_STRICT_MODE) {
+    class_alias('\PKP\form\validation\FormValidator', '\FormValidator');
+    define('FORM_VALIDATOR_OPTIONAL_VALUE', FormValidator::FORM_VALIDATOR_OPTIONAL_VALUE);
+    define('FORM_VALIDATOR_REQUIRED_VALUE', FormValidator::FORM_VALIDATOR_REQUIRED_VALUE);
+}

lib/pkp/classes/form/validation/FormValidatorArray.php

@@ -0,0 +1,110 @@
+<?php
+
+/**
+ * @file classes/form/validation/FormValidatorArray.php
+ *
+ * Copyright (c) 2014-2021 Simon Fraser University
+ * Copyright (c) 2000-2021 John Willinsky
+ * Distributed under the GNU GPL v3. For full terms see the file docs/COPYING.
+ *
+ * @class FormValidatorArray
+ *
+ * @ingroup form_validation
+ *
+ * @brief Form validation check that checks an array of fields.
+ */
+
+namespace PKP\form\validation;
+
+class FormValidatorArray extends FormValidator
+{
+    /** @var array Array of fields to check */
+    public $_fields;
+
+    /** @var array Array of field names where an error occurred */
+    public $_errorFields;
+
+    /**
+     * Constructor.
+     *
+     * @param \PKP\form\Form $form the associated form
+     * @param string $field the name of the associated field
+     * @param string $type the type of check, either "required" or "optional"
+     * @param string $message the error message for validation failures (i18n key)
+     * @param array $fields all subfields for each item in the array, i.e. name[][foo]. If empty it is assumed that name[] is a data field
+     */
+    public function __construct(&$form, $field, $type, $message, $fields = [])
+    {
+        parent::__construct($form, $field, $type, $message);
+        $this->_fields = $fields;
+        $this->_errorFields = [];
+    }
+
+
+    //
+    // Setters and Getters
+    //
+    /**
+     * Get array of fields where an error occurred.
+     *
+     * @return array
+     */
+    public function getErrorFields()
+    {
+        return $this->_errorFields;
+    }
+
+
+    //
+    // Public methods
+    //
+    /**
+     * @see FormValidator::isValid()
+     * Value is valid if it is empty and optional or all field values are set.
+     *
+     * @return bool
+     */
+    public function isValid()
+    {
+        if ($this->getType() == FormValidator::FORM_VALIDATOR_OPTIONAL_VALUE) {
+            return true;
+        }
+
+        $data = $this->getFieldValue();
+        if (!is_array($data)) {
+            return false;
+        }
+
+        $isValid = true;
+        foreach ($data as $key => $value) {
+            if (count($this->_fields) == 0) {
+                // We expect all fields to contain values.
+                if (is_null($value) || trim((string)$value) == '') {
+                    $isValid = false;
+                    array_push($this->_errorFields, $this->getField() . "[{$key}]");
+                }
+            } else {
+                // In the two-dimensional case we always expect a value array.
+                if (!is_array($value)) {
+                    $isValid = false;
+                    array_push($this->_errorFields, $this->getField() . "[{$key}]");
+                    continue;
+                }
+
+                // Go through all sub-sub-fields and check them explicitly
+                foreach ($this->_fields as $field) {
+                    if (!isset($value[$field]) || trim((string)$value[$field]) == '') {
+                        $isValid = false;
+                        array_push($this->_errorFields, $this->getField() . "[{$key}][{$field}]");
+                    }
+                }
+            }
+        }
+
+        return $isValid;
+    }
+}
+
+if (!PKP_STRICT_MODE) {
+    class_alias('\PKP\form\validation\FormValidatorArray', '\FormValidatorArray');
+}

lib/pkp/classes/form/validation/FormValidatorArrayCustom.php

@@ -0,0 +1,190 @@
+<?php
+
+/**
+ * @file classes/form/validation/FormValidatorArrayCustom.php
+ *
+ * Copyright (c) 2014-2021 Simon Fraser University
+ * Copyright (c) 2000-2021 John Willinsky
+ * Distributed under the GNU GPL v3. For full terms see the file docs/COPYING.
+ *
+ * @class FormValidatorArrayCustom
+ *
+ * @ingroup form_validation
+ *
+ * @brief Form validation check with a custom user function performing the validation check of an array of fields.
+ */
+
+namespace PKP\form\validation;
+
+class FormValidatorArrayCustom extends FormValidator
+{
+    /** @var array Array of fields to check */
+    public $_fields;
+
+    /** @var array Array of field names where an error occurred */
+    public $_errorFields;
+
+    /** @var bool is the field a multilingual-capable field */
+    public $_isLocaleField;
+
+    /** @var callable Custom validation function */
+    public $_userFunction;
+
+    /** @var array Additional arguments to pass to $userFunction */
+    public $_additionalArguments;
+
+    /** @var bool If true, field is considered valid if user function returns false instead of true */
+    public $_complementReturn;
+
+    /**
+     * Constructor.
+     *
+     * @param \PKP\form\Form $form the associated form
+     * @param string $field the name of the associated field
+     * @param string $type the type of check, either "required" or "optional"
+     * @param string $message the error message for validation failures (i18n key)
+     * @param callable $userFunction the user function to use for validation
+     * @param array $additionalArguments optional, a list of additional arguments to pass to $userFunction
+     * @param bool $complementReturn optional, complement the value returned by $userFunction
+     * @param array $fields all subfields for each item in the array, i.e. name[][foo]. If empty it is assumed that name[] is a data field
+     * @param bool $isLocaleField
+     */
+    public function __construct(&$form, $field, $type, $message, $userFunction, $additionalArguments = [], $complementReturn = false, $fields = [], $isLocaleField = false)
+    {
+        parent::__construct($form, $field, $type, $message);
+        $this->_fields = $fields;
+        $this->_errorFields = [];
+        $this->_isLocaleField = $isLocaleField;
+        $this->_userFunction = $userFunction;
+        $this->_additionalArguments = $additionalArguments;
+        $this->_complementReturn = $complementReturn;
+    }
+
+    //
+    // Setters and Getters
+    //
+    /**
+     * Get array of fields where an error occurred.
+     *
+     * @return array
+     */
+    public function getErrorFields()
+    {
+        return $this->_errorFields;
+    }
+
+    /**
+     * Is it a multilingual-capable field.
+     *
+     * @return bool
+     */
+    public function isLocaleField()
+    {
+        return $this->_isLocaleField;
+    }
+
+
+    //
+    // Public methods
+    //
+    /**
+     * @see FormValidator::isValid()
+     *
+     * @return bool
+     */
+    public function isValid()
+    {
+        if ($this->isEmptyAndOptional()) {
+            return true;
+        }
+
+        $data = $this->getFieldValue();
+        if (!is_array($data)) {
+            return false;
+        }
+
+        $isValid = true;
+        foreach ($data as $key => $value) {
+            // Bypass check for empty sub-fields if validation type is "optional"
+            if ($this->getType() == FormValidator::FORM_VALIDATOR_OPTIONAL_VALUE && ($value == [] || $value == '')) {
+                continue;
+            }
+
+            if (count($this->_fields) == 0) {
+                if ($this->isLocaleField()) {
+                    $ret = call_user_func_array($this->_userFunction, array_merge([$value, $key], $this->_additionalArguments));
+                } else {
+                    $ret = call_user_func_array($this->_userFunction, array_merge([$value], $this->_additionalArguments));
+                }
+                $ret = $this->_complementReturn ? !$ret : $ret;
+                if (!$ret) {
+                    $isValid = false;
+                    if ($this->isLocaleField()) {
+                        $this->_errorFields[$key] = $this->getField() . "[{$key}]";
+                    } else {
+                        array_push($this->_errorFields, $this->getField() . "[{$key}]");
+                    }
+                }
+            } else {
+                // In the two-dimensional case we always expect a value array.
+                if (!is_array($value)) {
+                    $isValid = false;
+                    if ($this->isLocaleField()) {
+                        $this->_errorFields[$key] = $this->getField() . "[{$key}]";
+                    } else {
+                        array_push($this->_errorFields, $this->getField() . "[{$key}]");
+                    }
+                    continue;
+                }
+
+                foreach ($this->_fields as $field) {
+                    // Bypass check for empty sub-sub-fields if validation type is "optional"
+                    if ($this->getType() == FormValidator::FORM_VALIDATOR_OPTIONAL_VALUE) {
+                        if (!isset($value[$field]) || $value[$field] == [] or $value[$field] == '') {
+                            continue;
+                        }
+                    } else {
+                        // Make sure that we pass in 'null' to the user function
+                        // if the expected field doesn't exist in the value array.
+                        if (!array_key_exists($field, $value)) {
+                            $value[$field] = null;
+                        }
+                    }
+
+                    if ($this->isLocaleField()) {
+                        $ret = call_user_func_array($this->_userFunction, array_merge([$value[$field], $key], $this->_additionalArguments));
+                    } else {
+                        $ret = call_user_func_array($this->_userFunction, array_merge([$value[$field]], $this->_additionalArguments));
+                    }
+                    $ret = $this->_complementReturn ? !$ret : $ret;
+                    if (!$ret) {
+                        $isValid = false;
+                        if ($this->isLocaleField()) {
+                            if (!isset($this->_errorFields[$key])) {
+                                $this->_errorFields[$key] = [];
+                            }
+                            array_push($this->_errorFields[$key], $this->getField() . "[{$key}][{$field}]");
+                        } else {
+                            array_push($this->_errorFields, $this->getField() . "[{$key}][{$field}]");
+                        }
+                    }
+                }
+            }
+        }
+        return $isValid;
+    }
+
+    /**
+     * Is the field an array.
+     *
+     * @return bool
+     */
+    public function isArray()
+    {
+        return is_array($this->getFieldValue());
+    }
+}
+
+if (!PKP_STRICT_MODE) {
+    class_alias('\PKP\form\validation\FormValidatorArrayCustom', '\FormValidatorArrayCustom');
+}

lib/pkp/classes/form/validation/FormValidatorBoolean.php

@@ -0,0 +1,70 @@
+<?php
+
+/**
+ * @file classes/form/validation/FormValidatorBoolean.php
+ *
+ * Copyright (c) 2014-2021 Simon Fraser University
+ * Copyright (c) 2000-2021 John Willinsky
+ * Distributed under the GNU GPL v3. For full terms see the file docs/COPYING.
+ *
+ * @class FormValidatorBoolean
+ *
+ * @ingroup form_validation
+ *
+ * @brief Form validation check that checks if the value can be
+ *  interpreted as a boolean value. An empty field is considered
+ *  'false', a value of '1' is considered 'true'.
+ */
+
+namespace PKP\form\validation;
+
+class FormValidatorBoolean extends FormValidator
+{
+    /**
+     * Constructor.
+     *
+     * @param \PKP\form\Form $form the associated form
+     * @param string $field the name of the associated field
+     * @param string $message the error message for validation failures (i18n key)
+     */
+    public function __construct(&$form, $field, $message)
+    {
+        parent::__construct($form, $field, FormValidator::FORM_VALIDATOR_OPTIONAL_VALUE, $message);
+    }
+
+
+    //
+    // Public methods
+    //
+    /**
+     * Value is valid if it is empty (false) or has
+     * value '1' (true). This assumes checkbox
+     * behavior in the form.
+     *
+     * @see FormValidator::isValid()
+     *
+     * @return bool
+     */
+    public function isValid()
+    {
+        $value = $this->getFieldValue();
+        $form = & $this->getForm();
+        if (empty($value) || $value == 'on') {
+            // Make sure that the form will contain a real
+            // boolean value after validation.
+            $value = ($value == 'on' ? true : false);
+            $form->setData($this->getField(), $value);
+            return true;
+        } elseif ($value === '1' || $value === '0') {
+            $value = ($value === '1' ? true : false);
+            $form->setData($this->getField(), $value);
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
+
+if (!PKP_STRICT_MODE) {
+    class_alias('\PKP\form\validation\FormValidatorBoolean', '\FormValidatorBoolean');
+}

lib/pkp/classes/form/validation/FormValidatorCSRF.php

@@ -0,0 +1,53 @@
+<?php
+
+/**
+ * @file classes/form/validation/FormValidatorCSRF.php
+ *
+ * Copyright (c) 2014-2021 Simon Fraser University
+ * Copyright (c) 2000-2021 John Willinsky
+ * Distributed under the GNU GPL v3. For full terms see the file docs/COPYING.
+ *
+ * @class FormValidatorCSRF
+ *
+ * @ingroup form_validation
+ *
+ * @brief Form validation check to make sure the CSRF token is correct.
+ */
+
+namespace PKP\form\validation;
+
+use APP\core\Application;
+
+class FormValidatorCSRF extends FormValidator
+{
+    /**
+     * Constructor.
+     *
+     * @param \PKP\form\Form $form
+     * @param string $message the locale key to use (optional)
+     */
+    public function __construct(&$form, $message = 'form.csrfInvalid')
+    {
+        parent::__construct($form, 'dummy', FormValidator::FORM_VALIDATOR_REQUIRED_VALUE, $message);
+    }
+
+
+    //
+    // Public methods
+    //
+    /**
+     * Check if the CSRF token is correct.
+     * overrides FormValidator::isValid()
+     *
+     * @return bool
+     */
+    public function isValid()
+    {
+        $request = Application::get()->getRequest();
+        return $request->checkCSRF();
+    }
+}
+
+if (!PKP_STRICT_MODE) {
+    class_alias('\PKP\form\validation\FormValidatorCSRF', '\FormValidatorCSRF');
+}

lib/pkp/classes/form/validation/FormValidatorControlledVocab.php

@@ -0,0 +1,43 @@
+<?php
+
+/**
+ * @file classes/form/validation/FormValidatorControlledVocab.php
+ *
+ * Copyright (c) 2014-2021 Simon Fraser University
+ * Copyright (c) 2000-2021 John Willinsky
+ * Distributed under the GNU GPL v3. For full terms see the file docs/COPYING.
+ *
+ * @class FormValidatorControlledVocab
+ *
+ * @ingroup form_validation
+ *
+ * @brief Form validation check that checks if value is within a certain set.
+ */
+
+namespace PKP\form\validation;
+
+use PKP\validation\ValidatorControlledVocab;
+
+class FormValidatorControlledVocab extends FormValidator
+{
+    /**
+     * Constructor.
+     *
+     * @param \PKP\form\Form $form the associated form
+     * @param string $field the name of the associated field
+     * @param string $type the type of check, either "required" or "optional"
+     * @param string $message the error message for validation failures (i18n key)
+     * @param string $symbolic
+     * @param int $assocType
+     * @param int $assocId
+     */
+    public function __construct(&$form, $field, $type, $message, $symbolic, $assocType, $assocId)
+    {
+        $validator = new ValidatorControlledVocab($symbolic, $assocType, $assocId);
+        parent::__construct($form, $field, $type, $message, $validator);
+    }
+}
+
+if (!PKP_STRICT_MODE) {
+    class_alias('\PKP\form\validation\FormValidatorControlledVocab', '\FormValidatorControlledVocab');
+}

lib/pkp/classes/form/validation/FormValidatorCustom.php

@@ -0,0 +1,91 @@
+<?php
+
+/**
+ * @file classes/form/validation/FormValidatorCustom.php
+ *
+ * Copyright (c) 2014-2021 Simon Fraser University
+ * Copyright (c) 2000-2021 John Willinsky
+ * Distributed under the GNU GPL v3. For full terms see the file docs/COPYING.
+ *
+ * @class FormValidatorCustom
+ *
+ * @ingroup form_validation
+ *
+ * @brief Form validation check with a custom user function performing the validation check.
+ */
+
+namespace PKP\form\validation;
+
+class FormValidatorCustom extends FormValidator
+{
+    /** @var callable Custom validation function */
+    public $_userFunction;
+
+    /** @var array Additional arguments to pass to $userFunction */
+    public $_additionalArguments;
+
+    /** @var bool If true, field is considered valid if user function returns false instead of true */
+    public $_complementReturn;
+
+    /** @var mixed[] Arguments to pass to getMessage() */
+    public $_messageArgs = [];
+
+    /** @var array If present, additional arguments to pass to the getMessage translation function
+     * The user function is passed the form data as its first argument and $additionalArguments, if set, as the remaining arguments. This function must return a boolean value.
+     *
+     * @param \PKP\form\Form $form the associated form
+     * @param string $field the name of the associated field
+     * @param string $type the type of check, either "required" or "optional"
+     * @param string $message the error message for validation failures (i18n key)
+     * @param callable $userFunction function the user function to use for validation
+     * @param array $additionalArguments optional, a list of additional arguments to pass to $userFunction
+     * @param bool $complementReturn optional, complement the value returned by $userFunction
+     * @param array $messageArgs optional, arguments to pass to getMessage()
+     */
+    public function __construct(&$form, $field, $type, $message, $userFunction, $additionalArguments = [], $complementReturn = false, $messageArgs = [])
+    {
+        parent::__construct($form, $field, $type, $message);
+        $this->_userFunction = $userFunction;
+        $this->_additionalArguments = $additionalArguments;
+        $this->_complementReturn = $complementReturn;
+        $this->_messageArgs = $messageArgs;
+    }
+
+
+    //
+    // Setters and Getters
+    //
+    /**
+     * @see FormValidator::getMessage()
+     *
+     * @return string
+     */
+    public function getMessage()
+    {
+        return __($this->_message, $this->_messageArgs);
+    }
+
+
+    //
+    // Public methods
+    //
+    /**
+     * @see FormValidator::isValid()
+     * Value is valid if it is empty and optional or validated by user-supplied function.
+     *
+     * @return bool
+     */
+    public function isValid()
+    {
+        if ($this->isEmptyAndOptional()) {
+            return true;
+        } else {
+            $ret = call_user_func_array($this->_userFunction, array_merge([$this->getFieldValue()], $this->_additionalArguments));
+            return $this->_complementReturn ? !$ret : $ret;
+        }
+    }
+}
+
+if (!PKP_STRICT_MODE) {
+    class_alias('\PKP\form\validation\FormValidatorCustom', '\FormValidatorCustom');
+}

lib/pkp/classes/form/validation/FormValidatorEmail.php

@@ -0,0 +1,48 @@
+<?php
+
+/**
+ * @file classes/form/validation/FormValidatorEmail.php
+ *
+ * Copyright (c) 2014-2021 Simon Fraser University
+ * Copyright (c) 2000-2021 John Willinsky
+ * Distributed under the GNU GPL v3. For full terms see the file docs/COPYING.
+ *
+ * @class FormValidatorEmail
+ *
+ * @ingroup form_validation
+ *
+ * @see FormValidator
+ *
+ * @brief Form validation check for email addresses.
+ */
+
+namespace PKP\form\validation;
+
+use PKP\validation\ValidatorEmail;
+
+class FormValidatorEmail extends FormValidator
+{
+    /**
+     * Constructor.
+     *
+     * @param \PKP\form\Form $form the associated form
+     * @param string $field the name of the associated field
+     * @param string $type the type of check, either "required" or "optional"
+     * @param string $message the error message for validation failures (i18n key)
+     */
+    public function __construct(&$form, $field, $type = 'optional', $message = 'email.invalid')
+    {
+        $validator = new ValidatorEmail();
+        parent::__construct($form, $field, $type, $message, $validator);
+        array_push($form->cssValidation[$field], 'email');
+    }
+
+    public function getMessage()
+    {
+        return __($this->_message, ['email' => $this->getFieldValue()]);
+    }
+}
+
+if (!PKP_STRICT_MODE) {
+    class_alias('\PKP\form\validation\FormValidatorEmail', '\FormValidatorEmail');
+}

lib/pkp/classes/form/validation/FormValidatorISSN.php

@@ -0,0 +1,40 @@
+<?php
+
+/**
+ * @file classes/form/validation/FormValidatorISSN.php
+ *
+ * Copyright (c) 2014-2021 Simon Fraser University
+ * Copyright (c) 2000-2021 John Willinsky
+ * Distributed under the GNU GPL v3. For full terms see the file docs/COPYING.
+ *
+ * @class FormValidatorISSN
+ *
+ * @ingroup form_validation
+ *
+ * @brief Form validation check for ISSNs.
+ */
+
+namespace PKP\form\validation;
+
+use PKP\validation\ValidatorISSN;
+
+class FormValidatorISSN extends FormValidator
+{
+    /**
+     * Constructor.
+     *
+     * @param \PKP\form\Form $form the associated form
+     * @param string $field the name of the associated field
+     * @param string $type the type of check, either "required" or "optional"
+     * @param string $message the error message for validation failures (i18n key)
+     */
+    public function __construct($form, $field, $type, $message)
+    {
+        $validator = new ValidatorISSN();
+        parent::__construct($form, $field, $type, $message, $validator);
+    }
+}
+
+if (!PKP_STRICT_MODE) {
+    class_alias('\PKP\form\validation\FormValidatorISSN', '\FormValidatorISSN');
+}

lib/pkp/classes/form/validation/FormValidatorInSet.php

@@ -0,0 +1,58 @@
+<?php
+
+/**
+ * @file classes/form/validation/FormValidatorInSet.php
+ *
+ * Copyright (c) 2014-2021 Simon Fraser University
+ * Copyright (c) 2000-2021 John Willinsky
+ * Distributed under the GNU GPL v3. For full terms see the file docs/COPYING.
+ *
+ * @class FormValidatorInSet
+ *
+ * @ingroup form_validation
+ *
+ * @brief Form validation check that checks if value is within a certain set.
+ */
+
+namespace PKP\form\validation;
+
+class FormValidatorInSet extends FormValidator
+{
+    /** @var array of all values accepted as valid */
+    public $_acceptedValues;
+
+    /**
+     * Constructor.
+     *
+     * @param \PKP\form\Form $form the associated form
+     * @param string $field the name of the associated field
+     * @param string $type the type of check, either "required" or "optional"
+     * @param string $message the error message for validation failures (i18n key)
+     * @param array $acceptedValues all possible accepted values
+     */
+    public function __construct(&$form, $field, $type, $message, $acceptedValues)
+    {
+        parent::__construct($form, $field, $type, $message);
+        $this->_acceptedValues = $acceptedValues;
+    }
+
+
+    //
+    // Public methods
+    //
+    /**
+     * Value is valid if it is empty and optional or is in the set of accepted values.
+     *
+     * @see FormValidator::isValid()
+     *
+     * @return bool
+     */
+    public function isValid()
+    {
+        return $this->isEmptyAndOptional() || in_array($this->getFieldValue(), $this->_acceptedValues);
+    }
+}
+
+if (!PKP_STRICT_MODE) {
+    class_alias('\PKP\form\validation\FormValidatorInSet', '\FormValidatorInSet');
+}

lib/pkp/classes/form/validation/FormValidatorLength.php

@@ -0,0 +1,97 @@
+<?php
+
+/**
+ * @file classes/form/validation/FormValidatorLength.php
+ *
+ * Copyright (c) 2014-2021 Simon Fraser University
+ * Copyright (c) 2000-2021 John Willinsky
+ * Distributed under the GNU GPL v3. For full terms see the file docs/COPYING.
+ *
+ * @class FormValidatorLength
+ *
+ * @ingroup form_validation
+ *
+ * @brief Form validation check that checks if a field's length meets certain requirements.
+ */
+
+namespace PKP\form\validation;
+
+use PKP\core\PKPString;
+
+class FormValidatorLength extends FormValidator
+{
+    /** @var string comparator to use (== | != | < | > | <= | >= ) */
+    public $_comparator;
+
+    /** @var int length to compare with */
+    public $_length;
+
+    /**
+     * Constructor.
+     *
+     * @param \PKP\form\Form $form the associated form
+     * @param string $field the name of the associated field
+     * @param string $type the type of check, either "required" or "optional"
+     * @param string $message the error message for validation failures (i18n key)
+     * @param string $comparator
+     * @param int $length
+     */
+    public function __construct(&$form, $field, $type, $message, $comparator, $length)
+    {
+        parent::__construct($form, $field, $type, $message);
+        $this->_comparator = $comparator;
+        $this->_length = $length;
+    }
+
+
+    //
+    // Setters and Getters
+    //
+    /**
+     * @see FormValidator::getMessage()
+     *
+     * @return string
+     */
+    public function getMessage()
+    {
+        return __($this->_message, ['length' => $this->_length]);
+    }
+
+
+    //
+    // Public methods
+    //
+    /**
+     * @see FormValidator::isValid()
+     * Value is valid if it is empty and optional or meets the specified length requirements.
+     *
+     * @return bool
+     */
+    public function isValid()
+    {
+        if ($this->isEmptyAndOptional()) {
+            return true;
+        } else {
+            $length = PKPString::strlen($this->getFieldValue());
+            switch ($this->_comparator) {
+                case '==':
+                    return $length == $this->_length;
+                case '!=':
+                    return $length != $this->_length;
+                case '<':
+                    return $length < $this->_length;
+                case '>':
+                    return $length > $this->_length;
+                case '<=':
+                    return $length <= $this->_length;
+                case '>=':
+                    return $length >= $this->_length;
+            }
+            return false;
+        }
+    }
+}
+
+if (!PKP_STRICT_MODE) {
+    class_alias('\PKP\form\validation\FormValidatorLength', '\FormValidatorLength');
+}

lib/pkp/classes/form/validation/FormValidatorLocale.php

@@ -0,0 +1,84 @@
+<?php
+
+/**
+ * @file classes/form/validation/FormValidatorLocale.php
+ *
+ * Copyright (c) 2014-2021 Simon Fraser University
+ * Copyright (c) 2000-2021 John Willinsky
+ * Distributed under the GNU GPL v3. For full terms see the file docs/COPYING.
+ *
+ * @class FormValidatorLocale
+ *
+ * @ingroup form_validation
+ *
+ * @brief Class to represent a form validation check for localized fields.
+ */
+
+namespace PKP\form\validation;
+
+use PKP\facades\Locale;
+
+class FormValidatorLocale extends FormValidator
+{
+    /** @var string Symbolic name of the locale to require */
+    public $_requiredLocale;
+
+    /**
+     * Constructor.
+     *
+     * @param \PKP\form\Form $form the associated form
+     * @param string $field the name of the associated field
+     * @param string $type the type of check, either "required" or "optional"
+     * @param string $message the error message for validation failures (i18n key)
+     * @param \PKP\validation\Validator $validator the validator used to validate this form field (optional)
+     * @param string $requiredLocale The name of the required locale, i.e. en
+     */
+    public function __construct(&$form, $field, $type, $message, $requiredLocale = null, $validator = null)
+    {
+        parent::__construct($form, $field, $type, $message, $validator);
+        if ($requiredLocale === null) {
+            $requiredLocale = Locale::getPrimaryLocale();
+        }
+        $this->_requiredLocale = $requiredLocale;
+    }
+
+    //
+    // Getters and Setters
+    //
+    /**
+     * Get the error message associated with a failed validation check.
+     *
+     * @see FormValidator::getMessage()
+     *
+     * @return string
+     */
+    public function getMessage()
+    {
+        return parent::getMessage() . ' (' . Locale::getMetadata($this->_requiredLocale)->getDisplayName() . ')';
+    }
+
+    //
+    // Protected helper methods
+    //
+    /**
+     * @see FormValidator::getFieldValue()
+     */
+    public function getFieldValue()
+    {
+        $form = & $this->getForm();
+        $data = $form->getData($this->getField());
+
+        $fieldValue = '';
+        if (is_array($data) && isset($data[$this->_requiredLocale])) {
+            $fieldValue = $data[$this->_requiredLocale];
+            if (is_scalar($fieldValue)) {
+                $fieldValue = trim((string)$fieldValue);
+            }
+        }
+        return $fieldValue;
+    }
+}
+
+if (!PKP_STRICT_MODE) {
+    class_alias('\PKP\form\validation\FormValidatorLocale', '\FormValidatorLocale');
+}

lib/pkp/classes/form/validation/FormValidatorLocaleEmail.php

@@ -0,0 +1,43 @@
+<?php
+
+/**
+ * @file classes/form/validation/FormValidatorLocaleEmail.php
+ *
+ * Copyright (c) 2014-2021 Simon Fraser University
+ * Copyright (c) 2000-2021 John Willinsky
+ * Distributed under the GNU GPL v3. For full terms see the file docs/COPYING.
+ *
+ * @class FormValidatorLocaleEmail
+ *
+ * @ingroup form_validation
+ *
+ * @see FormValidatorLocale
+ *
+ * @brief Form validation check for email addresses.
+ */
+
+namespace PKP\form\validation;
+
+use PKP\validation\ValidatorEmail;
+
+class FormValidatorLocaleEmail extends FormValidatorLocale
+{
+    /**
+     * Constructor.
+     *
+     * @param \PKP\form\Form $form the associated form
+     * @param string $field the name of the associated field
+     * @param string $type the type of check, either "required" or "optional"
+     * @param string $message the error message for validation failures (i18n key)
+     * @param string $requiredLocale The symbolic name of the required locale
+     */
+    public function __construct(&$form, $field, $type, $message, $requiredLocale = null)
+    {
+        $validator = new ValidatorEmail();
+        parent::__construct($form, $field, $type, $message, $requiredLocale, $validator);
+    }
+}
+
+if (!PKP_STRICT_MODE) {
+    class_alias('\PKP\form\validation\FormValidatorLocaleEmail', '\FormValidatorLocaleEmail');
+}

lib/pkp/classes/form/validation/FormValidatorLocaleUrl.php

@@ -0,0 +1,44 @@
+<?php
+
+/**
+ * @file classes/form/validation/FormValidatorLocaleUrl.php
+ *
+ * Copyright (c) 2014-2021 Simon Fraser University
+ * Copyright (c) 2000-2021 John Willinsky
+ * Distributed under the GNU GPL v3. For full terms see the file docs/COPYING.
+ *
+ * @class FormValidatorLocaleUrl
+ *
+ * @ingroup form_validation
+ *
+ * @see FormValidatorLocale
+ *
+ * @brief Form validation check for URL addresses.
+ */
+
+namespace PKP\form\validation;
+
+;
+use PKP\validation\ValidatorUrl;
+
+class FormValidatorLocaleUrl extends FormValidatorLocale
+{
+    /**
+     * Constructor.
+     *
+     * @param \PKP\form\Form $form the associated form
+     * @param string $field the name of the associated field
+     * @param string $type the type of check, either "required" or "optional"
+     * @param string $message the error message for validation failures (i18n key)
+     * @param string $requiredLocale The symbolic name of the required locale
+     */
+    public function __construct(&$form, $field, $type, $message, $requiredLocale = null)
+    {
+        $validator = new ValidatorUrl();
+        parent::__construct($form, $field, $type, $message, $requiredLocale, $validator);
+    }
+}
+
+if (!PKP_STRICT_MODE) {
+    class_alias('\PKP\form\validation\FormValidatorLocaleUrl', '\FormValidatorLocaleUrl');
+}

lib/pkp/classes/form/validation/FormValidatorORCID.php

@@ -0,0 +1,41 @@
+<?php
+
+/**
+ * @file classes/form/validation/FormValidatorORCID.php
+ *
+ * Copyright (c) 2013-2021 Simon Fraser University
+ * Copyright (c) 2000-2021 John Willinsky
+ * Distributed under the GNU GPL v3. For full terms see the file docs/COPYING.
+ *
+ * @class FormValidatorORCID
+ *
+ * @ingroup form_validation
+ *
+ * @brief Form validation check for ORCID iDs.
+ */
+
+namespace PKP\form\validation;
+
+;
+use PKP\validation\ValidatorORCID;
+
+class FormValidatorORCID extends FormValidator
+{
+    /**
+     * Constructor.
+     *
+     * @param \PKP\form\Form $form the associated form
+     * @param string $field the name of the associated field
+     * @param string $type the type of check, either "required" or "optional"
+     * @param string $message the error message for validation failures (i18n key)
+     */
+    public function __construct($form, $field, $type, $message)
+    {
+        $validator = new ValidatorORCID();
+        parent::__construct($form, $field, $type, $message, $validator);
+    }
+}
+
+if (!PKP_STRICT_MODE) {
+    class_alias('\PKP\form\validation\FormValidatorORCID', '\FormValidatorORCID');
+}

lib/pkp/classes/form/validation/FormValidatorPost.php

@@ -0,0 +1,53 @@
+<?php
+
+/**
+ * @file classes/form/validation/FormValidatorPost.php
+ *
+ * Copyright (c) 2014-2021 Simon Fraser University
+ * Copyright (c) 2000-2021 John Willinsky
+ * Distributed under the GNU GPL v3. For full terms see the file docs/COPYING.
+ *
+ * @class FormValidatorPost
+ *
+ * @ingroup form_validation
+ *
+ * @brief Form validation check to make sure the form is POSTed.
+ */
+
+namespace PKP\form\validation;
+
+use APP\core\Application;
+
+class FormValidatorPost extends FormValidator
+{
+    /**
+     * Constructor.
+     *
+     * @param \PKP\form\Form $form
+     * @param string $message the locale key to use (optional)
+     */
+    public function __construct(&$form, $message = 'form.postRequired')
+    {
+        parent::__construct($form, 'dummy', FormValidator::FORM_VALIDATOR_REQUIRED_VALUE, $message);
+    }
+
+
+    //
+    // Public methods
+    //
+    /**
+     * Check if form was posted.
+     * overrides FormValidator::isValid()
+     *
+     * @return bool
+     */
+    public function isValid()
+    {
+        $request = Application::get()->getRequest();
+        return $request->isPost();
+    }
+}
+
+if (!PKP_STRICT_MODE) {
+    class_alias('\PKP\form\validation\FormValidatorPost', '\FormValidatorPost');
+}

lib/pkp/classes/form/validation/FormValidatorReCaptcha.php

@@ -0,0 +1,135 @@
+<?php
+
+/**
+ * @file classes/form/validation/FormValidatorReCaptcha.php
+ *
+ * Copyright (c) 2014-2021 Simon Fraser University
+ * Copyright (c) 2000-2021 John Willinsky
+ * Distributed under the GNU GPL v3. For full terms see the file docs/COPYING.
+ *
+ * @class FormValidatorReCaptcha
+ *
+ * @ingroup form_validation
+ *
+ * @brief Form validation check reCaptcha values.
+ */
+
+namespace PKP\form\validation;
+
+use APP\core\Application;
+use Exception;
+use InvalidArgumentException;
+use PKP\config\Config;
+use PKP\form\Form;
+
+class FormValidatorReCaptcha extends FormValidator
+{
+    /** @var string The response field containing the reCaptcha response */
+    private const RECAPTCHA_RESPONSE_FIELD = 'g-recaptcha-response';
+    /** @var string The request URL */
+    private const RECAPTCHA_URL = 'https://www.google.com/recaptcha/api/siteverify';
+    /** @var string The initiating IP address of the user */
+    private $_userIp;
+    /** @var string The hostname to expect in the validation response */
+    private $_hostname;
+
+    /**
+     * Constructor.
+     *
+     * @param \PKP\form\Form $form
+     * @param string $userIp IP address of user request
+     * @param string $message Key of message to display on mismatch
+     * @param string|null $hostname Hostname to expect in validation response
+     */
+    public function __construct(Form $form, string $userIp, string $message, ?string $hostname = null)
+    {
+        parent::__construct($form, self::RECAPTCHA_RESPONSE_FIELD, FormValidator::FORM_VALIDATOR_REQUIRED_VALUE, $message);
+        $this->_userIp = $userIp;
+        $this->_hostname = $hostname;
+    }
+
+    //
+    // Public methods
+    //
+    /**
+     * @see FormValidator::isValid()
+     * Determine whether or not the form meets this ReCaptcha constraint.
+     *
+     */
+    public function isValid(): bool
+    {
+        $form = $this->getForm();
+        try {
+            $this->validateResponse($form->getData(self::RECAPTCHA_RESPONSE_FIELD), $this->_userIp, $this->_hostname);
+            return true;
+        } catch (Exception $exception) {
+            $this->_message = 'common.captcha.error.missing-input-response';
+            return false;
+        }
+    }
+
+    /**
+     * Validates the reCaptcha response
+     *
+     * @param string|null $response The reCaptcha response
+     * @param string|null $ip The user IP address (defaults to null)
+     * @param string|null $hostname The application hostname (defaults to null)
+     *
+     * @throws Exception Throws in case the validation fails
+     */
+    public static function validateResponse(?string $response, ?string $ip = null, ?string $hostname = null): void
+    {
+        if (!empty($ip) && !filter_var($ip, FILTER_VALIDATE_IP)) {
+            throw new InvalidArgumentException('Invalid IP address.');
+        }
+
+        if (empty($response)) {
+            throw new InvalidArgumentException('The reCaptcha user response is required.');
+        }
+
+        $privateKey = Config::getVar('captcha', 'recaptcha_private_key');
+        if (empty($privateKey)) {
+            throw new Exception('The reCaptcha is not configured correctly, the secret key is missing.');
+        }
+
+        $httpClient = Application::get()->getHttpClient();
+        $response = $httpClient->request(
+            'POST',
+            self::RECAPTCHA_URL,
+            [
+                'multipart' => [
+                    ['name' => 'secret', 'contents' => $privateKey],
+                    ['name' => 'response', 'contents' => $response],
+                    ['name' => 'remoteip', 'contents' => $ip]
+                ]
+            ]
+        );
+
+        $response = json_decode($response->getBody(), true);
+        if (Config::getVar('captcha', 'recaptcha_enforce_hostname') && ($response['hostname'] ?? null) != $hostname) {
+            throw new Exception('The hostname validation of the reCaptcha response failed.');
+        }
+
+        $errorMap = [
+            'missing-input-secret' => 'The secret parameter is missing.',
+            'invalid-input-secret' => 'The secret parameter is invalid or malformed.',
+            'missing-input-response' => 'The response parameter is missing.',
+            'invalid-input-response' => 'The response parameter is invalid or malformed.',
+            'invalid-keys' => 'The configured keys are invalid.',
+            'bad-request' => 'The request is invalid or malformed.',
+            'timeout-or-duplicate' => 'The response is no longer valid: either is too old or has been used previously.'
+        ];
+
+        if (!($response['success'] ?? false)) {
+            $errors = [];
+            foreach ($response['error-codes'] ?? [] as $error) {
+                $errors[] = $errorMap[$error] ?? $error;
+            }
+            throw new Exception(implode("\n", $errors) ?: 'The reCaptcha validation failed.');
+        }
+    }
+}
+
+if (!PKP_STRICT_MODE) {
+    class_alias('\PKP\form\validation\FormValidatorReCaptcha', '\FormValidatorReCaptcha');
+}

lib/pkp/classes/form/validation/FormValidatorRegExp.php

@@ -0,0 +1,42 @@
+<?php
+
+/**
+ * @file classes/form/validation/FormValidatorRegExp.php
+ *
+ * Copyright (c) 2014-2021 Simon Fraser University
+ * Copyright (c) 2000-2021 John Willinsky
+ * Distributed under the GNU GPL v3. For full terms see the file docs/COPYING.
+ *
+ * @class FormValidatorRegExp
+ *
+ * @ingroup form_validation
+ *
+ * @brief Form validation check using a regular expression.
+ */
+
+namespace PKP\form\validation;
+
+;
+use PKP\validation\ValidatorRegExp;
+
+class FormValidatorRegExp extends FormValidator
+{
+    /**
+     * Constructor.
+     *
+     * @param \PKP\form\Form $form the associated form
+     * @param string $field the name of the associated field
+     * @param string $type the type of check, either "required" or "optional"
+     * @param string $message the error message for validation failures (i18n key)
+     * @param string $regExp the regular expression (PCRE form)
+     */
+    public function __construct(&$form, $field, $type, $message, $regExp)
+    {
+        $validator = new ValidatorRegExp($regExp);
+        parent::__construct($form, $field, $type, $message, $validator);
+    }
+}
+
+if (!PKP_STRICT_MODE) {
+    class_alias('\PKP\form\validation\FormValidatorRegExp', '\FormValidatorRegExp');
+}

lib/pkp/classes/form/validation/FormValidatorUrl.php

@@ -0,0 +1,44 @@
+<?php
+
+/**
+ * @file classes/form/validation/FormValidatorUrl.php
+ *
+ * Copyright (c) 2014-2021 Simon Fraser University
+ * Copyright (c) 2000-2021 John Willinsky
+ * Distributed under the GNU GPL v3. For full terms see the file docs/COPYING.
+ *
+ * @class FormValidatorUrl
+ *
+ * @ingroup form_validation
+ *
+ * @see FormValidator
+ *
+ * @brief Form validation check for URLs.
+ */
+
+namespace PKP\form\validation;
+
+;
+use PKP\validation\ValidatorUrl;
+
+class FormValidatorUrl extends FormValidator
+{
+    /**
+     * Constructor.
+     *
+     * @param \PKP\form\Form $form the associated form
+     * @param string $field the name of the associated field
+     * @param string $type the type of check, either "required" or "optional"
+     * @param string $message the error message for validation failures (i18n key)
+     */
+    public function __construct(&$form, $field, $type, $message)
+    {
+        $validator = new ValidatorUrl();
+        parent::__construct($form, $field, $type, $message, $validator);
+        array_push($form->cssValidation[$field], 'url');
+    }
+}
+
+if (!PKP_STRICT_MODE) {
+    class_alias('\PKP\form\validation\FormValidatorUrl', '\FormValidatorUrl');
+}

lib/pkp/classes/form/validation/FormValidatorUsername.php

@@ -0,0 +1,48 @@
+<?php
+
+/**
+ * @file classes/form/validation/FormValidatorUsername.php
+ *
+ * Copyright (c) 2014-2021 Simon Fraser University
+ * Copyright (c) 2000-2021 John Willinsky
+ * Distributed under the GNU GPL v3. For full terms see the file docs/COPYING.
+ *
+ * @class FormValidatorUsername
+ *
+ * @ingroup form_validation
+ *
+ * @see FormValidator
+ *
+ * @brief Form validation check for usernames (lowercase alphanumeric with interior dash/underscore
+ */
+
+namespace PKP\form\validation;
+
+;
+use PKP\validation\ValidatorRegExp;
+
+class FormValidatorUsername extends FormValidator
+{
+    /**
+     * Constructor.
+     *
+     * @param \PKP\form\Form $form the associated form
+     * @param string $field the name of the associated field
+     * @param string $type the type of check, either "required" or "optional"
+     * @param string $message the error message for validation failures (i18n key)
+     */
+    public function __construct(&$form, $field, $type, $message)
+    {
+        parent::__construct(
+            $form,
+            $field,
+            $type,
+            $message,
+            new ValidatorRegExp('/^[a-z0-9]+([\-_][a-z0-9]+)*$/')
+        );
+    }
+}
+
+if (!PKP_STRICT_MODE) {
+    class_alias('\PKP\form\validation\FormValidatorUsername', '\FormValidatorUsername');
+}