/** * {@inheritdoc} */ public function loadClassMetadata(ClassMetadataInterface $classMetadata, array $normalizationGroups = null, array $denormalizationGroups = null, array $validationGroups = null) { $validatorClassMetadata = $this->validatorMetadataFactory->getMetadataFor($classMetadata->getName()); foreach ($classMetadata->getAttributesMetadata() as $attributeName => $attributeMetadata) { foreach ($validatorClassMetadata->getPropertyMetadata($attributeName) as $propertyMetadata) { if (null === $validationGroups) { foreach ($propertyMetadata->findConstraints($validatorClassMetadata->getDefaultGroup()) as $constraint) { if ($this->isRequired($constraint)) { $attributeMetadata = $attributeMetadata->withRequired(true); break 2; } } } else { foreach ($validationGroups as $validationGroup) { if (!is_string($validationGroup)) { continue; } foreach ($propertyMetadata->findConstraints($validationGroup) as $constraint) { if ($this->isRequired($constraint)) { $attributeMetadata = $attributeMetadata->withRequired(true); break 3; } } } } } $classMetadata = $classMetadata->withAttributeMetadata($attributeName, $attributeMetadata); } return $classMetadata; }
/** * Gets ClassMetadata of desired class with annotations and others (xml, yml, php) using metadata factory * * @param string $className * * @return ClassMetadata Returns ClassMetadata object of desired entity with annotations info */ public function getClassMetadata($className) { if (!isset($this->classesMetadata[$className])) { $this->classesMetadata[$className] = $this->metadataFactory->getMetadataFor($className); } return $this->classesMetadata[$className]; }
/** * {@inheritdoc} */ public function loadClassMetadata(ClassMetadata $classMetadata, array $normalizationGroups = null, array $denormalizationGroups = null, array $validationGroups = null) { $validatorClassMetadata = $this->validatorMetadataFactory->getMetadataFor($classMetadata->getName()); foreach ($classMetadata->getAttributes() as $attributeMetadata) { $attributeName = $attributeMetadata->getName(); foreach ($validatorClassMetadata->getPropertyMetadata($attributeName) as $propertyMetadata) { if (null === $validationGroups) { foreach ($propertyMetadata->findConstraints($validatorClassMetadata->getDefaultGroup()) as $constraint) { if ($this->isRequired($constraint)) { $attributeMetadata->setRequired(true); break 2; } } } else { foreach ($validationGroups as $validationGroup) { foreach ($propertyMetadata->findConstraints($validationGroup) as $constraint) { if ($this->isRequired($constraint)) { $attributeMetadata->setRequired(true); break 3; } } } } } } return true; }
public function testGenerateClass() { $constraint = new Range(array('min' => 10)); $cm = new ClassMetadata(__NAMESPACE__ . '\\TestEntity'); $cm->addPropertyConstraint('field1', $constraint); $this->metadataFactory->expects($this->once())->method('getMetadataFor')->will($this->returnValue($cm)); $data = $this->generator->generateClass(__NAMESPACE__ . '\\TestEntity'); $this->assertArrayHasKey('field1', $data); $this->assertArrayHasKey('range', $data['field1']); $this->assertEquals($constraint, $data['field1']['range']); }
/** * @param Node $node * @return void */ public function enterNode(Node $node) { if ($node instanceof Node\Stmt\Namespace_) { if (isset($node->name)) { $this->namespace = implode('\\', $node->name->parts); } return; } if (!$node instanceof Node\Stmt\Class_) { return; } $name = '' === $this->namespace ? $node->name : $this->namespace . '\\' . $node->name; if (!class_exists($name)) { return; } $metadata = $this->metadataFactory instanceof ClassMetadataFactoryInterface ? $this->metadataFactory->getClassMetadata($name) : $this->metadataFactory->getMetadataFor($name); if (!$metadata->hasConstraints() && !count($metadata->getConstrainedProperties())) { return; } $this->extractFromConstraints($metadata->constraints); foreach ($metadata->members as $members) { foreach ($members as $member) { $this->extractFromConstraints($member->constraints); } } }
/** * Generate array representation of constraints that is exported to JSON. * * @param string $className * @return array */ public function generateClass($className) { $data = array(); $metadata = $this->metadataFactory->getMetadataFor($className); $properties = $metadata->getConstrainedProperties(); foreach ($properties as $property) { $data[$property] = array(); $constraintsList = $metadata->getPropertyMetadata($property); foreach ($constraintsList as $constraints) { foreach ($constraints->constraints as $constraint) { $const = $this->translateConstraint($constraint); $data[$property][$this->getConstraintName($const)] = $const; } } } return $data; }
/** * {@inheritdoc} */ public function validatePropertyValue($object, $property_name, $value, $groups = NULL) { if (!is_object($object)) { throw new \InvalidArgumentException('Passing class name is not supported.'); } elseif (!$object instanceof TypedDataInterface) { throw new \InvalidArgumentException('The passed in object has to be typed data.'); } elseif (!$object instanceof ListInterface && !$object instanceof ComplexDataInterface) { throw new \InvalidArgumentException('Passed data does not contain properties.'); } $data = $object->get($property_name); $metadata = $this->metadataFactory->getMetadataFor($data); $constraints = $metadata->findConstraints(Constraint::DEFAULT_GROUP); return $this->validate($value, $constraints, $groups, TRUE); }
/** * Validates an object against the constraints defined for its class. * * If no metadata is available for the class, but the class is an instance * of {@link \Traversable} and the selected traversal strategy allows * traversal, the object will be iterated and each nested object will be * validated instead. * * @param object $object The object to cascade * @param string $propertyPath The current property path * @param string[] $groups The validated groups * @param int $traversalStrategy The strategy for traversing the * cascaded object * @param ExecutionContextInterface $context The current execution context * * @throws NoSuchMetadataException If the object has no associated metadata * and does not implement {@link \Traversable} * or if traversal is disabled via the * $traversalStrategy argument * @throws UnsupportedMetadataException If the metadata returned by the * metadata factory does not implement * {@link ClassMetadataInterface} */ private function validateObject($object, $propertyPath, array $groups, $traversalStrategy, ExecutionContextInterface $context) { try { $classMetadata = $this->metadataFactory->getMetadataFor($object); if (!$classMetadata instanceof ClassMetadataInterface) { throw new UnsupportedMetadataException(sprintf('The metadata factory should return instances of ' . '"Symfony\\Component\\Validator\\Mapping\\ClassMetadataInterface", ' . 'got: "%s".', is_object($classMetadata) ? get_class($classMetadata) : gettype($classMetadata))); } $this->validateClassNode($object, spl_object_hash($object), $classMetadata, $propertyPath, $groups, null, $traversalStrategy, $context); } catch (NoSuchMetadataException $e) { // Rethrow if not Traversable if (!$object instanceof \Traversable) { throw $e; } // Rethrow unless IMPLICIT or TRAVERSE if (!($traversalStrategy & (TraversalStrategy::IMPLICIT | TraversalStrategy::TRAVERSE))) { throw $e; } $this->validateEachObjectIn($object, $propertyPath, $groups, $context); } }
/** * {@inheritdoc} */ public function hasMetadataFor($object) { return $this->metadataFactory->hasMetadataFor($object); }