/** * @param array $request * @param \ReflectionClass $class * @param callable $nameMangling * * @return ConversionResult */ public function convert(array $request, \ReflectionClass $class, callable $nameMangling) { $ctx = new Context($this, $this->coercer, $nameMangling); $object = $this->instance($class); $setter = $this->setter($object); $errors = []; foreach ($class->getProperties() as $prop) { $name = $nameMangling($prop->getName()); if (!isset($request[$name]) && !$this->reader->getPropertyAnnotation($prop, Optional::class)) { $errors[] = new MissingFieldError($name); continue; } elseif (!\array_key_exists($name, $request)) { continue; } $value = $request[$name]; $typeAnnotation = $this->reader->getPropertyAnnotation($prop, Type::class); if ($value !== null && $typeAnnotation instanceof Type) { try { $result = $this->coercer->coerce($value, $typeAnnotation->type, $ctx); } catch (CoercionException $e) { throw ConverterException::in($class->getName(), $prop->getName(), $e); } $value = $result->getValue(); $errors = \array_merge($errors, $result->errorsInField($name)); $setter->set($prop->getName(), $value); } elseif ($value === null) { $setter->set($prop->getName(), null); } } return ConversionResult::errors($errors, $object); }
/** * @param \ReflectionClass $class * * @return \Metadata\ClassMetadata */ public function loadMetadataForClass(\ReflectionClass $class) { $metadata = new ClassMetadata($class->getName()); // Resource annotation $annotation = $this->reader->getClassAnnotation($class, 'Conjecto\\Nemrod\\ResourceManager\\Annotation\\Resource'); if (null !== $annotation) { $types = $annotation->types; $pattern = $annotation->uriPattern; if (!is_array($types)) { $types = array($types); } $metadata->types = $types; $metadata->uriPattern = $pattern; } foreach ($class->getProperties() as $reflectionProperty) { $propMetadata = new PropertyMetadata($class->getName(), $reflectionProperty->getName()); // Property annotation $annotation = $this->reader->getPropertyAnnotation($reflectionProperty, 'Conjecto\\Nemrod\\ResourceManager\\Annotation\\Property'); if (null !== $annotation) { $propMetadata->value = $annotation->value; $propMetadata->cascade = $annotation->cascade; } $metadata->addPropertyMetadata($propMetadata); } return $metadata; }
/** * @param \ReflectionClass $class * * @return \Metadata\ClassMetadata */ public function loadMetadataForClass(\ReflectionClass $class) { $metadata = $this->driver->loadMetadataForClass($class); foreach ($metadata->propertyMetadata as $key => $propertyMetadata) { $type = $propertyMetadata->type['name']; if (!$propertyMetadata->reflection) { continue; } /** @var PropertyMetadata $propertyMetadata */ /** @var HandledType $annot */ $annot = $this->reader->getPropertyAnnotation($propertyMetadata->reflection, HandledType::class); if (!$annot) { continue; } $isCollection = false; $collectionType = null; if (in_array($type, ['array', 'ArrayCollection'], true)) { $isCollection = true; $collectionType = $type; $type = $propertyMetadata->type['params'][0]['name']; } $handler = $annot->handler ?: 'Relation'; $newType = sprintf('%s<%s>', $handler, $type); if ($isCollection) { $newType = sprintf('%s<%s<%s>>', $collectionType, $handler, $type); } $propertyMetadata->setType($newType); } return $metadata; }
/** * @param $object * @param $classRefl * @param $segmentData * @throws MandatorySegmentPieceMissing */ protected function fillFromArray($object, $classRefl, $segmentData) { foreach ($classRefl->getProperties() as $propRefl) { $isSegmentPiece = $this->annotationReader->getPropertyAnnotation($propRefl, SegmentPiece::class); if ($isSegmentPiece) { $piece = isset($segmentData[$isSegmentPiece->position]) ? $segmentData[$isSegmentPiece->position] : null; $propRefl->setAccessible(true); if ($isSegmentPiece->parts) { $value = array(); $i = 0; foreach ($isSegmentPiece->parts as $k => $part) { if (!is_numeric($k) && is_array($part)) { $partName = $k; if (!empty($piece) && in_array("@mandatory", $part) && $this->isEmpty($piece[$i])) { throw new MandatorySegmentPieceMissing(sprintf("Segment %s part %s missing value at offset %d", $segmentData[0], $partName, $i)); } } else { $partName = $part; } $value[$partName] = isset($piece[$i]) ? $piece[$i] : null; ++$i; } $propRefl->setValue($object, $value); } else { $propRefl->setValue($object, $piece); } } } }
public function getForm(ResourceInterface $resource) { $resourceClassName = \Doctrine\Common\Util\ClassUtils::getClass($resource); $resourceParts = explode("\\", $resourceClassName); $resourceParts[count($resourceParts) - 2] = 'Form'; $resourceParts[count($resourceParts) - 1] .= 'Type'; $formType = implode("\\", $resourceParts); if (class_exists($formType)) { return $this->formFactory->create(new $formType(), $resource); } $options = array('data_class' => $resourceClassName); $builder = $this->formFactory->createBuilder('form', $resource, $options); $reflectionClass = new \ReflectionClass($resourceClassName); $annotationClass = 'uebb\\HateoasBundle\\Annotation\\FormField'; foreach ($reflectionClass->getProperties() as $propertyReflection) { /** * @var \uebb\HateoasBundle\Annotation\FormField $annotation */ $annotation = $this->annotationReader->getPropertyAnnotation($propertyReflection, $annotationClass); if ($annotation) { $builder->add($propertyReflection->getName(), $annotation->type, is_array($annotation->options) ? $annotation->options : array()); } } $form = $builder->getForm(); return $form; }
/** * @param ReflectionClass $class * * @return array */ public function getProperties(ReflectionClass $class) { $properties = $class->getProperties(); $propertyAnnotations = []; foreach ($properties as $property) { $annotationName = $this->reader->getPropertyAnnotation($property, Field::class); if ($annotationName) { $annotationName = $annotationName->getName(); $propertyAnnotations[$property->getName()] = $annotationName; } } return array_flip($propertyAnnotations); }
/** * @param EmbeddedMetadataInterface $embeddedMetadata * * @return EmbeddedMetadataInterface */ private function addNestedEmbeddedClasses(EmbeddedMetadataInterface $embeddedMetadata) { $reflClass = new \ReflectionClass($embeddedMetadata->getClassAttribute()); foreach ($reflClass->getProperties() as $reflProperty) { if ($annotation = $this->reader->getPropertyAnnotation($reflProperty, Index::class)) { $embeddedMetadata->addEmbeddableClass(new IndexMetadata($reflProperty->class, $reflProperty->name, $annotation->name, $annotation->type)); } if ($annotation = $this->reader->getPropertyAnnotation($reflProperty, Embedded::class)) { $nested = $this->addNestedEmbeddedClasses(new EmbeddedMetadata($reflProperty->class, $reflProperty->name, $annotation->class)); $embeddedMetadata->addEmbeddableClass($nested); } } return $embeddedMetadata; }
/** * Attempts to read the uploadable field annotation of the * specified property. * * @param \ReflectionClass $class The class. * @param string $field The field * @return null|\Vich\UploaderBundle\Annotation\UploadableField The uploadable field. */ public function readUploadableField(\ReflectionClass $class, $field) { try { $prop = $class->getProperty($field); $field = $this->reader->getPropertyAnnotation($prop, 'Vich\\UploaderBundle\\Mapping\\Annotation\\UploadableField'); if (null === $field) { return null; } $field->setPropertyName($prop->getName()); return $field; } catch (\ReflectionException $e) { return null; } }
/** * Get the designated class name from the given property * * @param mixed $property Can be either a \ReflectionProperty or a primitive string type. * @return string If $property was a primitive string type (ie <array>) then that string is returned. * If $property is a \ReflectionProperty, the type of that property is returned, or null if * one could not be determined. */ public function getTypeFromProperty($property) { if (is_string($property)) { throw new \InvalidArgumentException('Parameter $property cannot be a string unless the string is a valid primitive type'); } $typeAnnotation = $this->annotationReader->getPropertyAnnotation($property, 'Rezonant\\MapperBundle\\Annotations\\Type'); if ($typeAnnotation) { return $typeAnnotation->value; } $typeAnnotation = $this->annotationReader->getPropertyAnnotation($property, 'JMS\\Serializer\\Annotation\\Type'); if ($typeAnnotation) { return $typeAnnotation->name; } return null; }
/** * Form annotation converter. * * @param object $form * * @return array */ public function convert($form) { $data = array(); $reflection = new \ReflectionObject($form); foreach ($reflection->getProperties() as $property) { $annotation = $this->_reader->getPropertyAnnotation($property, $this->_annotation); if ($annotation !== null) { if (method_exists($annotation, 'setName')) { $annotation->setName($property->getName()); } $data[] = $annotation; } } return $data; }
/** * {@inheritdoc} */ public function loadMetadataForClass(\ReflectionClass $class) { $classMetadata = new MergeableClassMetadata($class->getName()); foreach ($class->getProperties() as $reflectionProperty) { $propertyMetadata = new PropertyMetadata($class->getName(), $reflectionProperty->getName()); /** @var \Integrated\Bundle\SlugBundle\Mapping\Annotations\Slug $annotation */ $annotation = $this->reader->getPropertyAnnotation($reflectionProperty, 'Integrated\\Bundle\\SlugBundle\\Mapping\\Annotations\\Slug'); if (null !== $annotation) { $propertyMetadata->slugFields = $annotation->fields; $propertyMetadata->slugSeparator = $annotation->separator; } $classMetadata->addPropertyMetadata($propertyMetadata); } return $classMetadata; }
/** * {@inheritdoc} */ public function loadClassMetadata(ClassMetadataInterface $classMetadata, array $normalizationGroups = null, array $denormalizationGroups = null, array $validationGroups = null) { $reflectionClass = $classMetadata->getReflectionClass(); if ($iri = $this->reader->getClassAnnotation($reflectionClass, self::IRI_ANNOTATION_NAME)) { $classMetadata = $classMetadata->withIri($iri->value); } foreach ($classMetadata->getAttributesMetadata() as $attributeName => $attributeMetadata) { if ($reflectionProperty = $this->getReflectionProperty($reflectionClass, $attributeName)) { if ($iri = $this->reader->getPropertyAnnotation($reflectionProperty, self::IRI_ANNOTATION_NAME)) { $classMetadata = $classMetadata->withAttributeMetadata($attributeName, $attributeMetadata->withIri($iri->value)); } } } return $classMetadata; }
/** * Creates form configuration for $model for given $fields * * @param object $model * @param array $fields * @return array */ private function getFieldsConfiguration($model, $fields = array()) { $configuration = $properties = array(); $ro = new \ReflectionObject($model); if (empty($fields)) { $properties = $ro->getProperties(); } else { foreach (array_keys($fields) as $field) { $properties[] = $ro->getProperty($field); } } foreach ($properties as $property) { $propertyIsListed = array_key_exists($property->getName(), $fields); if (!empty($fields) && !$propertyIsListed) { continue; } $fieldConfiguration = $this->annotationReader->getPropertyAnnotation($property, 'Codete\\FormGeneratorBundle\\Annotations\\Display'); if ($fieldConfiguration === null && !$propertyIsListed) { continue; } $configuration[$property->getName()] = (array) $fieldConfiguration; if (isset($fields[$property->getName()])) { $configuration[$property->getName()] = array_replace_recursive($configuration[$property->getName()], $fields[$property->getName()]); } // this variable comes from Doctrine\Common\Annotations\Annotation unset($configuration[$property->getName()]['value']); } return $configuration; }
/** * Get a list linking an item name with the property it refers to and what kind of collection it is. * Ex: [ * "byItemName" => "user" => ["property" => "users", "behavior" => "list", "methods" => ["add", "remove"]], * "byProperty" => "users" => ["itemName" => "user", "behavior" => "list", "methods" => ["add", "remove"]] * ] * * @param array $properties The properties of the object to read. * @param \Doctrine\Common\Annotations\Reader $annotationReader The annotation reader to use. * * @return array The described list. */ public static function getCollectionsItemNames($properties, $annotationReader) { $objectCollectionsItemNames = array("byProperty" => array(), "byItemName" => array()); foreach ($properties as $propertyName => $property) { $annotation = null; $behavior = null; foreach (self::$collectionAnnotationClasses as $annotationBehavior => $annotationClass) { $annotation = $annotationReader->getPropertyAnnotation($property, $annotationClass); if ($annotation !== null) { $behavior = $annotationBehavior; break; } } if ($annotation !== null) { // get the item name, or deduce it (singularize the property name) $itemName = $annotation->getItemName(); if ($itemName === null) { $itemName = Inflector::singularize($propertyName); } $objectCollectionsItemNames["byItemName"][$itemName] = array("property" => $propertyName, "behavior" => $behavior, "methods" => $annotation->getMethods()); $objectCollectionsItemNames["byProperty"][$propertyName] = array("itemName" => $itemName, "behavior" => $behavior, "methods" => $annotation->getMethods()); } } return $objectCollectionsItemNames; }
/** * reads the entity and returns a set of annotations * * @param string $entity * @param string $type * * @return Annotation[] */ private function getPropertiesByType($entity, $type) { $properties = $this->readClassProperties($entity); $fields = array(); foreach ($properties as $property) { $annotation = $this->reader->getPropertyAnnotation($property, $type); if (null === $annotation) { continue; } $property->setAccessible(true); $annotation->value = $property->getValue($entity); $annotation->name = $property->getName(); $fields[] = $annotation; } return $fields; }
/** * @param $annotationName * @param CommandMessageInterface $command * @param \ReflectionClass $reflectionClass * @return mixed|null */ private function getAnnotatedTargetValue($annotationName, CommandMessageInterface $command, \ReflectionClass $reflectionClass) { foreach (ReflectionUtils::getProperties($reflectionClass) as $property) { if (null !== ($annotation = $this->reader->getPropertyAnnotation($property, $annotationName))) { $property->setAccessible(true); return $property->getValue($command->getPayload()); } } foreach (ReflectionUtils::getMethods($reflectionClass) as $method) { if (null !== ($annotation = $this->reader->getMethodAnnotation($method, $annotationName))) { $method->setAccessible(true); return $method->invoke($command->getPayload()); } } return null; }
public static function fromAnnotation($model, Reader $reader) { $settings = ['model' => $model]; $classRefl = new ReflectionClass($model); $propertiesRefl = $classRefl->getProperties(); class_exists(Table::class); class_exists(Column::class); /* @var \Wandu\Database\Annotations\Table $table */ if ($table = $reader->getClassAnnotation($classRefl, Table::class)) { $settings['identifier'] = $table->identifier; $settings['increments'] = $table->increments; } $columns = []; $casts = []; foreach ($propertiesRefl as $propertyRefl) { /* @var \Wandu\Database\Annotations\Column $column */ if ($column = $reader->getPropertyAnnotation($propertyRefl, Column::class)) { $columns[$column->name] = $propertyRefl->name; $casts[$column->name] = $column->cast; } } if (count($columns)) { $settings['columns'] = $columns; } if (count($casts)) { $settings['casts'] = $casts; } return new RepositorySettings($table->name, $settings); }
protected function isPropertyExcluded(\ReflectionProperty $property, ClassMetadata $classMetadata) { if ($classMetadata->exclusionPolicy === Annotation\ExclusionPolicy::ALL) { return null === $this->reader->getPropertyAnnotation($property, Annotation\Expose::class); } return null !== $this->reader->getPropertyAnnotation($property, Annotation\Exclude::class); }
/** * Process (encrypt/decrypt) entities fields * @param Obj $entity Some doctrine entity * @param Boolean $isEncryptOperation If true - encrypt, false - decrypt entity */ private function processFields($entity, $isEncryptOperation = true) { $encryptorMethod = $isEncryptOperation ? 'encrypt' : 'decrypt'; $reflectionClass = new ReflectionClass($entity); $properties = $reflectionClass->getProperties(); $withAnnotation = false; foreach ($properties as $refProperty) { if ($this->annReader->getPropertyAnnotation($refProperty, self::ENCRYPTED_ANN_NAME)) { $withAnnotation = true; // we have annotation and if it decrypt operation, we must avoid duble decryption $propName = $refProperty->getName(); if ($refProperty->isPublic()) { $entity->{$propName} = $this->encryptor->{$encryptorMethod}($refProperty->getValue()); } else { $methodName = self::capitalize($propName); if ($reflectionClass->hasMethod($getter = 'get' . $methodName) && $reflectionClass->hasMethod($setter = 'set' . $methodName)) { $currentPropValue = $this->encryptor->{$encryptorMethod}($entity->{$getter}()); $entity->{$setter}($currentPropValue); } else { throw new \RuntimeException(sprintf("Property %s isn't public and doesn't has getter/setter")); } } } } return $withAnnotation; }
/** * {@inheritdoc} */ public function guessType($class, $property) { if (!($ret = $this->getMetadata($class))) { return null; } /** @var ClassMetadataInfo $metadata */ list($metadata, ) = $ret; if ($metadata->isAssociationWithSingleJoinColumn($property)) { $reflectionProperty = new \ReflectionProperty($class, $property); /** @var \Rafrsr\ResourceBundle\Annotations\ResourceAnnotationInterface $config */ $interface = 'Rafrsr\\ResourceBundle\\Annotations\\ResourceAnnotationInterface'; if ($config = $this->reader->getPropertyAnnotation($reflectionProperty, $interface)) { return new TypeGuess($config->getFormType(), [], Guess::VERY_HIGH_CONFIDENCE); } } return null; }
protected function doRead($entity, $property) { $reflectionClass = new \ReflectionClass($entity); $config = ['add' => NULL, 'remove' => NULL, 'set' => NULL, 'get' => NULL]; if (!$reflectionClass->hasProperty($property)) { return $config; } $class = '\\Librette\\Doctrine\\Annotations\\ManipulateMethods'; $reflectionProperty = $reflectionClass->getProperty($property); $annotation = $this->annotationReader->getPropertyAnnotation($reflectionProperty, $class); if ($annotation && $annotation instanceof ManipulateMethods) { $config['add'] = $annotation->add; $config['remove'] = $annotation->remove; $config['set'] = $annotation->set; $config['get'] = $annotation->get; } return $config; }
/** * Intercepts access to autowired properties and injects specified dependency * * @Around("@access(Warlock\Annotation\Autowired)") * * @param FieldAccess $joinpoint Autowiring joinpoint * * @return mixed */ public function beforeAccessingAutowiredProperty(FieldAccess $joinpoint) { $obj = $joinpoint->getThis(); $field = $joinpoint->getField(); if ($joinpoint->getAccessType() == FieldAccess::READ) { /** @var Autowired $autowired */ $autowired = $this->reader->getPropertyAnnotation($field, self::ANNOTATION_NAME); $strategy = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE; if (!$autowired->required) { $strategy = ContainerInterface::NULL_ON_INVALID_REFERENCE; } $value = $this->container->get($autowired, $strategy); } else { $value = $joinpoint->proceed(); } $field->setValue($obj, $value); return $value; }
private function parseProperties(\ReflectionClass $class, ClassMetadata $classMetadata) { foreach ($class->getProperties() as $reflProperty) { $propMeta = new PropertyMetadata($class->getName(), $reflProperty->getName()); // is property exposed? /** @var Property\Expose $annotation */ $annotation = $this->reader->getPropertyAnnotation($reflProperty, Property\Expose::class); if ($annotation) { $propMeta->setExposed(true); if ($annotation->name) { $propMeta->setExposedName($annotation->name); } if ($annotation->accessRoles) { $propMeta->setAccessRoles($annotation->accessRoles); } // set property renderer /** @var Property\Renderer $annotation */ $annotation = $this->reader->getPropertyAnnotation($reflProperty, Property\Renderer::class); if ($annotation) { if ($annotation->renderService) { $propMeta->setRenderService($annotation->renderService); if ($annotation->renderMethod) { $propMeta->setRenderMethod($annotation->renderMethod); } } } // property getter? /** @var Property\GetterMethod $annotation */ $annotation = $this->reader->getPropertyAnnotation($reflProperty, Property\GetterMethod::class); if ($annotation) { if ($annotation->method) { $propMeta->setGetterMethod($annotation->method); } else { // standard getter $propMeta->setGetterMethod('get' . ucfirst($propMeta->getName())); } } elseif (!$reflProperty->isPublic()) { // assuming standard getter $propMeta->setGetterMethod('get' . ucfirst($propMeta->getName())); } } $classMetadata->addPropertyMetadata($propMeta); } }
/** * Get the list of properties that have to be initialized automatically * during the object construction, plus their value. * * @param array $properties The properties of the object to read. * @param \Doctrine\Common\Annotations\Reader $annotationReader The annotation reader to use. * * @return array The list of properties and values, * in the form ["property" => "value"]. */ public static function getPropertiesToInitialize($properties, $annotationReader) { $propertiesValues = array(); foreach ($properties as $propertyName => $property) { $initializeAnnotation = $annotationReader->getPropertyAnnotation($property, self::$initializeAnnotationClass); $initializeObjectAnnotation = $annotationReader->getPropertyAnnotation($property, self::$initializeObjectAnnotationClass); if ($initializeAnnotation !== null && $initializeObjectAnnotation !== null) { throw new \LogicException("Two initial values are given for property {$propertyName}."); } if ($initializeAnnotation !== null) { $propertiesValues[$propertyName] = array('type' => 'initialize', 'value' => $initializeAnnotation->getValue()); } else { if ($initializeObjectAnnotation !== null) { $propertiesValues[$propertyName] = array('type' => 'initializeObject', 'value' => $initializeObjectAnnotation->getClassName()); } } } return $propertiesValues; }
/** * Get value * * @param mixed $obj * @param string $className * @return string */ private function findValue($obj, $className) { $reflClass = new \ReflectionClass($obj); // Make sure we are not using a Proxy class if ($obj instanceof Proxy) { $reflClass = $reflClass->getParentClass(); } // Find on property foreach ($reflClass->getProperties(\ReflectionProperty::IS_PUBLIC) as $property) { if ($this->reader->getPropertyAnnotation($property, $className)) { return $obj->{$property}; } } // Find on method foreach ($reflClass->getMethods() as $method) { if ($this->reader->getMethodAnnotation($method, $className)) { return $obj->{$method->getName()}(); } } }
/** * {@inheritdoc} */ public function parse(Request $request) { $resource = $request->getResource(); $classMetadata = $this->classMetadataFactory->getMetadataFor($resource->getEntityClass(), $resource->getNormalizationGroups(), $resource->getDenormalizationGroups(), $resource->getValidationGroups()); $request->addHeader('Content-Type', 'application/json'); $request->setDataMode(Request::DATA_MODE_RAW); $rawModeData = []; foreach ($classMetadata->getAttributes() as $attributeMetadata) { if (!$classMetadata->getReflectionClass()->hasProperty($attributeMetadata->getName())) { // Attribute is not a property: ignore it continue; } $groups = $this->reader->getPropertyAnnotation($classMetadata->getReflectionClass()->getProperty($attributeMetadata->getName()), 'Symfony\\Component\\Serializer\\Annotation\\Groups'); if ($attributeMetadata->isIdentifier() || !$attributeMetadata->isReadable() || !count(array_intersect($groups ? $groups->getGroups() : [], $resource->getDenormalizationGroups() ?: []))) { continue; } $rawModeData[$attributeMetadata->getName()] = $this->guesser->guess($attributeMetadata); } $request->setRawModeData($rawModeData); }
/** * {@inheritdoc} */ public function isTransient($className) { $r = new ReflectionClass($className); foreach ($r->getProperties() as $reflectionProperty) { $annotation = $this->reader->getPropertyAnnotation($reflectionProperty, 'Rollerworks\\Component\\Search\\Metadata\\Field'); if (null !== $annotation) { return true; } } return false; }
/** * {@inheritDoc} */ public function loadMetadata($class) { // Try get @Object annotation $objectAnnotation = null; $classAnnotations = Reflection::loadClassAnnotations($this->reader, $class); foreach ($classAnnotations as $classAnnotation) { if ($classAnnotation instanceof ObjectAnnotation) { if ($objectAnnotation) { throw new \RuntimeException(sprintf('Many @Normalize\\Object annotations in class "%s".', $class)); } $objectAnnotation = $classAnnotation; } } // Try get @Property annotation from properties $properties = []; $classProperties = Reflection::getClassProperties($class, true); if ($objectAnnotation && $objectAnnotation->allProperties) { foreach ($classProperties as $classProperty) { /** @var PropertyAnnotation $propertyAnnotation */ $propertyAnnotation = $this->reader->getPropertyAnnotation($classProperty, 'FivePercent\\Component\\ModelNormalizer\\Annotation\\Property'); if ($propertyAnnotation) { $properties[$classProperty->getName()] = new PropertyMetadata($propertyAnnotation->fieldName ?: $classProperty->getName(), $propertyAnnotation->groups, $propertyAnnotation->shouldNormalize, $propertyAnnotation->expressionValue, $propertyAnnotation->denormalizerClass); } else { $properties[$classProperty->getName()] = new PropertyMetadata($classProperty->getName(), [], false, null); } } } else { foreach ($classProperties as $classProperty) { $propertyAnnotations = $this->reader->getPropertyAnnotations($classProperty); foreach ($propertyAnnotations as $propertyAnnotation) { if ($propertyAnnotation instanceof PropertyAnnotation) { $properties[$classProperty->getName()] = new PropertyMetadata($propertyAnnotation->fieldName ?: $classProperty->getName(), $propertyAnnotation->groups, $propertyAnnotation->shouldNormalize, $propertyAnnotation->expressionValue, $propertyAnnotation->denormalizerClass); } } } } if (!count($properties) && !$objectAnnotation) { throw new NormalizeAnnotationNotFoundException(sprintf('Not found normalize annotations in class "%s".', $class)); } return new ObjectMetadata($properties); }
/** * Returns the setter name for the inverse side. * * @param $inverseSideEntity * @param $owningSideEntity * * @return bool|string */ protected function getReferenceSetter($inverseSideEntity, $owningSideEntity) { $inverseSideReflection = new \ReflectionClass($inverseSideEntity); $owningSideReflection = new \ReflectionClass($owningSideEntity); foreach ($inverseSideReflection->getProperties() as $inverseSideProperty) { $oneToManyAssociation = $this->reader->getPropertyAnnotation($inverseSideProperty, 'Doctrine\\ORM\\Mapping\\ManyToOne'); if ($oneToManyAssociation !== null && $oneToManyAssociation->targetEntity == $owningSideReflection->getName()) { return $inverseSideProperty->getName(); } } return false; }
/** * Get fields annotations * * @param string $annotationName * @return array */ protected function readPropertyAnnotations($annotationName) { $reflection = $this->getClassReflection(); $annotations = []; foreach ($reflection->getProperties() as $property) { $annotation = $this->reader->getPropertyAnnotation($property, $annotationName); if ($annotation !== null) { $annotations[$property->getName()] = $annotation; } } return $annotations; }