PHP Doctrine_Validator类代码示例

 /**
  * 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 = 'arnold@example.com';
     $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));
 }