Returns the violation message.
public getMessage ( ) : string | ||
return | string |
public function testConstraintViolationCanHandleArrayValue() { $constraint = new Type(array('type' => 'string')); $this->validator->isValid(array(0 => "Test"), $constraint); $violation = new ConstraintViolation('{{ value }}', $this->validator->getMessageParameters(), '', '', ''); $this->assertEquals('Array', $violation->getMessage()); }
protected function getConstraintViolation(ConstraintViolation $constraintViolation, array &$messages) { $path = new PropertyPath($constraintViolation->getPropertyPath()); $elements = $path->getElements(); $elements[] = $constraintViolation->getConstraint()->validatedBy(); $this->propertyAccessor->setValue($messages, $this->buildPath($elements), $constraintViolation->getMessage()); }
public function assert($input) { if (!$this->validate($input)) { $violation = new ConstraintViolation($this->validator->getMessageTemplate(), $this->validator->getMessageParameters(), '', '', $input); throw $this->reportError($violation->getMessage()); } return true; }
public function serializeViolation(LuaSerializationVisitor $visitor, ConstraintViolation $violation, array $type = null) { $data = ['property_path' => $violation->getPropertyPath(), 'message' => $violation->getMessage()]; if (null === $visitor->getRoot()) { $visitor->setRoot($data); } return $data; }
/** * Output validation error to console * * @param Exception $e **/ protected function outputViolation(ConstraintViolation $v) { $this->output->writeln("<error>" . $v->getMessage() . "</error>"); }
private function printError(ConstraintViolation $violation, $experimental, $indent) { $this->output->writeln(str_repeat(' ', $indent) . '- <fg=' . ($experimental ? 'yellow' : 'red') . '>' . ($experimental ? '(experimental) ' : '') . $violation->getMessage() . '</>'); }
/** * {@inheritdoc} */ public function mapViolation(ConstraintViolation $violation, FormInterface $form, $allowNonSynchronized = false) { $this->allowNonSynchronized = $allowNonSynchronized; // The scope is the currently found most specific form that // an error should be mapped to. After setting the scope, the // mapper will try to continue to find more specific matches in // the children of scope. If it cannot, the error will be // mapped to this scope. $scope = null; $violationPath = null; $relativePath = null; $match = false; // Don't create a ViolationPath instance for empty property paths if (strlen($violation->getPropertyPath()) > 0) { $violationPath = new ViolationPath($violation->getPropertyPath()); $relativePath = $this->reconstructPath($violationPath, $form); } // This case happens if the violation path is empty and thus // the violation should be mapped to the root form if (null === $violationPath) { $scope = $form; } // In general, mapping happens from the root form to the leaf forms // First, the rules of the root form are applied to determine // the subsequent descendant. The rules of this descendant are then // applied to find the next and so on, until we have found the // most specific form that matches the violation. // If any of the forms found in this process is not synchronized, // mapping is aborted. Non-synchronized forms could not reverse // transform the value entered by the user, thus any further violations // caused by the (invalid) reverse transformed value should be // ignored. if (null !== $relativePath) { // Set the scope to the root of the relative path // This root will usually be $form. If the path contains // an unmapped form though, the last unmapped form found // will be the root of the path. $scope = $relativePath->getRoot(); $it = new PropertyPathIterator($relativePath); while ($this->acceptsErrors($scope) && null !== ($child = $this->matchChild($scope, $it))) { $scope = $child; $it->next(); $match = true; } } // This case happens if an error happened in the data under a // form inheriting its parent data that does not match any of the // children of that form. if (null !== $violationPath && !$match) { // If we could not map the error to anything more specific // than the root element, map it to the innermost directly // mapped form of the violation path // e.g. "children[foo].children[bar].data.baz" // Here the innermost directly mapped child is "bar" $scope = $form; $it = new ViolationPathIterator($violationPath); // Note: acceptsErrors() will always return true for forms inheriting // their parent data, because these forms can never be non-synchronized // (they don't do any data transformation on their own) while ($this->acceptsErrors($scope) && $it->valid() && $it->mapsForm()) { if (!$scope->has($it->current())) { // Break if we find a reference to a non-existing child break; } $scope = $scope->get($it->current()); $it->next(); } } // Follow dot rules until we have the final target $mapping = $scope->getConfig()->getOption('error_mapping'); while ($this->acceptsErrors($scope) && isset($mapping['.'])) { $dotRule = new MappingRule($scope, '.', $mapping['.']); $scope = $dotRule->getTarget(); $mapping = $scope->getConfig()->getOption('error_mapping'); } // Only add the error if the form is synchronized if ($this->acceptsErrors($scope)) { $scope->addError(new FormError($violation->getMessage(), $violation->getMessageTemplate(), $violation->getMessageParameters(), $violation->getMessagePluralization())); } }
/** * Creates a JSON error response from a ConstraintViolation */ protected function createValidationErrorResponse(ConstraintViolation $violation) { return $this->createErrorResponse("The '" . $violation->getPropertyPath() . "' value is invalid.", $violation->getMessage()); }
/** * @param ConstraintViolationInterface|ConstraintViolation $error * @return array */ private function getValidationErrorArray($error) { return ['i18nKey' => method_exists($error->getConstraint(), 'getI18nKey') ? $error->getConstraint()->getI18nKey() : get_class($error->getConstraint()), 'messageTemplate' => $error->getMessageTemplate(), 'plural' => $error->getPlural(), 'invalidValue' => $error->getInvalidValue(), 'parameters' => $error->getParameters(), 'message' => $error->getMessage(), 'path' => $error->getPropertyPath()]; }
public function serializeViolationToYml(YamlSerializationVisitor $visitor, ConstraintViolation $violation, array $type = null) { return array('property_path' => $violation->getPropertyPath(), 'message' => $violation->getMessage()); }