/**
* This function first gets values from mapped fields and then check these values against
* Mollom web service and then notify callback object with the spam checking result.
* @param Validator $validator
* @return boolean - true when Mollom confirms that the submission is ham (not spam)
* - false when Mollom confirms that the submission is spam
* - false when Mollom say 'unsure'.
* In this case, 'mollom_captcha_requested' session is set to true
* so that Field() knows it's time to display captcha
*/
public function validate($validator)
{
// Check that, if necessary, the user has given permission to check for spam
$requireConfirmation = Config::inst()->get('AkismetSpamProtector', 'require_confirmation');
if ($requireConfirmation && !$this->Value()) {
$validator->validationError($this->name, _t('AkismetField.NOTIFICATIONREQUIRED', 'You must give consent to submit this content to spam detection'), "error");
return false;
}
// Check result
$isSpam = $this->getIsSpam();
if (!$isSpam) {
return true;
}
// Save error message
$errorMessage = _t('AkismetField.SPAM', "Your submission has been rejected because it was treated as spam.");
// If spam should be allowed, let it pass and save it for later
if (Config::inst()->get('AkismetSpamProtector', 'save_spam')) {
// In order to save spam but still display the spam message, we must mock a form message
// without failing the validation
$errors = array(array('fieldName' => $this->name, 'message' => $errorMessage, 'messageType' => 'error'));
$formName = $this->getForm()->FormName();
Session::set("FormInfo.{$formName}.errors", $errors);
return true;
} else {
// Mark as spam
$validator->validationError($this->name, $errorMessage, "error");
return false;
}
}
/**
* Validate this field as a valid hostname
*
* @param Validator $validator
* @return bool
*/
public function validate($validator)
{
if ($this->checkHostname($this->Value())) {
return true;
}
$validator->validationError($this->getName(), _t("DomainNameField.INVALID_DOMAIN", "Invalid domain name"), "validation");
return false;
}
/**
* Validate this field
*
* @param Validator $validator
* @return bool
*/
public function validate($validator)
{
if (!is_null($this->maxLength) && mb_strlen($this->value) > $this->maxLength) {
$validator->validationError($this->name, _t('TextField.VALIDATEMAXLENGTH', 'The value for {name} must not exceed {maxLength} characters in length', array('name' => $this->getName(), 'maxLength' => $this->maxLength)), "validation");
return false;
}
return true;
}
/**
* Validate this field
*
* @param Validator $validator
* @return bool
*/
public function validate($validator)
{
if (!$this->value) {
return true;
}
if ($this->isNumeric()) {
return true;
}
$validator->validationError($this->name, _t('NumericField.VALIDATION', "'{value}' is not a number, only numbers can be accepted for this field", array('value' => $this->value)), "validation");
return false;
}
/**
* Validate this field
*
* @param Validator $validator
* @return bool
*/
public function validate($validator)
{
if (self::getValidateOnSubmit()) {
return true;
} else {
if (strtoupper($this->value) === SimpleCaptchaController::getCaptchaID()) {
return true;
}
$validator->validationError($this->name, sprintf("%s is wrong, Correct captcha is required", $this->value), "validation");
return false;
}
}
/**
* Validates for RFC 2822 compliant email addresses.
*
* @see http://www.regular-expressions.info/email.html
* @see http://www.ietf.org/rfc/rfc2822.txt
*
* @param Validator $validator
*
* @return string
*/
public function validate($validator)
{
$this->value = trim($this->value);
$pattern = '^[a-z0-9!#$%&\'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&\'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$';
// Escape delimiter characters.
$safePattern = str_replace('/', '\\/', $pattern);
if ($this->value && !preg_match('/' . $safePattern . '/i', $this->value)) {
$validator->validationError($this->name, _t('EmailField.VALIDATION', 'Please enter an email address'), 'validation');
return false;
}
return true;
}
/**
* Checks if a certain field value is valid.
*
* @param string $value
* @param Validator $validator
*/
public function validateValue($value, $validator)
{
if (!$this->Required) {
return;
}
if (is_array($value)) {
return;
}
// eg. checkbox set values
if (!strlen($value)) {
$validator->validationError('MetadataRaw', sprintf('The metadata field "%s" on the "%s" schema is required', $this->Title, $this->Schema()->Title), 'validation');
}
}
/**
* Validates for RFC 2822 compliant email adresses.
*
* @see http://www.regular-expressions.info/email.html
* @see http://www.ietf.org/rfc/rfc2822.txt
*
* @param Validator $validator
* @return String
*/
function validate($validator)
{
$this->value = trim($this->value);
$pcrePattern = '^[a-z0-9!#$%&\'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&\'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$';
// PHP uses forward slash (/) to delimit start/end of pattern, so it must be escaped
$pregSafePattern = str_replace('/', '\\/', $pcrePattern);
if ($this->value && !preg_match('/' . $pregSafePattern . '/i', $this->value)) {
$validator->validationError($this->name, _t('EmailField.VALIDATION', "Please enter an email address."), "validation");
return false;
} else {
return true;
}
}
/**
* Validate this field
*
* @param Validator $validator
* @return bool
*/
public function validate($validator)
{
$value = isset($_POST[$this->name . '_custom']) ? $_POST[$this->name . '_custom'] : null;
if (!$value) {
return true;
}
// no custom value, don't validate
// Check that the current date with the date format is valid or not
require_once 'Zend/Date.php';
$date = Zend_Date::now()->toString($value);
$valid = Zend_Date::isDate($date, $value);
if ($valid) {
return true;
} else {
if ($validator) {
$validator->validationError($this->name, _t('MemberDatetimeOptionsetField.DATEFORMATBAD', "Date format is invalid"), "validation", false);
}
return false;
}
}
/**
* Validate this field
*
* @param Validator $validator
* @return bool
*/
public function validate($validator)
{
$name = $this->name;
// if field isn't visible, don't validate
if (!$this->isSaveable()) {
return true;
}
$this->passwordField->setValue($this->value);
$this->confirmPasswordfield->setValue($this->confirmValue);
$value = $this->passwordField->Value();
// both password-fields should be the same
if ($value != $this->confirmPasswordfield->Value()) {
$validator->validationError($name, _t('Form.VALIDATIONPASSWORDSDONTMATCH', "Passwords don't match"), "validation");
return false;
}
if (!$this->canBeEmpty) {
// both password-fields shouldn't be empty
if (!$value || !$this->confirmPasswordfield->Value()) {
$validator->validationError($name, _t('Form.VALIDATIONPASSWORDSNOTEMPTY', "Passwords can't be empty"), "validation");
return false;
}
}
// lengths
if ($this->minLength || $this->maxLength) {
$errorMsg = null;
$limit = null;
if ($this->minLength && $this->maxLength) {
$limit = "{{$this->minLength},{$this->maxLength}}";
$errorMsg = _t('ConfirmedPasswordField.BETWEEN', 'Passwords must be {min} to {max} characters long.', array('min' => $this->minLength, 'max' => $this->maxLength));
} elseif ($this->minLength) {
$limit = "{{$this->minLength}}.*";
$errorMsg = _t('ConfirmedPasswordField.ATLEAST', 'Passwords must be at least {min} characters long.', array('min' => $this->minLength));
} elseif ($this->maxLength) {
$limit = "{0,{$this->maxLength}}";
$errorMsg = _t('ConfirmedPasswordField.MAXIMUM', 'Passwords must be at most {max} characters long.', array('max' => $this->maxLength));
}
$limitRegex = '/^.' . $limit . '$/';
if (!empty($value) && !preg_match($limitRegex, $value)) {
$validator->validationError($name, $errorMsg, "validation");
}
}
if ($this->requireStrongPassword) {
if (!preg_match('/^(([a-zA-Z]+\\d+)|(\\d+[a-zA-Z]+))[a-zA-Z0-9]*$/', $value)) {
$validator->validationError($name, _t('Form.VALIDATIONSTRONGPASSWORD', "Passwords must have at least one digit and one alphanumeric character"), "validation");
return false;
}
}
// Check if current password is valid
if (!empty($value) && $this->getRequireExistingPassword()) {
if (!$this->currentPasswordValue) {
$validator->validationError($name, _t('ConfirmedPasswordField.CURRENT_PASSWORD_MISSING', "You must enter your current password."), "validation");
return false;
}
// Check this password is valid for the current user
$member = Member::currentUser();
if (!$member) {
$validator->validationError($name, _t('ConfirmedPasswordField.LOGGED_IN_ERROR', "You must be logged in to change your password."), "validation");
return false;
}
// With a valid user and password, check the password is correct
$checkResult = $member->checkPassword($this->currentPasswordValue);
if (!$checkResult->valid()) {
$validator->validationError($name, _t('ConfirmedPasswordField.CURRENT_PASSWORD_ERROR', "The current password you have entered is not correct."), "validation");
return false;
}
}
return true;
}
/**
* @param string $fieldName
* @param string $message
* @param string $messageType
*/
public function validationError($fieldName, $message, $messageType = '')
{
// Just make any error use the form message
$this->form->sessionMessage($message, $messageType);
parent::validationError($fieldName, $message, $messageType);
}
/**
* Validate the value of this EmailField agianst our list of allowed and disallowed domains
* @param Validator $validator
* @return bool
*/
protected function validateDomain(Validator $validator)
{
// If we can't get a domain from the current value, just quite validating the domain.
$domain = $this->getDomain();
if (!$domain) {
return true;
}
// Validate against the allowed domain list
if ($this->allowedDomains && !$this->valueInList($domain, $this->allowedDomains)) {
// Build the message
$message = _t('DomainSpecificEmailField.ALLOWEDDOMAIN', 'The email address is not from an allowed domain.');
if ($this->showListOnError) {
$message .= ' ' . _t('DomainSpecificEmailField.ALLOWEDDOMAINLLIST', 'The following domains are allowed: ') . implode(', ', $this->allowedDomains);
}
// Record the error
$validator->validationError($this->getName(), $message);
return false;
}
// Validate against the disallowed domain list
if ($this->disallowedDomains && $this->valueInList($domain, $this->disallowedDomains)) {
// Build messgae
$message = _t('DomainSpecificEmailField.DISALLOWEDDOMAIN', 'The email address is from a disallowed domain.');
if ($this->showListOnError) {
$message .= ' ' . _t('DomainSpecificEmailField.DISALLOWEDDOMAINLLIST', 'The following domains are disallowed: ') . implode(', ', $this->disallowedDomains);
}
// Record error
$validator->validationError($this->getName(), $message);
return false;
}
// Made it all the way without incident. Domain is valid.
return true;
}
/**
* Validate this field
*
* @param Validator $validator
* @return bool
*/
public function validate($validator)
{
$valid = false;
$source = $this->getSourceAsArray();
$disabled = $this->getDisabledItems();
if ($this->value) {
foreach ($source as $value => $title) {
if (is_array($title) && array_key_exists($this->value, $title)) {
// Check that the set value is not in the list of disabled items
if (!isset($disabled[$value]) || !in_array($this->value, $disabled[$value])) {
$valid = true;
}
// Check that the value matches and is not disabled
} elseif ($this->value == $value && !in_array($this->value, $disabled)) {
$valid = true;
}
}
} elseif ($this->getHasEmptyDefault()) {
$valid = true;
}
if (!$valid) {
$validator->validationError($this->name, _t('DropdownField.SOURCE_VALIDATION', "Please select a value within the list provided. {value} is not a valid option", array('value' => $this->value)), "validation");
return false;
}
return true;
}
/**
* Validate the captcha information
*
* @param Validator $validator
*
* @return boolean
*/
public function validate($validator)
{
// Bypass spam detection for eligible users
if ($this->exemptUser()) {
$this->clearMollomSession();
return true;
}
$session_id = Session::get("mollom_session_id");
$mapped = $this->getSpamMappedData();
$data = array();
// prepare submission
foreach (array('authorName', 'authorUrl', 'authorMail', 'authorIp', 'authorId') as $k) {
if (isset($mapped[$k])) {
$data[$k] = $mapped[$k];
}
}
if ($session_id) {
// session ID exists so has been checked by captcha
$data['id'] = $session_id;
$data['solution'] = $this->Value();
$result = $this->getMollom()->checkCaptcha($data);
if (is_array($result)) {
if ($result['solved']) {
$this->clearMollomSession();
return true;
} else {
$this->requestMollom();
$validator->validationError($this->name, _t('MollomCaptchaField.CAPTCHAREQUESTED', "Please answer the captcha question", "Mollom Captcha provides words in an image, and expects a user to type them in a textfield"), "warning");
return false;
}
}
} else {
$contentMap = array('id' => 'id', 'title' => 'postTitle', 'body' => 'postBody');
foreach ($contentMap as $k => $v) {
if (isset($mapped[$k])) {
$data[$v] = $mapped[$k];
}
}
$result = $this->getMollom()->checkContent($data);
// Mollom can do much more useful things.
// @todo handle profanityScore, qualityScore, sentimentScore, reason
if (is_array($result)) {
switch ($result['spamClassification']) {
case 'ham':
$this->clearMollomSession();
return true;
case 'unsure':
$this->requestMollom();
// we're unsure so request the captcha.
$validator->validationError($this->name, _t('MollomCaptchaField.CAPTCHAREQUESTED', "Please answer the captcha question", "Mollom Captcha provides words in an image, and expects a user to type them in a textfield"), "warning");
return false;
case 'spam':
$this->clearMollomSession();
$this->requestMollom();
$validator->validationError($this->name, _t('MollomCaptchaField.SPAM', "Your submission has been rejected because it was treated as spam.", "Mollom Captcha provides words in an image, and expects a user to type them in a textfield"), "error");
return false;
break;
}
}
}
return true;
}
/**
* Validate by submitting to external service
*
* @todo implement socket timeout handling (or switch to curl?)
* @param Validator $validator
* @return boolean
*/
public function validate($validator)
{
// don't bother querying the recaptcha-service if fields were empty
if (!isset($_REQUEST['g-recaptcha-response']) || empty($_REQUEST['g-recaptcha-response'])) {
$validator->validationError($this->name, _t('RecaptchaField.EMPTY', "Please answer the captcha question", "Recaptcha (https://www.google.com/recaptcha) protects this website " . "from spam and abuse."), "validation", false);
return false;
}
$response = $this->recaptchaHTTPPost($_REQUEST['g-recaptcha-response']);
if (!$response) {
$validator->validationError($this->name, _t('RecaptchaField.NORESPONSE', "The recaptcha service gave no response. Please try again later.", "Recaptcha (https://www.google.com/recaptcha) protects this website " . "from spam and abuse."), "validation", false);
return false;
}
// get the payload of the response and decode it
$response = json_decode($response, true);
if ($response['success'] != 'true') {
// Count some errors as "user level", meaning they raise a validation error rather than a system error
$userLevelErrors = array('missing-input-response', 'invalid-input-response');
if (count(array_intersect($response['error-codes'], $userLevelErrors)) === 0) {
$error = implode(', ', $response['error-codes']);
user_error("RecatpchaField::validate(): Recaptcha-service error: '{$error}'", E_USER_ERROR);
return false;
} else {
// Internal error-string returned by recaptcha, e.g. "incorrect-captcha-sol".
// Used to generate the new iframe-url/js-url after form-refresh.
Session::set("FormField.{$this->form->FormName()}.{$this->getName()}.error", trim($error));
$validator->validationError($this->name, _t('RecaptchaField.VALIDSOLUTION', "Your answer didn't match the captcha words, please try again", "Recaptcha (https://www.google.com/recaptcha) protects this website " . "from spam and abuse."), "validation", false);
return false;
}
}
return true;
}
/**
* Validate this field
*
* @param Validator $validator
* @return bool
*/
public function validate($validator)
{
// Check if valid value is given
$selected = $this->Value();
if (strlen($selected)) {
// Use selection rules to check which are valid
foreach ($this->getValidValues() as $formValue) {
if ($this->isSelectedValue($formValue, $selected)) {
return true;
}
}
} else {
if ($this->getHasEmptyDefault()) {
// Check empty value
return true;
}
$selected = '(none)';
}
// Fail
$validator->validationError($this->name, _t('DropdownField.SOURCE_VALIDATION', "Please select a value within the list provided. {value} is not a valid option", array('value' => $selected)), "validation");
return false;
}
/**
* @param Validator $validator
*
* @return boolean
*/
public function validate($validator)
{
$name = $this->name;
// if field isn't visible, don't validate
if (!$this->isSaveable()) {
return true;
}
$passwordField = $this->children->fieldByName($name . '[_Password]');
$passwordConfirmField = $this->children->fieldByName($name . '[_ConfirmPassword]');
$passwordField->setValue($_POST[$name]['_Password']);
$passwordConfirmField->setValue($_POST[$name]['_ConfirmPassword']);
$value = $passwordField->Value();
// both password-fields should be the same
if ($value != $passwordConfirmField->Value()) {
$validator->validationError($name, _t('Form.VALIDATIONPASSWORDSDONTMATCH', "Passwords don't match"), "validation", false);
return false;
}
if (!$this->canBeEmpty) {
// both password-fields shouldn't be empty
if (!$value || !$passwordConfirmField->Value()) {
$validator->validationError($name, _t('Form.VALIDATIONPASSWORDSNOTEMPTY', "Passwords can't be empty"), "validation", false);
return false;
}
}
// lengths
if ($this->minLength || $this->maxLength) {
if ($this->minLength && $this->maxLength) {
$limit = "{{$this->minLength},{$this->maxLength}}";
$errorMsg = _t('ConfirmedPasswordField.BETWEEN', 'Passwords must be {min} to {max} characters long.', array('min' => $this->minLength, 'max' => $this->maxLength));
} elseif ($this->minLength) {
$limit = "{{$this->minLength}}.*";
$errorMsg = _t('ConfirmedPasswordField.ATLEAST', 'Passwords must be at least {min} characters long.', array('min' => $this->minLength));
} elseif ($this->maxLength) {
$limit = "{0,{$this->maxLength}}";
$errorMsg = _t('ConfirmedPasswordField.MAXIMUM', 'Passwords must be at most {max} characters long.', array('max' => $this->maxLength));
}
$limitRegex = '/^.' . $limit . '$/';
if (!empty($value) && !preg_match($limitRegex, $value)) {
$validator->validationError($name, $errorMsg, "validation", false);
}
}
if ($this->requireStrongPassword) {
if (!preg_match('/^(([a-zA-Z]+\\d+)|(\\d+[a-zA-Z]+))[a-zA-Z0-9]*$/', $value)) {
$validator->validationError($name, _t('Form.VALIDATIONSTRONGPASSWORD', "Passwords must have at least one digit and one alphanumeric character"), "validation", false);
return false;
}
}
return true;
}
/**
* Validate this field
*
* @param Validator $validator
* @return bool
*/
public function validate($validator)
{
$values = $this->value;
if (!$values) {
return true;
}
$sourceArray = $this->getSourceAsArray();
if (is_array($values)) {
if (!array_intersect_key($sourceArray, $values)) {
$validator->validationError($this->name, _t('CheckboxSetField.SOURCE_VALIDATION', "Please select a value within the list provided. '{value}' is not a valid option", array('value' => implode(' and ', array_diff($sourceArray, $values)))), "validation");
return false;
}
} else {
if (!in_array($this->value, $sourceArray)) {
$validator->validationError($this->name, _t('CheckboxSetField.SOURCE_VALIDATION', "Please select a value within the list provided. '{value}' is not a valid option", array('value' => $this->value)), "validation");
return false;
}
}
return true;
}
/**
* Validate this field
*
* @param Validator $validator
* @return bool
*/
public function validate($validator)
{
$source = $this->getSourceAsArray();
$disabled = $this->getDisabledItems();
if (!array_key_exists($this->value, $source) || in_array($this->value, $disabled)) {
if ($this->getHasEmptyDefault() && !$this->value) {
return true;
}
$validator->validationError($this->name, _t('DropdownField.SOURCE_VALIDATION', "Please select a value within the list provided. {value} is not a valid option", array('value' => $this->value)), "validation");
return false;
}
return true;
}
/**
* Validation method for this field, called when the entire form is validated
*
* @param Validator $validator
* @return boolean
*/
public function validate($validator)
{
$name = $this->getName();
$value = $this->Value();
// If there is no file then quit
if (!$value) {
return true;
}
// Revalidate each file against nested validator
$this->getUpload()->clearErrors();
// Generate $_FILES style file attribute array for upload validator
$store = $this->getAssetStore();
$mime = $store->getMimeType($value['Filename'], $value['Hash'], $value['Variant']);
$metadata = $store->getMetadata($value['Filename'], $value['Hash'], $value['Variant']);
$tmpFile = array('name' => $value['Filename'], 'type' => $mime, 'size' => isset($metadata['size']) ? $metadata['size'] : 0, 'tmp_name' => null, 'error' => UPLOAD_ERR_OK);
$this->getUpload()->validate($tmpFile);
// Check all errors
if ($errors = $this->getUpload()->getErrors()) {
foreach ($errors as $error) {
$validator->validationError($name, $error, "validation");
}
return false;
}
return true;
}
/**
* Validate this field
*
* @param Validator $validator
* @return bool
*/
public function validate($validator)
{
$values = $this->value;
if (!$values) {
return true;
}
$source = $this->getSourceAsArray();
if (is_array($values)) {
if (!array_intersect_key($source, array_flip($values))) {
$validator->validationError($this->name, _t("Please select a value within the list provided. {value} is not a valid option", array('value' => $this->value)), "validation");
return false;
}
} else {
if (!array_key_exists($this->value, $source)) {
$validator->validationError($this->name, _t('ListboxField.SOURCE_VALIDATION', "Please select a value within the list provided. %s is not a valid option", array('value' => $this->value)), "validation");
return false;
}
}
return true;
}
/**
* Validate by submitting to external service
*
* @todo implement socket timeout handling (or switch to curl?)
* @param Validator $validator
* @return boolean
*/
public function validate($validator)
{
// don't bother querying the recaptcha-service if fields were empty
if (!isset($_REQUEST['recaptcha_challenge_field']) || empty($_REQUEST['recaptcha_challenge_field']) || !isset($_REQUEST['recaptcha_response_field']) || empty($_REQUEST['recaptcha_response_field'])) {
$validator->validationError($this->name, _t('RecaptchaField.EMPTY', "Please answer the captcha question", PR_MEDIUM, "Recaptcha (http://recaptcha.net) provides two words in an image, and expects a user to type them in a textfield"), "validation", false);
return false;
}
$response = $this->recaptchaHTTPPost($_REQUEST['recaptcha_challenge_field'], $_REQUEST['recaptcha_response_field']);
if (!$response) {
$validator->validationError($this->name, _t('RecaptchaField.NORESPONSE', "The recaptcha service gave no response. Please try again later.", PR_MEDIUM, "Recaptcha (http://recaptcha.net) provides two words in an image, and expects a user to type them in a textfield"), "validation", false);
return false;
}
// get the payload of the response and split it by newlines
list($isValid, $error) = explode("\n", $response, 2);
if ($isValid != 'true') {
// Count some errors as "user level", meaning they raise a validation error rather than a system error
$userLevelErrors = array('incorrect-captcha-sol', 'invalid-request-cookie');
if (!in_array(trim($error), $userLevelErrors)) {
user_error("RecatpchaField::validate(): Recaptcha-service error: '{$error}'", E_USER_ERROR);
return false;
} else {
// Internal error-string returned by recaptcha, e.g. "incorrect-captcha-sol".
// Used to generate the new iframe-url/js-url after form-refresh.
Session::set("FormField.{$this->form->FormName()}.{$this->Name()}.error", trim($error));
$validator->validationError($this->name, _t('RecaptchaField.VALIDSOLUTION', "Your answer didn't match the captcha words, please try again", PR_MEDIUM, "Recaptcha (http://recaptcha.net) provides two words in an image, and expects a user to type them in a textfield"), "validation", false);
return false;
}
}
return true;
}
/**
* Validation method for this field, called when the entire form is validated
*
* @param Validator $validator
* @return boolean
*/
public function validate($validator)
{
// @todo Test compatibility with RequiredFields
$name = $this->getName();
$files = $this->getItems();
// If there are no files then quit
if ($files->count() == 0) {
return true;
}
// Check max number of files
$maxFiles = $this->getAllowedMaxFileNumber();
if ($maxFiles && $files->count() > $maxFiles) {
$validator->validationError($name, _t('UploadField.MAXNUMBEROFFILES', 'Max number of {count} file(s) exceeded.', array('count' => $maxFiles)), "validation");
return false;
}
// Revalidate each file against nested validator
$this->upload->clearErrors();
foreach ($files as $file) {
// Generate $_FILES style file attribute array for upload validator
$tmpFile = array('name' => $file->Name, 'type' => null, 'size' => $file->AbsoluteSize, 'tmp_name' => null, 'error' => UPLOAD_ERR_OK);
$this->upload->validate($tmpFile);
}
// Check all errors
if ($errors = $this->upload->getErrors()) {
foreach ($errors as $error) {
$validator->validationError($name, $error, "validation");
}
return false;
}
return true;
}
/**
* Validate this field
*
* @todo Very basic validation at the moment
*
* @param Validator $validator
* @return bool
*/
public function validate($validator)
{
$valid = preg_match('/^[0-9\\+\\-\\(\\)\\s\\#]*$/', $this->joinPhoneNumber($this->value));
if (!$valid) {
$validator->validationError($this->name, _t('PhoneNumberField.VALIDATION', "Please enter a valid phone number"), "validation", false);
return false;
}
return true;
}
/**
* Validate this field
*
* @param Validator $validator
* @return bool
*/
public function validate($validator)
{
$value = $this->Value();
if (!$value) {
return true;
// no custom value, don't validate
}
// Check that the current date with the date format is valid or not
require_once 'Zend/Date.php';
$date = Zend_Date::now()->toString($value);
$valid = Zend_Date::isDate($date, $value);
if ($valid) {
return true;
}
// Fail
$validator->validationError($this->getName(), _t('MemberDatetimeOptionsetField.DATEFORMATBAD', "Date format is invalid"), "validation");
return false;
}
/**
* Validate this field
*
* @param Validator $validator
* @return bool
*/
public function validate($validator)
{
// Don't validate empty fields
if (empty($this->value)) {
return true;
}
if (!Zend_Date::isDate($this->value, $this->getConfig('timeformat'), $this->locale)) {
$validator->validationError($this->name, _t('TimeField.VALIDATEFORMAT', "Please enter a valid time format ({format})", array('format' => $this->getConfig('timeformat'))), "validation", false);
return false;
}
return true;
}
/**
* Please note that we do NOT validate an empty field. Add a required
* constraint if you want a value
*
* @param Validator $validator
* @return boolean
*/
public function validate($validator)
{
if (empty($this->value)) {
return true;
}
try {
$valid = self::validatePhoneNumber($this->value, $this->getTargetCountryCode());
} catch (\libphonenumber\NumberParseException $e) {
$valid = false;
//if it wasn't parsed properly, it's probably not valid
}
if (!$valid) {
$validator->validationError($this->name, _t('PhoneNumberField.VALIDATION', "Please enter a valid phone number"), "validation", false);
return false;
}
return true;
}
/**
* Validate by submitting to external service
*
* @param Validator $validator Validator
*
* @return boolean
*
* @author Sascha Koehler <*****@*****.**>, Sebastian Diel <*****@*****.**>
* @since 12.02.2013
*/
public function validate($validator)
{
$valid = false;
$checkValue = $_REQUEST[$this->getName() . 'Field'];
$fh = fopen($this->getTempDir() . '/' . 'cap_' . $this->getFormIdentifier() . '.txt', "r");
$hash = fgets($fh);
$hash2 = md5(strtolower($checkValue));
if ($hash2 == $hash) {
$valid = true;
} else {
$validator->validationError($this->getName(), _t('Form.CAPTCHAFIELDNOMATCH'), "validation", false);
}
return $valid;
}
/**
* If this field is required then we require at least the first postal line
* along with the town and postcode. Either this has been manually filled
* in or, automatically filled in by
*
* @param Validator $validator
*
* @return bool
*/
public function validate($validator)
{
$name = $this->getName();
if ($validator->fieldIsRequired($name)) {
// remove this as a required field as we're doing the checking here.
$validator->removeRequiredField($name);
$fields = $this->getManualFields();
$postal = $fields->dataFieldByName("{$name}[PostalLine1]");
if (!$postal->Value()) {
$validator->validationError($name, _t("AddressFinderField.ENTERAVALIDADDRESS", "Please enter a valid address."), 'PostalLine1', false);
return false;
}
$city = $fields->dataFieldByName("{$name}[City]");
if (!$city->Value()) {
$validator->validationError($name, _t("AddressFinderField.ENTERAVALIDCITY", "Please enter a valid city."), "City", false);
return false;
}
$postcode = $fields->dataFieldByName("{$name}[Postcode]");
if (!$postcode->Value()) {
$validator->validationError($name, _t("AddressFinderField.ENTERAVALIDPOSTCODE", "Please enter a valid postcode."), "Postcode", false);
return false;
}
}
return true;
}
/**
* Validation for this field.
*
* @param Validator $validator
*
* @return bool
*/
public function validate($validator)
{
if (!$this->value) {
return true;
}
$validationChecks = [true];
if (!$this->isNumeric()) {
$validator->validationError($this->name, _t('NumericField.VALIDATION', "'{value}' is not a number, only numbers can be accepted for this field", ['value' => $this->value]), 'validation');
$validationChecks[] = false;
}
if (($this->getUIOption('max') || $this->getUIOption('max') === 0) && $this->getEnforceAboveMaxValidation() && $this->value > $this->getUIOption('max')) {
$validator->validationError($this->name, _t('SpinnerField.ABOVEMAX', '\'{value}\' exceeds the maximum allowed number {max}', ['value' => $this->value, 'max' => $this->getUIOption('max')]), 'validation');
$validationChecks[] = false;
}
if (($this->getUIOption('min') || $this->getUIOption('min') === 0) && $this->getEnforceBelowMinValidation() && $this->value < $this->getUIOption('min')) {
$validator->validationError($this->name, _t('SpinnerField.BELOWMIN', '\'{value}\' is below the minimum allowed number {min}', ['value' => $this->value, 'min' => $this->getUIOption('min')]), 'validation');
$validationChecks[] = false;
}
if ($this->getEnforceStepValidation() && 0 !== $this->value % $this->getUIOption('step')) {
$validator->validationError($this->name, _t('SpinnerField.NOTEVENLYDIVISIBLE', '\'{value}\' is not evenly divisible by {step}', ['value' => $this->value, 'step' => $this->getUIOption('step')]), 'validation');
$validationChecks[] = false;
}
return min($validationChecks);
}