/**
* tests validity of the record using the current data.
*
* (This is an override of base Doctrine functionality, to fix a bug with validation.)
*
* @param boolean $deep (optional) run the validation process on the relations
* @param boolean $hooks (optional) invoke save hooks before start
* @return boolean whether or not this record is valid
*/
public function isValid($deep = false, $hooks = true)
{
if (!$this->_table->getAttribute(Doctrine_Core::ATTR_VALIDATE)) {
return true;
}
if ($this->_state == self::STATE_LOCKED || $this->_state == self::STATE_TLOCKED) {
return true;
}
if ($hooks) {
$this->invokeSaveHooks('pre', 'save');
$this->invokeSaveHooks('pre', $this->exists() ? 'update' : 'insert');
}
// Clear the stack from any previous errors.
$this->getErrorStack()->clear();
// Run validation process
$event = new Doctrine_Event($this, Doctrine_Event::RECORD_VALIDATE);
$this->preValidate($event);
$this->getTable()->getRecordListener()->preValidate($event);
if (!$event->skipOperation) {
$validator = new Doctrine_Validator();
$validator->validateRecord($this);
$this->validate();
if ($this->_state == self::STATE_TDIRTY || $this->_state == self::STATE_TCLEAN) {
$this->validateOnInsert();
} else {
$this->validateOnUpdate();
}
}
$this->getTable()->getRecordListener()->postValidate($event);
$this->postValidate($event);
$valid = $this->getErrorStack()->count() == 0 ? true : false;
if ($valid && $deep) {
$stateBeforeLock = $this->_state;
$this->_state = $this->exists() ? self::STATE_LOCKED : self::STATE_TLOCKED;
foreach ($this->_references as $reference) {
if ($reference instanceof Doctrine_Record) {
if (!($valid = $reference->isValid($deep))) {
break;
}
} elseif ($reference instanceof Doctrine_Collection) {
foreach ($reference as $record) {
if (!($valid = $record->isValid($deep, $hooks))) {
break;
}
}
// Bugfix.
if (!$valid) {
break;
}
}
}
$this->_state = $stateBeforeLock;
}
return $valid;
}
public function testIsValidLength()
{
$binaryValue = fread(fopen(__FILE__, 'r'), filesize(__FILE__));
//Should pass with size the same size as maximum size
$this->assertTrue(Doctrine_Validator::validateLength($binaryValue, "blob", filesize(__FILE__)));
//Should fail with maximum size 1 less than actual file size
$this->assertFalse(Doctrine_Validator::validateLength($binaryValue, "blob", filesize(__FILE__) - 1));
}
/**
* checks if given value is a valid ISO-8601 timestamp (YYYY-MM-DDTHH:MM:SS+00:00)
*
* @param mixed $value
* @return boolean
*/
public function validate($value)
{
if (is_null($value)) {
return true;
}
$e = explode('T', trim($value));
$date = isset($e[0]) ? $e[0] : null;
$time = isset($e[1]) ? $e[1] : null;
$dateValidator = Doctrine_Validator::getValidator('date');
$timeValidator = Doctrine_Validator::getValidator('time');
if (!$dateValidator->validate($date)) {
return false;
}
if (!$timeValidator->validate($time)) {
return false;
}
return true;
}
/**
* checks if given value is a valid timestamp
* ISO-8601 timestamp (YYYY-MM-DDTHH:MM:SS+00:00) or (YYYY-MM-DD HH:MM:SS)
*
* @param mixed $value
* @return boolean
*/
public function validate($value)
{
if (is_null($value)) {
return true;
}
$splitChar = false !== strpos($value, 'T') ? 'T' : ' ';
$e = explode($splitChar, trim($value));
$date = isset($e[0]) ? $e[0] : null;
$time = isset($e[1]) ? $e[1] : null;
$dateValidator = Doctrine_Validator::getValidator('date');
$timeValidator = Doctrine_Validator::getValidator('time');
if (!$dateValidator->validate($date)) {
return false;
}
if (!$timeValidator->validate($time)) {
return false;
}
return true;
}
/**
* checks if given value is a valid timestamp (YYYY-MM-DD HH:MM:SS)
*
* @param mixed $value
* @return boolean
*/
public function validate($value)
{
if ($value === null) {
return true;
}
if (!preg_match('/^ *\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}(.\\d{6}\\+\\d{2})? *$/', $value)) {
return false;
}
list($date, $time) = explode(' ', trim($value));
$dateValidator = Doctrine_Validator::getValidator('date');
$timeValidator = Doctrine_Validator::getValidator('time');
if (!$dateValidator->validate($date)) {
return false;
}
if (!$timeValidator->validate($time)) {
return false;
}
return true;
}
/**
* validateField
*
* @param string $name
* @param string $value
* @param Doctrine_Record $record
* @return Doctrine_Validator_ErrorStack $errorStack
*/
public function validateField($fieldName, $value, Doctrine_Record $record = null)
{
if ($record instanceof Doctrine_Record) {
$errorStack = $record->getErrorStack();
} else {
$record = $this->create();
$errorStack = new Doctrine_Validator_ErrorStack($this->getOption('name'));
}
if ($value === self::$_null) {
$value = null;
} else {
if ($value instanceof Doctrine_Record && $value->exists()) {
$value = $value->getIncremented();
} else {
if ($value instanceof Doctrine_Record && !$value->exists()) {
foreach ($this->getRelations() as $relation) {
if ($fieldName == $relation->getLocalFieldName() && (get_class($value) == $relation->getClass() || is_subclass_of($value, $relation->getClass()))) {
return $errorStack;
}
}
}
}
}
$dataType = $this->getTypeOf($fieldName);
// Validate field type, if type validation is enabled
if ($this->getAttribute(Doctrine::ATTR_VALIDATE) & Doctrine::VALIDATE_TYPES) {
if (!Doctrine_Validator::isValidType($value, $dataType)) {
$errorStack->add($fieldName, 'type');
}
if ($dataType == 'enum') {
$enumIndex = $this->enumIndex($fieldName, $value);
if ($enumIndex === false && $value !== null) {
$errorStack->add($fieldName, 'enum');
}
}
}
// Validate field length, if length validation is enabled
if ($this->getAttribute(Doctrine::ATTR_VALIDATE) & Doctrine::VALIDATE_LENGTHS) {
if (!Doctrine_Validator::validateLength($value, $dataType, $this->getFieldLength($fieldName))) {
$errorStack->add($fieldName, 'length');
}
}
// Run all custom validators
foreach ($this->getFieldValidators($fieldName) as $validatorName => $args) {
if (!is_string($validatorName)) {
$validatorName = $args;
$args = array();
}
$validator = Doctrine_Validator::getValidator($validatorName);
$validator->invoker = $record;
$validator->field = $fieldName;
$validator->args = $args;
if (!$validator->validate($value)) {
$errorStack->add($fieldName, $validator);
}
}
return $errorStack;
}
/**
* isValid
*
* @return boolean whether or not this record is valid
*/
public function isValid()
{
if (!$this->_table->getAttribute(Doctrine::ATTR_VALIDATE)) {
return true;
}
// Clear the stack from any previous errors.
$this->getErrorStack()->clear();
// Run validation process
$event = new Doctrine_Event($this, Doctrine_Event::RECORD_VALIDATE);
$this->preValidate($event);
$this->getTable()->getRecordListener()->preValidate($event);
if (!$event->skipOperation) {
$validator = new Doctrine_Validator();
$validator->validateRecord($this);
$this->validate();
if ($this->_state == self::STATE_TDIRTY || $this->_state == self::STATE_TCLEAN) {
$this->validateOnInsert();
} else {
$this->validateOnUpdate();
}
}
$this->getTable()->getRecordListener()->postValidate($event);
$this->postValidate($event);
return $this->getErrorStack()->count() == 0 ? true : false;
}
public function checkValidation($deep = true, $hooks = true)
{
$invalidRecords = array();
if (!$this->_table->getAttribute(Doctrine::ATTR_VALIDATE)) {
return true;
}
if ($this->_state == self::STATE_LOCKED || $this->_state == self::STATE_TLOCKED) {
return true;
}
if ($hooks) {
$this->invokeSaveHooks('pre', 'save');
$this->invokeSaveHooks('pre', $this->exists() ? 'update' : 'insert');
}
// Clear the stack from any previous errors.
$this->getErrorStack()->clear();
// Run validation process
$event = new Doctrine_Event($this, Doctrine_Event::RECORD_VALIDATE);
$this->preValidate($event);
$this->getTable()->getRecordListener()->preValidate($event);
if (!$event->skipOperation) {
$validator = new Doctrine_Validator();
$validator->validateRecord($this);
$this->validate();
if ($this->_state == self::STATE_TDIRTY || $this->_state == self::STATE_TCLEAN) {
$this->validateOnInsert();
} else {
$this->validateOnUpdate();
}
}
$this->getTable()->getRecordListener()->postValidate($event);
$this->postValidate($event);
$valid = $this->getErrorStack()->count() == 0 ? true : false;
if (!$valid) {
$invalidRecords[] = $this;
}
if ($deep) {
$stateBeforeLock = $this->_state;
$this->_state = $this->exists() ? self::STATE_LOCKED : self::STATE_TLOCKED;
foreach ($this->_references as $reference) {
if ($reference instanceof Doctrine_Record) {
if (!method_exists($reference, 'checkValidation')) {
continue;
}
$valid = $reference->checkValidation($deep);
if (is_array($valid) && !empty($valid)) {
$invalidRecords = array_merge($valid, $invalidRecords);
}
} else {
if ($reference instanceof Doctrine_Collection) {
foreach ($reference as $record) {
if (!method_exists($record, 'checkValidation')) {
continue;
}
$valid = $record->checkValidation($deep);
if (is_array($valid) && !empty($valid)) {
$invalidRecords = array_merge($valid, $invalidRecords);
}
}
}
}
}
$this->_state = $stateBeforeLock;
}
return $invalidRecords;
}
/**
* Validates all the unique indexes.
*
* This methods validates 'unique' sets of fields for the given Doctrine_Record instance.
* Pushes error to the record error stack if they are generated.
*
* @param Doctrine_Record $record
*/
public function validateUniques(Doctrine_Record $record)
{
$errorStack = $record->getErrorStack();
$validator = Doctrine_Validator::getValidator('unique');
$validator->invoker = $record;
foreach ($this->_uniques as $unique) {
list($fields, $options) = $unique;
$validator->args = $options;
$validator->field = $fields;
$values = array();
foreach ($fields as $field) {
$values[] = $record->{$field};
}
if (!$validator->validate($values)) {
foreach ($fields as $field) {
$errorStack->add($field, $validator);
}
}
}
}
public function testValidate()
{
$this->manager->setAttribute(Doctrine_Core::ATTR_VALIDATE, Doctrine_Core::VALIDATE_ALL);
$user = $this->connection->getTable('User')->find(4);
$set = array('password' => 'this is an example of too long password', 'loginname' => 'this is an example of too long loginname', 'name' => 'valid name', 'created' => 'invalid');
$user->setArray($set);
$email = $user->Email;
$email->address = 'zYne@invalid';
$this->assertTrue($user->getModified() == $set);
$validator = new Doctrine_Validator();
$validator->validateRecord($user);
$stack = $user->errorStack();
$this->assertTrue($stack instanceof Doctrine_Validator_ErrorStack);
$this->assertTrue(in_array('length', $stack['loginname']));
$this->assertTrue(in_array('length', $stack['password']));
$this->assertTrue(in_array('type', $stack['created']));
$validator->validateRecord($email);
$stack = $email->errorStack();
$this->assertTrue(in_array('email', $stack['address']));
$email->address = '*****@*****.**';
$validator->validateRecord($email);
$stack = $email->errorStack();
$this->assertTrue(in_array('unique', $stack['address']));
$this->manager->setAttribute(Doctrine_Core::ATTR_VALIDATE, Doctrine_Core::VALIDATE_NONE);
}
/**
* isValid
*
* @return boolean whether or not this record is valid
*/
public function isValid()
{
if (!$this->_table->getAttribute(Doctrine::ATTR_VALIDATE)) {
return true;
}
// Clear the stack from any previous errors.
$this->_errorStack->clear();
// Run validation process
$validator = new Doctrine_Validator();
$validator->validateRecord($this);
$this->validate();
if ($this->_state == self::STATE_TDIRTY || $this->_state == self::STATE_TCLEAN) {
$this->validateOnInsert();
} else {
$this->validateOnUpdate();
}
return $this->_errorStack->count() == 0 ? true : false;
}
public function testMysqlTimestamp()
{
$timestamp = '2010-03-02 22:08:56';
$timestampValidator = Doctrine_Validator::getValidator('timestamp');
$this->assertTrue($timestampValidator->validate($timestamp));
}
