/**
* {@inheritdoc}
*/
public function buildForm(FormBuilderInterface $builder, array $options)
{
if (empty($options['data_class'])) {
return;
}
$className = $options['data_class'];
if (!$this->doctrineHelper->isManageableEntity($className)) {
return;
}
if (!$this->entityConfigProvider->hasConfig($className)) {
return;
}
$uniqueKeys = $this->entityConfigProvider->getConfig($className)->get('unique_key');
if (empty($uniqueKeys)) {
return;
}
/* @var \Symfony\Component\Validator\Mapping\ClassMetadata $validatorMetadata */
$validatorMetadata = $this->validator->getMetadataFor($className);
foreach ($uniqueKeys['keys'] as $uniqueKey) {
$fields = $uniqueKey['key'];
$labels = array_map(function ($fieldName) use($className) {
$label = $this->entityConfigProvider->getConfig($className, $fieldName)->get('label');
return $this->translator->trans($label);
}, $fields);
$constraint = new UniqueEntity(['fields' => $fields, 'errorPath' => '', 'message' => $this->translator->transChoice('oro.entity.validation.unique_field', sizeof($fields), ['%field%' => implode(', ', $labels)])]);
$validatorMetadata->addConstraint($constraint);
}
}
/**
* Merges constraints from the form with constraints in the class metaData
*
* @param FormInterface $form
*/
public function mergeConstraints(FormInterface &$form)
{
$metaData = null;
$dataClass = $form->getConfig()->getDataClass();
if ($dataClass != '') {
$metaData = $this->validator->getMetadataFor($dataClass);
}
if ($metaData instanceof ClassMetadata) {
/**
* @var FormInterface $child
*/
foreach ($form->all() as $child) {
$options = $child->getConfig()->getOptions();
$name = $child->getConfig()->getName();
$type = $child->getConfig()->getType()->getName();
if (isset($options['constraints'])) {
$existingConstraints = $options['constraints'];
$extractedConstraints = $this->extractPropertyConstraints($name, $metaData);
// Merge all constraints
$options['constraints'] = array_merge($existingConstraints, $extractedConstraints);
}
$form->add($name, $type, $options);
}
}
}
/**
* @param string $columnName
* @param string $entityName
* @param array $column
*
* @return array
*/
public function getColumnOptions($columnName, $entityName, $column)
{
/** @var ValidatorInterface $validatorMetadata */
$validatorMetadata = $this->validator->getMetadataFor($entityName);
foreach ($this->guessers as $guesser) {
$options = $guesser->guessColumnOptions($columnName, $entityName, $column);
if (!empty($options)) {
if ($validatorMetadata->hasPropertyMetadata($columnName)) {
$options[Configuration::BASE_CONFIG_KEY]['validation_rules'] = $this->getValidationRules($validatorMetadata, $columnName);
}
return $options;
}
}
return [];
}
/**
* Is required property
*
* @param \ReflectionProperty $property
* @param array $groups
*
* @return bool
*/
private function isPropertyRequired(\ReflectionProperty $property, array $groups)
{
if (!$this->validator) {
// Can not check...
return true;
}
$metadata = $this->validator->getMetadataFor($property->getDeclaringClass()->getName());
if (!$metadata instanceof ClassMetadata) {
return true;
}
$propertyMetadata = $metadata->getPropertyMetadata($property->getName());
if ($propertyMetadata) {
// @todo: merge all metadata?
$propertyMetadata = array_pop($propertyMetadata);
foreach ($groups as $group) {
$constraints = $propertyMetadata->findConstraints($group);
foreach ($constraints as $constraint) {
if ($constraint instanceof NotBlank) {
return true;
}
}
}
}
return false;
}
/**
* @param string $name
* @throws \NForms\Exceptions\MetadataException
* @return \Symfony\Component\Validator\Constraint[]
*/
public function getConstraintsForField($name)
{
/** @var ClassMetadata $metadata */
$metadata = $this->validator->getMetadataFor($this->class);
// if (!property_exists($this->getClass(), $name)) {
// throw new MetadataException("Field '$name' was not found in the class '{$this->getClass()}'.");
// }
$constraints = array();
$validationGroups = $this->validationGroups ?: array(Constraint::DEFAULT_GROUP);
foreach ($validationGroups as $validationGroup) {
/** @var PropertyMetadata $propertyMetadata */
foreach ($metadata->getPropertyMetadata($name) as $propertyMetadata) {
$constraints += $propertyMetadata->findConstraints($validationGroup);
}
}
$constraints = array_unique($constraints, SORT_REGULAR);
// remove duplicates
return $constraints;
}
public function __construct(ValidatorInterface $validator)
{
$metadata = $validator->getMetadataFor('Symfony\\Component\\Form\\Form');
// Register the form constraints in the validator programmatically.
// This functionality is required when using the Form component without
// the DIC, where the XML file is loaded automatically. Thus the following
// code must be kept synchronized with validation.xml
/* @var $metadata ClassMetadata */
$metadata->addConstraint(new Form());
$metadata->addPropertyConstraint('children', new Valid());
$this->validator = $validator;
}
/**
* @param FormInterface $form
*
* @return array
*/
private function getEntityConstraints(FormInterface $form)
{
$config = $form->getParent()->getConfig();
if (!$config->hasOption('data_class') || !class_exists($config->getOption('data_class'))) {
return [];
}
$constraints = [];
/** @var ClassMetadata $metadata */
$metadata = $this->validator->getMetadataFor($config->getDataClass());
/** @var PropertyMetadata[] $properties */
$properties = $metadata->getPropertyMetadata($form->getName());
foreach ($properties as $property) {
$constraints = array_merge($constraints, $property->findConstraints($metadata->getDefaultGroup()));
}
return $constraints;
}
/**
* @param ValidatorInterface|LegacyValidatorInterface $validator
*
* @throws UnexpectedTypeException If $validator is invalid
*/
public function __construct($validator)
{
// 2.5 API
if ($validator instanceof ValidatorInterface) {
$metadata = $validator->getMetadataFor('Symfony\\Component\\Form\\Form');
// 2.4 API
} elseif ($validator instanceof LegacyValidatorInterface) {
$metadata = $validator->getMetadataFactory()->getMetadataFor('Symfony\\Component\\Form\\Form');
} else {
throw new UnexpectedTypeException($validator, 'Symfony\\Component\\Validator\\Validator\\ValidatorInterface or Symfony\\Component\\Validator\\ValidatorInterface');
}
// Register the form constraints in the validator programmatically.
// This functionality is required when using the Form component without
// the DIC, where the XML file is loaded automatically. Thus the following
// code must be kept synchronized with validation.xml
/** @var $metadata ClassMetadata */
$metadata->addConstraint(new Form());
$metadata->addPropertyConstraint('children', new Valid());
$this->validator = $validator;
}
/**
* @param ValidatorInterface|LegacyValidatorInterface $validator
*
* @throws UnexpectedTypeException If $validator is invalid
*/
public function __construct($validator)
{
// 2.5 API
if ($validator instanceof ValidatorInterface) {
$metadata = $validator->getMetadataFor('Symfony\\Component\\Form\\Form');
// 2.4 API
} elseif ($validator instanceof LegacyValidatorInterface) {
@trigger_error('Passing an instance of Symfony\\Component\\Validator\\ValidatorInterface as argument to the ' . __METHOD__ . ' method is deprecated since version 2.8 and will be removed in 3.0. Use an implementation of Symfony\\Component\\Validator\\Validator\\ValidatorInterface instead', E_USER_DEPRECATED);
$metadata = $validator->getMetadataFactory()->getMetadataFor('Symfony\\Component\\Form\\Form');
} else {
throw new UnexpectedTypeException($validator, 'Symfony\\Component\\Validator\\Validator\\ValidatorInterface or Symfony\\Component\\Validator\\ValidatorInterface');
}
// Register the form constraints in the validator programmatically.
// This functionality is required when using the Form component without
// the DIC, where the XML file is loaded automatically. Thus the following
// code must be kept synchronized with validation.xml
/* @var $metadata ClassMetadata */
$metadata->addConstraint(new Form());
$metadata->addPropertyConstraint('children', new Valid());
$this->validator = $validator;
}
/**
* Attach the inline validator to the model metadata, this must be done once per admin.
*/
protected function attachInlineValidator()
{
$admin = $this;
// add the custom inline validation option
// TODO: Remove conditional method when bumping requirements to SF 2.5+
if (method_exists($this->validator, 'getMetadataFor')) {
$metadata = $this->validator->getMetadataFor($this->getClass());
} else {
$metadata = $this->validator->getMetadataFactory()->getMetadataFor($this->getClass());
}
$metadata->addConstraint(new InlineConstraint(array('service' => $this, 'method' => function (ErrorElement $errorElement, $object) use($admin) {
/* @var \Sonata\AdminBundle\Admin\AdminInterface $admin */
// This avoid the main validation to be cascaded to children
// The problem occurs when a model Page has a collection of Page as property
if ($admin->hasSubject() && spl_object_hash($object) !== spl_object_hash($admin->getSubject())) {
return;
}
$admin->validate($errorElement, $object);
foreach ($admin->getExtensions() as $extension) {
$extension->validate($admin, $errorElement, $object);
}
}, 'serializingWarning' => true)));
}
public function getMetadataFor($value)
{
return $this->wrappedValidator->getMetadataFor($value);
}
