A constraint can be defined on a class, an option or a getter method.
The Constraint class encapsulates all the configuration required for
validating this class, option or getter result successfully.
Constraint instances are immutable and serializable.
/** * Checks if current workflow item allows transition * * @param WorkflowData $value * @param TransitionIsAllowed $constraint */ public function validate($value, Constraint $constraint) { /** @var WorkflowItem $workflowItem */ $workflowItem = $constraint->getWorkflowItem(); $transitionName = $constraint->getTransitionName(); $workflow = $this->registry->getWorkflow($workflowItem->getWorkflowName()); $errors = new ArrayCollection(); $result = false; try { $result = $workflow->isTransitionAllowed($workflowItem, $transitionName, $errors, true); } catch (InvalidTransitionException $e) { switch ($e->getCode()) { case InvalidTransitionException::UNKNOWN_TRANSITION: $errors->add(array('message' => $constraint->unknownTransitionMessage, 'parameters' => array('{{ transition }}' => $transitionName))); break; case InvalidTransitionException::NOT_START_TRANSITION: $errors->add(array('message' => $constraint->notStartTransitionMessage, 'parameters' => array('{{ transition }}' => $transitionName))); break; case InvalidTransitionException::STEP_HAS_NO_ALLOWED_TRANSITION: $errors->add(array('message' => $constraint->stepHasNotAllowedTransitionMessage, 'parameters' => array('{{ transition }}' => $transitionName, '{{ step }}' => $workflowItem->getCurrentStep()->getName()))); break; } } if (!$result) { if ($errors->count()) { foreach ($errors as $error) { $this->context->addViolation($error['message'], $error['parameters']); } } else { $this->context->addViolation($constraint->someConditionsNotMetMessage); } } }
public function validate($value, Constraint $constraint) { if (!$constraint instanceof TokenEntity) { throw new \InvalidArgumentException('Given constraint must ne instance of TokenEntity class'); } if ($value) { $configValidation = false; try { /** @var StorageApi $storageApi */ $storageApi = $constraint->getStorageApi(); $token = $storageApi->getToken($value); if (!$token) { throw new \Exception('Token does not exists'); } $userToken = new Token($storageApi); $configValidation = true; $components = new Components(new StorageApi(array('token' => $token['token'], 'url' => $storageApi->getApiUrl(), 'userAgent' => $storageApi->getUserAgent()))); $components->listComponents(new ListConfigurationsOptions()); } catch (\Exception $e) { if ($e instanceof \Keboola\StorageApi\ClientException && $e->getCode() === 403) { //@FIXME jak zmenit api exception code if ($configValidation) { $this->context->addViolation($constraint->configMessage, array('%string%' => $value), null, null, 'TOKEN_PERMISSION'); } else { $this->context->addViolation($constraint->permissionsMessage, array(), null, null, 'TOKEN_PERMISSION'); } } else { $this->context->addViolation($constraint->message, array('%string%' => $value)); } return; } //@FIXME doplnit validaci na master token!!! } }
/** * {@inheritdoc} * * @throws UnexpectedTypeException When the constraint isn't a subclass of {@see AbstractAssertionConstraint} * @throws ConstraintDefinitionException When the assertion doesn't exist on the assertion class */ public function validate($value, Constraint $constraint) { if (!$constraint instanceof AbstractAssertionConstraint) { throw new UnexpectedTypeException($constraint, __NAMESPACE__ . '\\AbstractAssertionConstraint'); } $methodName = $constraint->getAssertionMethodName(); $callable = [static::$assertClass, $methodName]; $override = null; if (is_callable($callable) === false) { throw new ConstraintDefinitionException('Must be a valid callable on the assertion class'); } $parameters = array($value); foreach ($constraint->getAssertionParameterNames() as $name) { $parameters[] = $constraint->{$name}; } try { call_user_func_array($callable, $parameters); } catch (\Exception $e) { if ($e instanceof static::$assertExceptionClass) { $this->context->buildViolation($e->getMessage())->setParameter('{{ value }}', $this->formatValue($value))->setCode($e->getCode())->setCause($e)->addViolation(); } else { throw $e; } } }
/** * Returns the validator for the supplied constraint. * * @param Constraint $constraint A constraint * * @return ConstraintValidatorInterface A validator for the supplied constraint * * @throws UnexpectedTypeException When the validator is not an instance of ConstraintValidatorInterface */ public function getInstance(Constraint $constraint) { $name = $constraint->validatedBy(); if (!isset($this->validators[$name])) { switch (get_class($constraint)) { case self::BASE_NAMESPACE . '\\All': $name = self::BASE_NAMESPACE . '\\LegacyAllValidator'; break; case self::BASE_NAMESPACE . '\\Choice': $name = self::BASE_NAMESPACE . '\\LegacyChoiceValidator'; break; case self::BASE_NAMESPACE . '\\Collection': $name = self::BASE_NAMESPACE . '\\LegacyCollectionValidator'; break; case self::BASE_NAMESPACE . '\\Count': $name = self::BASE_NAMESPACE . '\\LegacyCountValidator'; break; case self::BASE_NAMESPACE . '\\Length': $name = self::BASE_NAMESPACE . '\\LegacyLengthValidator'; break; case self::FORM_BASE_NAMESPACE . '\\Form': $name = self::FORM_BASE_NAMESPACE . '\\LegacyFormValidator'; break; } $this->validators[$name] = new $name(); } elseif (is_string($this->validators[$name])) { $this->validators[$name] = $this->container->get($this->validators[$name]); } if (!$this->validators[$name] instanceof ConstraintValidatorInterface) { throw new UnexpectedTypeException($this->validators[$name], 'Symfony\\Component\\Validator\\ConstraintValidatorInterface'); } return $this->validators[$name]; }
/** * Checks if the passed value is valid. * * @param mixed $value The value that should be validated * @param Constraint $constraint The constraint for the validation * @return bool */ public function validate($value, Constraint $constraint) { /** @var EntityExists $constraint */ if ($constraint->validate($value)) { $this->context->addViolation($constraint->message, ['{{ type }}' => $constraint->entityClass, '{{ value }}' => $value]); } }
public function validate($value, Constraint $constraint) { if (!$constraint instanceof OrchestrationTableEntity) { throw new \InvalidArgumentException('Given constraint must ne instance of OrchestrationTableEntity class'); } if ($value) { // table exists try { /** @var StorageApi $storageApi */ $storageApi = $constraint->getStorageApi(); if (!$storageApi->tableExists($value)) { throw new \Exception('Configuration table does not exists'); } } catch (\Exception $e) { $this->context->addViolation($constraint->message, array('%string%' => $value)); return; } // table structure try { /** @var StorageApi $storageApi */ $storageApi = $constraint->getStorageApi(); $table = $storageApi->getTable($value); $token = new Token($storageApi); $requiredColumns = self::getRequiredColumns(); $missingColumns = array_diff($requiredColumns, $table['columns']); if (!empty($missingColumns)) { throw new \Exception('Invalid configuration table structure'); } } catch (\Exception $e) { $this->context->addViolation($constraint->structureMessage, array('%string%' => implode(', ', $requiredColumns))); return; } } }
/** * {@inheritDoc} */ public function getInstance(Constraint $constraint) { $className = $constraint->validatedBy(); if (!isset($this->validators[$className]) || $className === 'Symfony\\Component\\Validator\\Constraints\\CollectionValidator') { $this->validators[$className] = new $className(); } return $this->validators[$className]; }
/** * {@inheritdoc} */ public function getInstance(Constraint $constraint) { $class_name = $constraint->validatedBy(); if (!isset($this->validators[$class_name])) { $this->validators[$class_name] = $this->classResolver->getInstanceFromDefinition($class_name); } return $this->validators[$class_name]; }
/** * {@inheritdoc} */ public function getInstance(Constraint $constraint) { $className = $constraint->validatedBy(); if (!isset($this->validators[$className])) { $this->validators[$className] = 'validator.expression' === $className ? new ExpressionValidator($this->propertyAccessor) : new $className(); } return $this->validators[$className]; }
/** * @param Constraint $constraint * @return \Symfony\Component\Validator\ConstraintValidatorInterface */ public function getInstance(Constraint $constraint) { $class_name = $constraint->validatedBy(); if (!isset($this->validators[$class_name])) { $this->validators[$class_name] = new $class_name(); } return $this->validators[$class_name]; }
/** * {@inheritdoc} */ public function addConstraint(Constraint $constraint) { if (!in_array(Constraint::PROPERTY_CONSTRAINT, (array) $constraint->getTargets())) { throw new ConstraintDefinitionException(sprintf('The constraint %s cannot be put on properties or getters', get_class($constraint))); } parent::addConstraint($constraint); return $this; }
/** * {@inheritdoc} */ public function getInstance(Constraint $constraint) { $name = $constraint->validatedBy(); if (isset($this->serviceNames[$name])) { return $this->container[$this->serviceNames[$name]]; } return parent::getInstance($constraint); }
function it_doesnt_support_multi_targets_constraint($guesser, $factory, ClassMetadata $metadata, ProductValueInterface $value, AttributeInterface $attribute, Constraint $multiTargets, Constraint $validNumber) { $factory->createMetadata(Argument::any())->willReturn($metadata); $value->getAttribute()->willReturn($attribute); $attribute->getBackendType()->willReturn('varchar'); $guesser->guessConstraints($attribute)->willReturn([$multiTargets]); $multiTargets->getTargets()->willReturn([Constraint::PROPERTY_CONSTRAINT, Constraint::CLASS_CONSTRAINT]); $this->shouldThrow(new \LogicException('No support provided for constraint on many targets'))->duringGetMetadataFor($value); }
/** * Returns the validator for the supplied constraint. * * @param Constraint $constraint A constraint * @return ConstraintValidator A validator for the supplied constraint */ public function getInstance(Constraint $constraint) { $name = $constraint->validatedBy(); if (isset($this->validators[$name])) { return $this->validators[$name]; } $this->validators[$name] = $this->createValidator($name); return $this->validators[$name]; }
/** * {@inheritdoc} */ public function validate($entity, Constraint $constraint) { if (!isset($entity)) { return; } if (!in_array($entity->bundle(), $constraint->getBundleOption())) { $this->context->addViolation($constraint->message, array('%bundle' => implode(', ', $constraint->getBundleOption()))); } }
/** * {@inheritDoc} */ public function validate($value, Constraint $constraint) { $callback = $constraint->getFilterCallback(); $entity = $constraint->getMapper()->findBy($callback($value)); if ($entity instanceof AbstractEntity) { return; } $this->context->addViolation($constraint->message, ['{{ field }}' => $constraint->field, '{{ value }}' => $value], $value); }
/** * {@inheritDoc} */ public function getInstance(Constraint $constraint) { $name = $constraint->validatedBy(); if (!isset($this->validators[$name])) { $this->validators[$name] = new $name(); } elseif (is_string($this->validators[$name])) { $this->validators[$name] = $this->serviceLocator->getService($this->validators[$name]); } return $this->validators[$name]; }
public function validate($commitEntity, Constraint $constraint) { $statusHash = $commitEntity->getStatusHash(); $this->projectEnvironment = $this->projectEnvironmentStorage->getProjectEnviromment($commitEntity->getProject()); $this->gitStatusCommand->overRideGitEnvironment($this->projectEnvironment); $currentStatusHash = $this->gitStatusCommand->getStatusHash(); if ($currentStatusHash !== $statusHash) { $this->context->buildViolation($constraint->getMessage())->setParameter('{{statushash}}', $statusHash)->setParameter('{{currentstatushash}}', $currentStatusHash)->atPath('files')->addViolation(); } }
/** * Returns the validator for the supplied constraint. * * @param Constraint $constraint A constraint * * @return Symfony\Component\Validator\ConstraintValidator A validator for the supplied constraint */ public function getInstance(Constraint $constraint) { $className = $constraint->validatedBy(); if (!isset($this->validators[$className])) { $this->validators[$className] = new $className(); } elseif (is_string($this->validators[$className])) { $this->validators[$className] = $this->container[$this->validators[$className]]; } return $this->validators[$className]; }
/** * @param ClassMetadata $metadata * @param Constraint $constraint * @param AttributeInterface $attribute */ protected function addConstraint(ClassMetadata $metadata, Constraint $constraint, AttributeInterface $attribute) { $target = $constraint->getTargets(); if (is_array($target)) { throw new \LogicException('No support provided for constraint on many targets'); } elseif (Constraint::PROPERTY_CONSTRAINT === $target) { $metadata->addPropertyConstraint($attribute->getBackendType(), $constraint); } elseif (Constraint::CLASS_CONSTRAINT === $target) { $metadata->addConstraint($constraint); } }
/** * {@inheritDoc} */ public function addConstraint(Constraint $constraint) { if (!in_array(Constraint::PROPERTY_CONSTRAINT, (array) $constraint->targets())) { throw new ConstraintDefinitionException(sprintf('The constraint %s cannot be put on properties or getters', get_class($constraint))); } if ($constraint instanceof Valid) { $this->cascaded = true; } else { parent::addConstraint($constraint); } return $this; }
/** * Checks if the passed value is valid. * * @param mixed $value The value that should be validated * @param Constraint $constraint The constraint for the validation * * @api */ public function validate($value, Constraint $constraint) { $groupName = $constraint->getGroupName(); foreach ($value as $user) { $groups = $user->getGroups(); foreach ($groups as $group) { if ($group->getName() != $groupName) { $this->context->addViolation('message', array('%group%' => $groupName)); } } } }
/** * Checks if the passed value is valid. * * @api * * @param mixed $value The value that should be validated * @param \Symfony\Component\Validator\Constraint|\Spryker\Zed\Category\Communication\Constraint\CategoryNameExists $constraint The constraint for the validation * * @return void */ public function validate($value, Constraint $constraint) { $idLocale = $constraint->getLocale()->getIdLocale(); $idCategory = $constraint->getIdCategory(); $categoryQueryContainer = $constraint->getQueryContainer(); $categoryEntity = $categoryQueryContainer->queryCategory($value, $idLocale)->findOne(); if ($categoryEntity !== null) { if ($idCategory === null || $idCategory !== $categoryEntity->getIdCategory()) { $this->addViolation($value, $constraint); } } }
public function getInstance(Constraint $constraint) { $className = $constraint->validatedBy(); if (!isset($this->validators[$className])) { if (class_exists($className)) { $this->validators[$className] = new $className(); } else { $this->validators[$className] = $this->app[$className]; } } return $this->validators[$className]; }
/** * Returns the validator for the supplied constraint. * * @param Constraint $constraint A constraint * * @return ConstraintValidatorInterface A validator for the supplied constraint * * @throws UnexpectedTypeException When the validator is not an instance of ConstraintValidatorInterface */ public function getInstance(Constraint $constraint) { $name = $constraint->validatedBy(); if (!isset($this->validators[$name])) { $this->validators[$name] = new $name(); } elseif (is_string($this->validators[$name])) { $this->validators[$name] = $this->container->get($this->validators[$name]); } if (!$this->validators[$name] instanceof ConstraintValidatorInterface) { throw new UnexpectedTypeException($this->validators[$name], 'Symfony\\Component\\Validator\\ConstraintValidatorInterface'); } return $this->validators[$name]; }
/** * Returns a contraint validator from the container service, setting it if it * doesn't exist yet * * Throws an exception if validator service is not instance of * ConstraintValidatorInterface. * * @param Constraint $constraint * @return ConstraintValidatorInterface * @throws \LogicException */ public function getInstance(Constraint $constraint) { $className = $constraint->validatedBy(); $id = $this->getServiceIdFromClass($className); if (!$this->container->has($id)) { $this->container->set($id, new $className()); } $validator = $this->container->get($id); if (!$validator instanceof ConstraintValidatorInterface) { throw new \LogicException('Service "' . $id . '" is not instance of ConstraintValidatorInterface'); } return $validator; }
private function validateSize(Constraint $constraint, $size, $type, array $parameters) { if ($constraint->min == $constraint->max && $size != $constraint->max) { $this->context->addViolation($constraint->getExactMessage($type), array_merge(array('{{ limit }}' => $constraint->max), $parameters), null, (int) $constraint->max); return; } if (null !== $constraint->max && $size > $constraint->max) { $this->context->addViolation($constraint->getMaxMessage($type), array_merge(array('{{ limit }}' => $constraint->max), $parameters), null, (int) $constraint->max); return; } if (null !== $constraint->min && $size < $constraint->min) { $this->context->addViolation($constraint->getMinMessage($type), array_merge(array('{{ limit }}' => $constraint->min), $parameters), null, (int) $constraint->min); } }
/** * {@inheritdoc} */ public function validate($value, Constraint $constraint) { /* @var OwnOrAdminConstraintInterface $constraint */ $account = $constraint->getAccount(); if ($value == $account->id()) { // No violation if the user is the same as the provided one. return NULL; } if ($account->hasPermission($constraint->getPermission())) { // No violation if the current user has admin rights. return NULL; } $this->context->addViolation($constraint->message, ['@permission' => $constraint->getPermission()]); }
public function validate($value, Constraint $constraint) { $today = new \DateTime(); if ($value > $today) { $this->context->addViolation($constraint->message1); } if ($value <= $constraint->getColonie()->getDateColonie()) { $this->context->addViolation($constraint->message2); } if (!$constraint->getColonie()->getVisites()->isEmpty()) { if ($value <= $constraint->getColonie()->getVisites()->last()->getDate()) { $this->context->addViolation($constraint->message3); } } if (!$constraint->getColonie()->getRemerages()->isEmpty()) { if ($value <= $constraint->getColonie()->getRemerages()->last()->getDate()) { $this->context->addViolation($constraint->message4); } } if (!$constraint->getColonie()->getTranshumances()->isEmpty()) { if ($value <= $constraint->getColonie()->getTranshumances()->last()->getDate()) { $this->context->addViolation($constraint->message5); } } }
/** * {@inheritDoc} */ public function __construct($options = null) { if (!isset($options['value'])) { throw new ConstraintDefinitionException(sprintf('The %s constraint requires the "value" option to be set.', get_class($this))); } parent::__construct($options); }