PHP ValidatorInterface::validate方法代码示例

 /**
  * @param mixed $data
  * @throws MissingDependencyException
  */
 public function validate($data)
 {
     if (!$this->validator) {
         throw new MissingDependencyException('No validator present.');
     }
     return $this->validator->validate($data);
 }

 /**
  * Validate data
  *
  * @param EntityData $data
  * @throws ValidationException
  */
 public function run(EntityData $data)
 {
     $constraintViolations = $this->validator->validate($data);
     if ($constraintViolations->count()) {
         throw new ValidationException($constraintViolations);
     }
 }

 /**
  * {@inheritdoc}
  *
  * Expected input format :
  * {
  *     'attribute': 'maximum_print_size',
  *     'code': '210_x_1219_mm',
  *     'sort_order': 2,
  *     'labels': {
  *         'de_DE': '210 x 1219 mm',
  *         'en_US': '210 x 1219 mm',
  *         'fr_FR': '210 x 1219 mm'
  *     }
  * }
  *
  * @throws BusinessValidationException
  */
 public function update($attributeOption, array $data, array $options = [])
 {
     if (!$attributeOption instanceof AttributeOptionInterface) {
         throw new \InvalidArgumentException(sprintf('Expects a "Pim\\Bundle\\CatalogBundle\\Model\\AttributeOptionInterface", "%s" provided.', ClassUtils::getClass($attributeOption)));
     }
     // TODO: ugly fix to workaround issue with "attribute.group.code: This value should not be blank."
     // in case of existing option, attribute is a proxy, attribute group too, the validated group code is null
     $attributeOption->getAttribute() !== null ? $attributeOption->getAttribute()->getGroup()->getCode() : null;
     $isNew = $attributeOption->getId() === null;
     $readOnlyFields = ['attribute', 'code'];
     $updateViolations = new ConstraintViolationList();
     foreach ($data as $field => $data) {
         $isReadOnlyField = in_array($field, $readOnlyFields);
         if ($isNew || !$isReadOnlyField) {
             try {
                 $this->setData($attributeOption, $field, $data);
             } catch (\InvalidArgumentException $e) {
                 $setViolation = new ConstraintViolation($e->getMessage(), $e->getMessage(), [], $attributeOption, null, null);
                 $updateViolations->add($setViolation);
             }
         }
     }
     $validatorViolations = $this->validator->validate($attributeOption);
     $updateViolations->addAll($validatorViolations);
     if ($updateViolations->count() > 0) {
         throw new BusinessValidationException($updateViolations);
     }
     return $this;
 }

 /**
  * @param Container $container
  * @param object $entity
  * @return \Symfony\Component\Validator\ConstraintViolationInterface[]|ConstraintViolationList
  */
 public function validateContainer(Container $container, $entity)
 {
     if ($entity === NULL) {
         return;
     }
     $meta = $this->em->getClassMetadata(get_class($entity));
     $groups = NULL;
     if ($entity instanceof GroupSequenceProviderInterface) {
         $groups = $entity->getGroupSequence();
     }
     /** @var ConstraintViolationList|ConstraintViolationInterface[] $violations */
     $violations = $this->validator->validate($entity, $groups);
     $this->mapViolationsToForm($container, $violations);
     foreach ($container->getComponents(FALSE, 'Nette\\Forms\\Container') as $child) {
         /** @var Nette\Forms\Container $child */
         if (!$meta->hasAssociation($field = $child->getName())) {
             continue;
         }
         if ($meta->isSingleValuedAssociation($field)) {
             $this->validateContainer($child, $meta->getFieldValue($entity, $field));
         } else {
             throw new NotImplementedException("To many relation is not yet implemented");
         }
     }
 }

 /**
  * @param SourceInterface $source
  *
  * @throws ValidationException
  */
 protected function validate(SourceInterface $source)
 {
     $violations = $this->validator->validate($source);
     if ($violations->count()) {
         throw ValidationException::create($violations);
     }
 }

 /**
  * {@inheritdoc}
  */
 public function process(VariableInterface $variable, VariantInterface $variant)
 {
     if (0 < count($this->validator->validate($variant, array('sylius')))) {
         $variable->removeVariant($variant);
     } else {
         $this->eventDispatcher->dispatch('sylius.variant.pre_create', new GenericEvent($variant));
     }
 }

 /**
  * Add a new enrichment to the indexer
  *
  * @param \Searchperience\Api\Client\Domain\Enrichment\Enrichment $enrichment
  * @throws \Searchperience\Common\Exception\InvalidArgumentException
  * @return integer HTTP Status code
  */
 public function add(\Searchperience\Api\Client\Domain\Enrichment\Enrichment $enrichment)
 {
     $violations = $this->enrichmentValidator->validate($enrichment);
     if ($violations->count() > 0) {
         throw new \Searchperience\Common\Exception\InvalidArgumentException('Given object of type "' . get_class($enrichment) . '" is not valid: ' . PHP_EOL . $violations);
     }
     $status = $this->storageBackend->post($enrichment);
     return $status;
 }

 /**
  * {@inheritdoc}
  */
 public function validate($entity, array $columnsInfo, array $data, array $errors = array())
 {
     $this->checkIdentifier($entity, $columnsInfo, $data);
     if (!count($errors)) {
         return $this->getErrorMap($this->validator->validate($entity));
     } else {
         return $this->validateProperties($entity, $columnsInfo) + $errors;
     }
 }

 /**
  * @param object $filter
  * @throws \Searchperience\Common\Exception\InvalidArgumentException
  */
 protected function validateFilter($filter)
 {
     $this->loadConstraints();
     $this->injectValidator(\Symfony\Component\Validator\Validation::createValidatorBuilder()->enableAnnotationMapping()->getValidator());
     $violations = $this->filterValidator->validate($filter);
     if ($violations->count() > 0) {
         throw new \Searchperience\Common\Exception\InvalidArgumentException('Given object of type "' . get_class($violations) . '" is not valid: ' . $violations);
     }
 }

 /**
  * @{inheritdoc}
  */
 public function validate($object, Violation\ViolationList $violationList)
 {
     $errors = $this->validator->validate($object);
     foreach ($errors as $error) {
         $constraint = call_user_func_array(array($this->model, 'createFromConstraintViolation'), array($error));
         $violationList->add($constraint);
     }
     return $violationList;
 }

 /**
  * Add a new Document to the index
  *
  * @param \Searchperience\Api\Client\Domain\UrlQueueItem\UrlQueueItem $urlQueueItem
  * @throws \Searchperience\Common\Exception\InvalidArgumentException
  * @return integer HTTP Status code
  */
 public function add(\Searchperience\Api\Client\Domain\UrlQueueItem\UrlQueueItem $urlQueueItem)
 {
     $violations = $this->urlQueueValidator->validate($urlQueueItem);
     if ($violations->count() > 0) {
         throw new InvalidArgumentException('Given object of type "' . get_class($urlQueueItem) . '" is not valid: ' . PHP_EOL . $violations);
     }
     $status = $this->storageBackend->post($urlQueueItem);
     return $status;
 }

 /**
  * @param object $object
  */
 public function validate($object)
 {
     $flattenedErros = array();
     $errors = $this->validator->validate($object);
     if (count($errors) > 0) {
         foreach ($errors as $error) {
             $flattenedErros[$error->getPropertyPath()] = $error->getMessage();
         }
         throw new InvalidException("Object is invalid", $flattenedErros);
     }
 }

 public function saveCart(CartEvent $event)
 {
     $cart = $event->getCart();
     $errors = $this->validator->validate($cart);
     $valid = 0 === count($errors);
     if ($valid) {
         $this->cartManager->persist($cart);
         $this->cartManager->flush();
         $this->cartProvider->setCart($cart);
     }
 }

 /**
  * Validate entity, returns list of errors or null
  *
  * @param object $entity
  * @return array|null
  */
 public function validateEntity($entity)
 {
     $violations = $this->validator->validate($entity);
     if (count($violations)) {
         $errors = array();
         /** @var ConstraintViolationInterface $violation */
         foreach ($violations as $violation) {
             $errors[] = sprintf(sprintf('%s: %s', $violation->getPropertyPath(), $violation->getMessage()));
         }
         return $errors;
     }
     return null;
 }

 /**
  * Validates one entity.
  *
  * @param BaseEntity $entity
  * @throws \App\Exceptions\EntityValidationException
  */
 private function validateEntity(BaseEntity $entity)
 {
     /** @var ConstraintViolationListInterface $violationList */
     $violationList = $this->validator->validate($entity);
     if ($violationList->count() > 0) {
         $msg = "";
         /** @var ConstraintViolationInterface $violation */
         foreach ($violationList as $violation) {
             $msg .= get_class($violation->getRoot()) . '::$' . $violation->getPropertyPath();
             $msg .= ' ' . $violation->getMessage() . PHP_EOL;
         }
         throw new EntityValidationException($msg);
     }
 }