PHP Validator::string方法代码示例

 public function setState($value)
 {
     if (!v::string()->notEmpty()->validate($value) || strlen($value) != 2) {
         throw new FieldRequiredException("Estado é uma informação obrigatória");
     }
     $this->_state = strtoupper($value);
 }

 public function __construct($webapiKey = null, $userLogin = null, $hashedPassword = null)
 {
     $this->properties['webapiKey'] = new Property(['validator' => function ($value) {
         try {
             Validator::string()->noWhitespace()->notEmpty()->length(4)->assert($value);
         } catch (NestedValidationExceptionInterface $e) {
             throw new ValidationException($e);
         }
     }]);
     if (!is_null($webapiKey)) {
         $this->properties['webapiKey']->set($webapiKey)->lock();
     }
     // --------------------
     $this->properties['userLogin'] = new Property(['validator' => function ($value) {
         try {
             Validator::string()->noWhitespace()->notEmpty()->length(4)->assert($value);
         } catch (NestedValidationExceptionInterface $e) {
             throw new ValidationException($e);
         }
     }]);
     if (!is_null($userLogin)) {
         $this->properties['userLogin']->set($userLogin)->lock();
     }
     // ----------------------
     $this->properties['hashedPassword'] = new Property(['validator' => function ($value) {
         try {
             Validator::string()->noWhitespace()->notEmpty()->regex('/^([A-Za-z0-9+\\/]{4})*([A-Za-z0-9+\\/]{4}|[A-Za-z0-9+\\/]{3}=|[A-Za-z0-9+\\/]{2}==)$/')->assert($value);
         } catch (NestedValidationExceptionInterface $e) {
             throw new ValidationException($e);
         }
     }]);
     if (!is_null($hashedPassword)) {
         $this->properties['hashedPassword']->set($hashedPassword)->lock();
     }
 }

 public function setJustification($justification)
 {
     if (!v::string()->length(15, 1000)->validate($justification)) {
         throw new FieldRequiredException("A justicativa deve ter entre 15 e 100 caracteres");
     }
     $this->_justification = $justification;
 }

 /**
  * Saves a setting as a key/value pair
  *
  * Settings specific to fast-forward start with a `ff.` prefix.
  *
  * You can use the constants of this class to avoid looking up the key names.
  *
  * @param string $key   Unique key name.<br>
  *                      Must contain only letters (a-z, A-Z), digits (0-9) and "."
  * @param string $value
  *
  * @throws \Exception
  */
 public function set($key, $value)
 {
     $out = $this->client->getOutput();
     try {
         v::string()->alnum('.')->noWhitespace()->notEmpty()->assert($key);
     } catch (NestedValidationExceptionInterface $e) {
         $out->error($e->getFullMessage());
         return;
     }
     $setting = $this->get($key, true);
     if ($setting === null) {
         $setting = new Setting();
         $setting->key = $key;
     }
     $oldValue = $setting->value;
     $setting->value = $value;
     if (!$this->validate($setting)) {
         return;
     }
     if ($oldValue === null) {
         $out->writeln("Inserting new setting:\n{$key} = <options=bold>{$value}</>");
     } elseif ($oldValue !== $value) {
         $out->writeln("Changing setting:\n{$key} = {$oldValue} --> <options=bold>{$value}</>");
     } else {
         $out->writeln("Setting already up-to-date:\n{$key} = {$value}");
     }
     $setting->save();
 }

 public function validate($data)
 {
     $validator = V::key('name', V::string()->length(0, 100), true)->key('email', V::email()->length(0, 200), true)->key('password', V::string()->length(0, 100), true);
     try {
         $validator->assert($data);
         switch ($data['userable_type']) {
             case 'Designer':
                 $this->designerCreationValidator->validate($data);
                 $data['userable_type'] = DesignerModel::class;
                 break;
             case 'Administrator':
                 $this->adminCreationValidator->validate($data);
                 $data['userable_type'] = AdministratorModel::class;
                 break;
             case 'Buyer':
                 $this->buyerCreationValidator->validate($data);
                 $data['userable_type'] = BuyerModel::class;
                 break;
             default:
                 break;
         }
     } catch (AbstractNestedException $e) {
         $errors = $e->findMessages(['email', 'length', 'in']);
         throw new ValidationException('Could not create user.', $errors);
     }
     return true;
 }

 public function validate($prop, $label)
 {
     $value = $this->getValue($prop);
     if (!v::string()->cnpj()->validate($value)) {
         $this->addException("O preenchimento do campo {$label} está inválido");
     }
 }

 public function post()
 {
     try {
         $newManufacturer = (object) (['id' => null] + $_POST);
         v::arr()->key('name', v::string()->notEmpty()->length(1, 300))->assert($_POST);
         if ($_FILES['files']['error'] == 4) {
             throw new Exception('O campo imagem é obrigatório');
         }
         if (empty($newManufacturer->manufacturer_featured)) {
             $newManufacturer->manufacturer_featured = null;
         }
         $this->collection->persist($newManufacturer);
         $this->collection->flush();
         foreach ($_FILES as $file) {
             $this->uploaderService->setFile($_POST['name'], 'files');
             $image = (object) ['name' => $this->uploaderService->getFile()->getNameWithExtension(), 'title' => $_POST['name'], 'type' => $this->uploaderService->getFile()->getMimetype(), 'manufacturer_id' => $newManufacturer->id];
             $this->imageCollection->persist($image);
             $this->imageCollection->flush();
             $this->uploaderService->upload();
         }
         header('HTTP/1.1 303 See Other');
         header('Location: /catalog/manufacturers');
     } catch (NestedValidationExceptionInterface $e) {
         return $this->get() + ['manufacturer/addManufacturer' => $newManufacturer, 'messages' => $e->findMessages(['name' => 'O nome deve ser entre 1 e 300 caracteres'])];
     }
 }

 public function validate($prop, $label)
 {
     $value = $this->getValue($prop);
     if (!v::string()->notEmpty()->validate($value)) {
         $this->addException("O campo {$label} é de preenchimento obrigatório");
     }
 }

 public function setName($value)
 {
     if (!v::string()->notEmpty()->validate($value)) {
         throw new FieldRequiredException("Nome/Razão Social é uma informação obrigatória");
     }
     $this->_name = $value;
 }

 public function post($manufacturerId)
 {
     $editManufacturer = $this->collection[$manufacturerId]->fetch() ?: new stdClass();
     foreach ($_POST as $k => $v) {
         $editManufacturer->{$k} = $v;
     }
     try {
         v::object()->attribute('name', v::string()->notEmpty()->length(1, 300))->assert($editManufacturer);
         $this->collection->persist($editManufacturer);
         $this->collection->flush();
         if (empty($newManufacturer->manufacturer_featured)) {
             $newManufacturer->manufacturer_featured = null;
         }
         if ($_FILES['files']['error'] != 4) {
             foreach ($_FILES as $file) {
                 $this->uploaderService->setFile($editManufacturer->name, 'files');
                 $image = (object) ['name' => $this->uploaderService->getFile()->getNameWithExtension(), 'title' => $editManufacturer->name, 'type' => $this->uploaderService->getFile()->getMimetype(), 'manufacturer_id' => $editManufacturer->id];
                 $this->imageCollection->persist($image);
                 $this->imageCollection->flush();
                 $this->uploaderService->upload();
             }
         }
         header('HTTP/1.1 303 See Other');
         header('Location: ' . $_SERVER['REQUEST_URI']);
     } catch (NestedValidationExceptionInterface $e) {
         return ['editManufacturer' => $editManufacturer, 'messages' => $e->findMessages(['name' => 'Name must have between 1 and 300 chars', 'enabled' => 'Could not enable manufacturer'])];
     }
 }

 public function setStateRegistration($value)
 {
     if (!v::string()->notEmpty()->validate($value)) {
         throw new FieldRequiredException("Inscrição Estadual é uma informação obrigatória");
     }
     $value = preg_replace('/\\D/', '', $value);
     $this->_stateRegistration = $value;
 }

 public function testGetFullMessageShouldIncludeAllValidationMessagesInAChain()
 {
     try {
         Validator::string()->length(1, 15)->assert('');
     } catch (NestedValidationExceptionInterface $e) {
         $this->assertEquals('\\-These rules must pass for ""
\-"" must have a length between 1 and 15', $e->getFullMessage());
     }
 }

 private function validateServer($server)
 {
     $validate_server = Validator::string()->noWhitespace()->length(6, 80);
     if (!$validate_server->validate($server)) {
         return false;
     } else {
         return true;
     }
 }

 private function validateServerNode($server, $node)
 {
     $validate_server = Validator::string()->noWhitespace()->length(6, 40);
     $validate_node = Validator::string()->length(3, 100);
     if (!$validate_server->validate($server) || !$validate_node->validate($node)) {
         return false;
     } else {
         return true;
     }
 }

 public function validate($data)
 {
     $validator = V::key('about', V::string()->length(0, 100), false)->key('website', V::string()->length(0, 100), false)->key('twitter_username', V::string()->length(0, 100), false)->key('facebook_url', V::string()->length(0, 100), false)->key('pinterest_url', V::string()->length(0, 100), false)->key('instagram_username', V::string()->length(0, 100), false);
     try {
         $validator->assert($data);
     } catch (AbstractNestedException $e) {
         $errors = $e->findMessages(['about', 'website', 'twitter_username', 'facebook_url', 'pinterest_url', 'instagram_username']);
         throw new ValidationException('Could not update user.', $errors);
     }
     return true;
 }