/** * @param ReflectionProperty $property * @return PropertyMetadata */ private function loadPropertyMetadata(ReflectionProperty $property) { $propertyMetadata = new PropertyMetadata($property->getDeclaringClass()->getName(), $property->getName()); foreach ($this->reader->getPropertyAnnotations($property) as $propertyAnnotation) { if ($propertyAnnotation instanceof Type) { $propertyMetadata->type = $propertyAnnotation->name; } if ($propertyAnnotation instanceof ReferenceOne) { $propertyMetadata->reference = PropertyMetadata::REFERENCE_ONE; $propertyMetadata->target = $propertyAnnotation->target; } if ($propertyAnnotation instanceof ReferenceMany) { $propertyMetadata->reference = PropertyMetadata::REFERENCE_MANY; $propertyMetadata->target = $propertyAnnotation->target; } if ($propertyAnnotation instanceof ReferenceKey) { $propertyMetadata->reference = PropertyMetadata::REFERENCE_KEY; $propertyMetadata->target = $propertyAnnotation->target; if ($propertyAnnotation->value instanceof Type) { $propertyMetadata->value = ['type' => 'type', 'name' => $propertyAnnotation->value->name]; } } if ($propertyAnnotation instanceof EmbedOne) { $propertyMetadata->embed = PropertyMetadata::EMBED_ONE; $propertyMetadata->target = $propertyAnnotation->target; $propertyMetadata->mapping = $propertyAnnotation->mapping; } if ($propertyAnnotation instanceof EmbedMany) { $propertyMetadata->embed = PropertyMetadata::EMBED_MANY; $propertyMetadata->target = $propertyAnnotation->target; $propertyMetadata->mapping = $propertyAnnotation->mapping; } } return $propertyMetadata; }
/** * @param string $classname * @return array */ public function getFieldsMetadata($classname) { foreach ($this->getReflectionClass($classname)->getProperties() as $property) { $properties = array_reduce($this->reader->getPropertyAnnotations($property), function ($reduced, $current) use($property, $classname) { if ($current instanceof AbstractField) { $current->name = $property->getName(); if (is_object($classname)) { $property->setAccessible(true); $current->value = $property->getValue($classname); } $key = get_class($current); if (isset($reduced[$key])) { if (!is_array($reduced[$key])) { $reduced[$key] = [$reduced[$key]]; } $reduced[$key][] = $current; } else { $reduced[$key] = $current; } return $reduced; } }); if (!is_null($properties)) { $fields[$property->getName()] = $properties; } } return $fields; }
public function loadMetadataForClass($className) { $metadata = new ClassMetadata($className); $reflectionClass = new \ReflectionClass($className); $reflectionProperties = $reflectionClass->getProperties(); foreach ($reflectionProperties as $reflectionProperty) { $name = $reflectionProperty->getName(); $pMetadata = new PropertyMetadata($name); $annotations = $this->reader->getPropertyAnnotations($reflectionProperty); foreach ($annotations as $annotation) { if ($annotation instanceof Annotations\Expose) { $pMetadata->setExpose((bool) $annotation->value); } elseif ($annotation instanceof Annotations\Type) { $pMetadata->setType((string) $annotation->value); } elseif ($annotation instanceof Annotations\Groups) { $pMetadata->setGroups($annotation->value); } elseif ($annotation instanceof Annotations\SerializedName) { $pMetadata->setSerializedName((string) $annotation->value); } elseif ($annotation instanceof Annotations\SinceVersion) { $pMetadata->setSinceVersion((string) $annotation->value); } elseif ($annotation instanceof Annotations\UntilVersion) { $pMetadata->setUntilVersion((string) $annotation->value); } } $metadata->addPropertyMetadata($pMetadata); } return $metadata; }
public function getPropertyAnnotationClassNames($className, $propertyName = NULL) { $reflectionProperty = new \ReflectionProperty($className, $propertyName); $annotations = $this->annotationReader->getPropertyAnnotations($reflectionProperty); $classNames = array(); foreach ($annotations as $annotation) { $classNames[] = get_class($annotation); } return array_unique($classNames); }
/** * @param array $properties * @param object $class * @return array */ public function getPropertyAnnotations(array $properties, $class) { $contraints = array(); // Foreach the sync and retrieve the anotation foreach ($properties as $property) { $propertyReflection = new \ReflectionProperty($class, $property); $annotation = $this->annotationReader->getPropertyAnnotations($propertyReflection); if (empty($annotation) === false) { $contraints[$property] = $annotation; } } return $contraints; }
/** * {@inheritdoc} */ public function parse(TransportableInterface $transport) { $resource = new ResourceMapping(); // Gain a reflection instance of the given class and retrieve all the properties marked as protected. $class = new ReflectionObject($transport); $properties = $class->getProperties(ReflectionProperty::IS_PROTECTED); foreach ($properties as $property) { $annotations = new ArrayCollection($this->reader->getPropertyAnnotations($property)); $this->processFieldAnnotationsForResourceMapping($resource, $property, $annotations); } $this->validateResourceMapping($resource); return $resource; }
/** * {@inheritdoc} */ public function fillEntity(Utils\ArrayHash $values, Entities\IEntity $entity, $isNew = FALSE) { $classMetadata = $this->managerRegistry->getManagerForClass(get_class($entity))->getClassMetadata(get_class($entity)); foreach (array_merge($classMetadata->getFieldNames(), $classMetadata->getAssociationNames()) as $fieldName) { $propertyReflection = new Nette\Reflection\Property(get_class($entity), $fieldName); /** @var Doctrine\Mapping\Annotation\Crud $crud */ if ($crud = $this->annotationReader->getPropertyAnnotation($propertyReflection, self::EXTENSION_ANNOTATION)) { if ($isNew && $crud->isRequired() && !$values->offsetExists($fieldName)) { throw new Exceptions\InvalidStateException('Missing required key "' . $fieldName . '"'); } if (!$values->offsetExists($fieldName) || !$isNew && !$crud->isWritable() || $isNew && !$crud->isRequired()) { continue; } $value = $values->offsetGet($fieldName); if ($value instanceof Utils\ArrayHash || is_array($value)) { if (!$classMetadata->getFieldValue($entity, $fieldName) instanceof Entities\IEntity) { $propertyAnnotations = $this->annotationReader->getPropertyAnnotations($propertyReflection); $annotations = array_map(function ($annotation) { return get_class($annotation); }, $propertyAnnotations); if (in_array('Doctrine\\ORM\\Mapping\\OneToOne', $annotations, TRUE)) { $className = $this->annotationReader->getPropertyAnnotation($propertyReflection, 'Doctrine\\ORM\\Mapping\\OneToOne')->targetEntity; } elseif (in_array('Doctrine\\ORM\\Mapping\\ManyToOne', $annotations, TRUE)) { $className = $this->annotationReader->getPropertyAnnotation($propertyReflection, 'Doctrine\\ORM\\Mapping\\ManyToOne')->targetEntity; } else { $className = $propertyReflection->getAnnotation('var'); } // Check if class is callable if (class_exists($className)) { $classMetadata->setFieldValue($entity, $fieldName, new $className()); } else { $classMetadata->setFieldValue($entity, $fieldName, $value); } } // Check again if entity was created if (($fieldValue = $classMetadata->getFieldValue($entity, $fieldName)) && $fieldValue instanceof Entities\IEntity) { $classMetadata->setFieldValue($entity, $fieldName, $this->fillEntity(Utils\ArrayHash::from((array) $value), $fieldValue, $isNew)); } } else { if ($crud->validator !== NULL) { $value = $this->validateProperty($crud->validator, $value); } $classMetadata->setFieldValue($entity, $fieldName, $value); } } } return $entity; }
public function getContentFiles($object) { $reflectedClass = new \ReflectionClass($object); $reader = new AnnotationReader(); $annotations = $reader->getClassAnnotations($reflectedClass); $isContentFiledClass = false; foreach ($annotations as $annotation) { if ($annotation instanceof ContentFiled) { $isContentFiledClass = true; } } if (!$isContentFiledClass) { throw new \InvalidArgumentException('Only @ContentFiled annotated classes are supported!'); } $contentFiles = []; foreach ($reflectedClass->getProperties() as $property) { foreach ($reader->getPropertyAnnotations($property) as $annotation) { if ($annotation instanceof ContentFileAnnotation) { $mappingType = $object->{$annotation->mappingTypeMethod}(); $contentFiles = array_merge($contentFiles, $this->contentFileManager->findFilesByMappingType($mappingType)); } } } return $contentFiles; }
/** * @param string $className * @return Datagrid */ public function create($className) { /** @var \Doctrine\ORM\EntityManager $entityManager */ $entityManager = $this->getServiceLocator()->get('Doctrine\\ORM\\EntityManager'); $metadata = $entityManager->getClassMetadata($className); $reflection = $metadata->getReflectionClass(); $datagridSpec = new ArrayObject(array('className' => $className, 'primaryKey' => $metadata->getSingleIdentifierFieldName(), 'name' => array('singular' => '', 'plural' => ''), 'defaultSort' => null, 'headerColumns' => array(), 'searchColumns' => array(), 'suggestColumns' => array())); $reader = new AnnotationReader(); foreach ($reader->getClassAnnotations($reflection) as $annotation) { $params = compact('datagridSpec', 'annotation'); $this->getEventManager()->trigger('discoverTitle', $this, $params); } foreach ($reflection->getProperties() as $property) { foreach ($reader->getPropertyAnnotations($property) as $annotation) { $params = compact('datagridSpec', 'annotation', 'property'); $this->getEventManager()->trigger('configureColumn', $this, $params); } } foreach ($reflection->getMethods() as $method) { foreach ($reader->getMethodAnnotations($method) as $annotation) { $params = compact('datagridSpec', 'annotation', 'method'); $this->getEventManager()->trigger('configureColumn', $this, $params); } } $this->datagrids[$className] = new Datagrid($entityManager, $datagridSpec->getArrayCopy()); return $this->datagrids[$className]; }
/** * Load all of the @XmlValue annotations * * @param ClassMetadata $metadata */ protected function loadClassValue(ClassMetadata $metadata) { $reflClass = $metadata->getReflectionClass(); foreach ($reflClass->getProperties() as $property) { foreach ($this->reader->getPropertyAnnotations($property) as $annotation) { if ($annotation instanceof XmlValue) { $metadata->setValue($property->getName()); } } } }
public function testAnnotations() { $reader = new AnnotationReader(new \Doctrine\Common\Cache\ArrayCache()); $reader->setDefaultAnnotationNamespace('Doctrine\\Tests\\Common\\Annotations\\'); $class = new \ReflectionClass('Doctrine\\Tests\\Common\\Annotations\\DummyClass'); $classAnnots = $reader->getClassAnnotations($class); $annotName = 'Doctrine\\Tests\\Common\\Annotations\\DummyAnnotation'; $this->assertEquals(1, count($classAnnots)); $this->assertTrue($classAnnots[$annotName] instanceof DummyAnnotation); $this->assertEquals("hello", $classAnnots[$annotName]->dummyValue); $field1Prop = $class->getProperty('field1'); $propAnnots = $reader->getPropertyAnnotations($field1Prop); $this->assertEquals(1, count($propAnnots)); $this->assertTrue($propAnnots[$annotName] instanceof DummyAnnotation); $this->assertEquals("fieldHello", $propAnnots[$annotName]->dummyValue); $getField1Method = $class->getMethod('getField1'); $methodAnnots = $reader->getMethodAnnotations($getField1Method); $this->assertEquals(1, count($methodAnnots)); $this->assertTrue($methodAnnots[$annotName] instanceof DummyAnnotation); $this->assertEquals(array(1, 2, "three"), $methodAnnots[$annotName]->value); $field2Prop = $class->getProperty('field2'); $propAnnots = $reader->getPropertyAnnotations($field2Prop); $this->assertEquals(1, count($propAnnots)); $this->assertTrue(isset($propAnnots['Doctrine\\Tests\\Common\\Annotations\\DummyJoinTable'])); $joinTableAnnot = $propAnnots['Doctrine\\Tests\\Common\\Annotations\\DummyJoinTable']; $this->assertEquals(1, count($joinTableAnnot->joinColumns)); $this->assertEquals(1, count($joinTableAnnot->inverseJoinColumns)); $this->assertTrue($joinTableAnnot->joinColumns[0] instanceof DummyJoinColumn); $this->assertTrue($joinTableAnnot->inverseJoinColumns[0] instanceof DummyJoinColumn); $this->assertEquals('col1', $joinTableAnnot->joinColumns[0]->name); $this->assertEquals('col2', $joinTableAnnot->joinColumns[0]->referencedColumnName); $this->assertEquals('col3', $joinTableAnnot->inverseJoinColumns[0]->name); $this->assertEquals('col4', $joinTableAnnot->inverseJoinColumns[0]->referencedColumnName); $dummyAnnot = $reader->getMethodAnnotation($class->getMethod('getField1'), 'Doctrine\\Tests\\Common\\Annotations\\DummyAnnotation'); $this->assertEquals('', $dummyAnnot->dummyValue); $this->assertEquals(array(1, 2, 'three'), $dummyAnnot->value); $dummyAnnot = $reader->getPropertyAnnotation($class->getProperty('field1'), 'Doctrine\\Tests\\Common\\Annotations\\DummyAnnotation'); $this->assertEquals('fieldHello', $dummyAnnot->dummyValue); $classAnnot = $reader->getClassAnnotation($class, 'Doctrine\\Tests\\Common\\Annotations\\DummyAnnotation'); $this->assertEquals('hello', $classAnnot->dummyValue); }
public static function fromReflection(ReflectionProperty $reflection = NULL) { if (!defined('PHP_VERSION_ID')) { $v = explode('.', PHP_VERSION); define('PHP_VERSION_ID', $v[0] * 10000 + $v[1] * 100 + $v[2]); } if ($reflection === null) { return null; } if (func_num_args() > 1) { $stack = func_get_arg(1); } else { $stack = new \ArrayObject(); } $stackExpression = $reflection->getDeclaringClass()->getName() . '::' . $reflection->getName(); if (isset($stack[$stackExpression])) { return $stack[$stackExpression]; } $stack[$stackExpression] = $instance = new Property($reflection); if (func_num_args() > 2) { $reader = func_get_arg(2); } else { $reader = new AnnotationReader(); } if (func_num_args() > 3) { $phpParser = func_get_arg(3); } else { $phpParser = new PhpParser(); } $instance->name = $reflection->getName(); $instance->public = $reflection->isPublic(); $instance->private = $reflection->isPrivate(); $instance->protected = $reflection->isProtected(); $instance->static = $reflection->isStatic(); $instance->default = $reflection->isDefault(); $instance->modifiers = $reflection->getModifiers(); $instance->docComment = $reflection->getDocComment(); $instance->annotations = $reader->getPropertyAnnotations($reflection); $instance->declaringClass = Type::fromReflection($reflection->getDeclaringClass() ? $reflection->getDeclaringClass() : null, $stack, $reader, $phpParser); $defaultProperties = $reflection->getDeclaringClass()->getDefaultProperties(); if (isset($defaultProperties[$instance->name])) { $instance->defaultValue = $defaultProperties[$instance->name]; } if (preg_match('/@var\\s+([a-zA-Z0-9\\\\\\[\\]_]+)/', $instance->docComment, $m)) { $typeString = $m[1]; } if (isset($typeString)) { $instance->type = MixedType::fromString($typeString, $stack, $reader, $phpParser, $instance->declaringClass); } else { $instance->type = MixedType::getInstance(); } return $instance; }
/** * Get BuilderDefinition from entity property * * @param string $propertyName * @param bool $fillValues * @return BuilderDefinition|null * @throws InvalidStateException */ private function getPropertyRule($propertyName, $fillValues = TRUE) { $property = $this->entityReflection->getProperty($propertyName); $annotations = $this->annotationReader->getPropertyAnnotations($property); $rule = new BuilderDefinition($propertyName); foreach ($annotations as $annotation) { switch (get_class($annotation)) { case 'Doctrine\\ORM\\Mapping\\Column': if ($this->getEntityPrimaryKeyName($this->entity) === $propertyName) { $rule->setComponentType(BuilderDefinition::COMPONENT_TYPE_HIDDEN); $rule->setRequired(FALSE); } else { $type = BuilderDefinition::COMPONENT_TYPE_TEXT; $rule->setRequired(!$annotation->nullable); /** @var Column $annotation */ if ($annotation->type === 'boolean') { $type = BuilderDefinition::COMPONENT_TYPE_CHECKBOX; } // is numeric? if ($annotation->type === 'integer' || $annotation->type === 'float' || $annotation->type === 'bigint' || $annotation->type === 'decimal' || $annotation->type === 'smallint') { $rule->addValidationRule(Form::NUMERIC, 'This is required in numeric format', TRUE); } $rule->setComponentType($type); } break; case 'Doctrine\\ORM\\Mapping\\ManyToOne': /** @var ManyToOne $annotation */ $rule->setComponentType(BuilderDefinition::COMPONENT_TYPE_SELECT); if ($fillValues) { $rule->setValues($this->getPossibleValues($annotation->targetEntity)); } $rule->setTargetEntity($annotation->targetEntity); $rule->setRequired(TRUE); break; case 'Doctrine\\ORM\\Mapping\\ManyToMany': /** @var OneToMany $annotation */ $rule->setComponentType(BuilderDefinition::COMPONENT_TYPE_MULTI_SELECT); if ($fillValues) { $rule->setValues($this->getPossibleValues($annotation->targetEntity)); } $rule->setRequired(TRUE); $rule->setTargetEntity($annotation->targetEntity); break; case 'Doctrine\\ORM\\Mapping\\JoinColumn': /** @var JoinColumn $annotation */ $rule->setRequired(!$annotation->nullable); break; } } return $rule->getComponentType() === NULL ? NULL : $rule; }
/** * Get all annotation and add validators */ protected function getAnnotationValidator() { $reader = new AnnotationReader(); $classReflection = new \ReflectionClass($this->object); $propertiesReflection = $classReflection->getProperties(); foreach ($propertiesReflection as $property) { $annotations = $reader->getPropertyAnnotations($property); $propertyName = $property->getName(); foreach ($annotations as $annotation) { if ($annotation instanceof ValidatorInterface) { $this->addValidator($propertyName, $annotation); } } } }
public static function getJsonSchema() { $reader = new AnnotationReader(); $schema = array(); $reflection = new \ReflectionClass(static::class); foreach ($reflection->getProperties() as $property) { $annotations = $reader->getPropertyAnnotations($property); foreach ($annotations as $annotation) { if ($annotation instanceof Property) { var_dump($annotation); } else { var_dump($annotation); } } } }
/** * Validate value with annotation. * * @param object $value * * @throws ValidationException */ public function validateWithAnnotation($value) { if (!is_object($value)) { throw new ValidationException('To validate with annotation, value should be object but got "%s".', gettype($value)); } $reader = new AnnotationReader(); $values = $this->getValues($value); foreach ($this->getProperties($value) as $prop) { foreach ($reader->getPropertyAnnotations($prop) as $annotation) { if ($annotation instanceof AbstractConstraint) { $name = $prop->getName(); $val = isset($values[$name]) ? $values[$name] : null; $this->validate($val, $annotation, array('attribute' => trim(implode(' ', preg_split('/(?=[A-Z])/', $name))))); } } } }
protected function processObjectProperties(AnnotationReader $reader, $object, array $properties) { $values = array(); foreach ($properties as $property) { // Get the annotation for this property. $annotations = $reader->getPropertyAnnotations($property); if (empty($annotations)) { continue; } foreach ($annotations as $annotation) { // Check if the annotation is parseble, if not, get the next one. if (!$annotation instanceof Annotation\AnnotationInterface) { continue; } // If the annotation has a 'name' attribute then use that, otherwise // use the property name (class member) as the value key. $name = $annotation->name; if (empty($name)) { $name = $property->name; } // Get the value of the property. $value = $annotation->getPropertyValue($property, $object); if ($annotation instanceof Annotation\Object) { // If $value is an object then recurse into it. $values[$name] = $this->toArray($value); } else { if ($annotation instanceof Annotation\Collection) { // $value is a collection, iterate through it. foreach ($value as $item) { if (is_object($item)) { // If the item is an object then we want to recurse into it. $values[$name][] = $this->toArray($item); } else { // Other wise just add the $item value. $values[$name][] = $item; } } } else { // $value is just a simple value. $values[$name] = $value; } } } } return $values; }
/** * @param FormEvent $event * * @return ResourceAnnotationInterface|null */ private function getPropertyConfig(FormEvent $event) { if (null === ($class = $event->getForm()->getParent()->getConfig()->getDataClass())) { return null; } $property = $event->getForm()->getName(); if (!property_exists($class, $property)) { return null; } $reflectionProperty = new \ReflectionProperty($class, $property); $propertyAnnotations = $this->reader->getPropertyAnnotations($reflectionProperty); foreach ($propertyAnnotations as $propertyAnnotation) { if ($propertyAnnotation instanceof ResourceAnnotationInterface) { return $propertyAnnotation; } } return null; }
/** * Processes Maam annotations in class files and writes new classes with the generated * getters and setters. * * @param string $filePath Path to the file to generate * @return array|null Array consisting of the class and path if generated, or null if not because there were no * Maam annotations. */ protected function generateClass($filePath) { $newMethods = []; $reflectionClass = $this->getReflectionClass($filePath); $annotationReader = new AnnotationReader(); /** @var \ReflectionProperty $property */ foreach ($reflectionClass->getProperties() as $property) { $annotations = $annotationReader->getPropertyAnnotations($property); if (count($annotations) === 0) { return null; } $newMethods = array_merge($newMethods, $this->generateMethods($annotations, $property->getName())); } if (count($newMethods) === 0) { return null; } return ['class' => $reflectionClass->getName(), 'path' => $this->writeNewCode($filePath, $newMethods)]; }
/** * Expects to receive an array from which it will extract * the values it recognizes to stored them in this class. * * @param array */ public function exchangeArray(array $data = array()) { $annotationReader = new AnnotationReader(); foreach ($data as $key => $value) { if (property_exists(get_class($this), $key)) { $reflectionProperty = new \ReflectionProperty(get_class($this), $key); $propertyAnnotations = $annotationReader->getPropertyAnnotations($reflectionProperty); if (property_exists(get_class($propertyAnnotations[0]), 'targetEntity')) { $namespace = $this->_getNameSpace(); $newClass = $namespace . $propertyAnnotations[0]->targetEntity; $this->{$key} = new $newClass(); $this->{$key}->exchangeArray($value); } else { if ($key === 'fecha' && is_string($value)) { $this->{$key} = new \DateTime($value); } else { $this->{$key} = $value; } } } } }
/** * @param Repository[] $repositories * * @return Repository[] */ public function compare(array $repositories, $options = []) { if (count($repositories) < 2) { throw new \InvalidArgumentException('At least two Repositories must be specified!'); } $reflectedClass = new \ReflectionClass(Repository::class); $reader = new AnnotationReader(); $propertyAccessor = PropertyAccess::createPropertyAccessor(); $totalWeight = 0.0; foreach ($repositories as $repository) { /* @var Repository $repository */ foreach ($reflectedClass->getProperties() as $property) { foreach ($reader->getPropertyAnnotations($property) as $annotation) { if ($annotation instanceof Weight) { $optionName = strtolower(preg_replace('/([^A-Z])([A-Z])/', '$1_$2', $property->name)); $factor = isset($options[$optionName]) ? floatval($options[$optionName]) : $annotation->value; $repository->addWeight($propertyAccessor->getValue($repository, $property->name) * $factor); } } } $totalWeight += $repository->getWeight(); } // Sort in ascending order according to repository's weight usort($repositories, function (Repository $a, Repository $b) { return $b->getWeight() - $a->getWeight(); }); // Calculate rating $left = 100; foreach ($repositories as $repository) { /* @var Repository $repository */ $rating = floor(100 * $repository->getWeight() / $totalWeight); $repository->setRating($rating); $left -= $rating; } // The leader is rated better than others $repositories[0]->addRating($left); return $repositories; }
public static function processClass($class) { if ($class instanceof \ReflectionClass) { $reflection = $class; } else { $reflection = new \ReflectionClass($class); } $format = array(); $reader = new AnnotationReader(); foreach ($reflection->getProperties() as $property) { $annotations = $reader->getPropertyAnnotations($property); foreach ($annotations as $annotation) { if ($annotation instanceof PropertyFormatter) { $format[$property->getName()] = $annotation; break; } } } if (empty($format)) { static::$reflectionCache[$reflection->getName()] = new DefaultClassFormatter($reflection); } else { static::$reflectionCache[$reflection->getName()] = new ClassFormatterImp($reflection, $format); } }
/** * Parse an embedded class. * * @param string $name * @param \ProAI\Datamapper\Annotations\Annotation $annotation * @param \ProAI\Datamapper\Metadata\Definitions\Entity $entityMetadata * @return \ProAI\Datamapper\Metadata\Definitions\EmbeddedClass */ protected function parseEmbeddedClass($name, Annotation $annotation, EntityDefinition &$entityMetadata, $primaryKeyOnly = false) { // check if related class is valid $annotation->class = $this->getRealEntity($annotation->class, $entityMetadata['class']); $reflectionClass = new ReflectionClass($annotation->class); $classAnnotations = $this->reader->getClassAnnotations($reflectionClass); // check if class is embedded class $this->validator->validateEmbeddedClass($annotation->class, $classAnnotations); $embeddedColumnPrefix = $annotation->columnPrefix || $annotation->columnPrefix === false ? $annotation->columnPrefix : $name; $embeddedClassMetadata = new EmbeddedClassDefinition(['name' => $name, 'class' => $annotation->class, 'columnPrefix' => $embeddedColumnPrefix, 'attributes' => []]); // scan property annotations foreach ($reflectionClass->getProperties() as $reflectionProperty) { $name = $this->getSanitizedName($reflectionProperty->getName(), $entityMetadata['class']); $propertyAnnotations = $this->reader->getPropertyAnnotations($reflectionProperty); foreach ($propertyAnnotations as $annotation) { // property is column if ($annotation instanceof \ProAI\Datamapper\Annotations\Column) { $this->setAdditionalColumnProperties($name, $annotation, $propertyAnnotations, true, $embeddedColumnPrefix); $embeddedClassMetadata['attributes'][] = $this->parseColumn($name, $annotation, $entityMetadata, true, $primaryKeyOnly); } } } return $embeddedClassMetadata; }
/** * @param $entityName * * @return array Entity class name, null if not found * @throws \Doctrine\ORM\ORMException * @internal param string $table Table name * @internal param EntityManager $em Entity manager */ protected function getEntityStringColumns($entityName) { // Go through all the classes $classNames = $this->dqlConverter->getAvailableEntities(); $annotationReader = new AnnotationReader(); $searchingEntityName = strtolower($entityName); foreach ($classNames as $i => $className) { $className = $classNames[$i]; $classMetaData = $this->em->getClassMetadata($className); $currentEntityName = strtolower($classMetaData->getReflectionClass()->getName()); if ($currentEntityName === $searchingEntityName) { /** @var array $allColumnNames */ $allColumnNames = $classMetaData->getFieldNames(); $columnNames = []; foreach ($allColumnNames as $columnName) { try { $annotations = $annotationReader->getPropertyAnnotations(new \ReflectionProperty($classMetaData->getName(), $columnName)); if ($classMetaData->getTypeOfField($columnName) === 'string') { $isEnum = false; foreach ($annotations as $annotation) { if ($annotation instanceof Choice) { $isEnum = true; break; } } if (!$isEnum) { $columnNames[] = $columnName; } } } catch (\ReflectionException $e) { //@todo @MartinMatejka what here, return false or return null or log? } } return $columnNames; } } return []; }
/** * {@inheritdoc} */ public function loadMetadataForClass($className, ClassMetadataInfo $metadata) { $reflClass = $metadata->getReflectionClass(); $classAnnotations = $this->reader->getClassAnnotations($reflClass); // Compatibility with Doctrine Common 3.x if ($classAnnotations && is_int(key($classAnnotations))) { foreach ($classAnnotations as $annot) { $classAnnotations[get_class($annot)] = $annot; } } // Evaluate XmlEntity Annotations if (isset($classAnnotations['Doctrine\\OXM\\Mapping\\XmlEntity'])) { $entityAnnot = $classAnnotations['Doctrine\\OXM\\Mapping\\XmlEntity']; } elseif (isset($classAnnotations['Doctrine\\OXM\\Mapping\\XmlRootEntity'])) { $entityAnnot = $classAnnotations['Doctrine\\OXM\\Mapping\\XmlRootEntity']; $metadata->isRoot = true; } elseif (isset($classAnnotations['Doctrine\\OXM\\Mapping\\XmlMappedSuperclass'])) { $entityAnnot = $classAnnotations['Doctrine\\OXM\\Mapping\\XmlMappedSuperclass']; $metadata->isMappedSuperclass = true; } else { throw MappingException::classIsNotAValidXmlEntity($className); } $metadata->setName($reflClass->getName()); if (isset($entityAnnot->xml)) { $metadata->setXmlName($entityAnnot->xml); } else { $metadata->setXmlName(Inflector::xmlize($reflClass->getShortName())); } if (isset($entityAnnot->repositoryClass)) { $metadata->setCustomRepositoryClass($entityAnnot->repositoryClass); } // Evaluate XmlChangeTrackingPolicy annotation if (isset($classAnnotations['Doctrine\\OXM\\Mapping\\XmlChangeTrackingPolicy'])) { $changeTrackingAnnot = $classAnnotations['Doctrine\\OXM\\Mapping\\XmlChangeTrackingPolicy']; $metadata->setChangeTrackingPolicy(constant('Doctrine\\OXM\\Mapping\\ClassMetadata::CHANGETRACKING_' . $changeTrackingAnnot->value)); } // Check for XmlNamespace/XmlNamespaces annotations $xmlNamespaces = array(); if (isset($classAnnotations['Doctrine\\OXM\\Mapping\\XmlNamespace'])) { $xmlNamespaceAnnot = $classAnnotations['Doctrine\\OXM\\Mapping\\XmlNamespace']; $xmlNamespaces[] = array('url' => $xmlNamespaceAnnot->url, 'prefix' => $xmlNamespaceAnnot->prefix); } else { if (isset($classAnnotations['Doctrine\\OXM\\Mapping\\XmlNamespaces'])) { $xmlNamespaceAnnot = $classAnnotations['Doctrine\\OXM\\Mapping\\XmlNamespaces']; foreach ($xmlNamespaceAnnot->value as $xmlNamespace) { $xmlNamespaces[] = array('url' => $xmlNamespace->url, 'prefix' => $xmlNamespace->prefix); } } } $metadata->setXmlNamespaces($xmlNamespaces); foreach ($reflClass->getProperties() as $property) { if ($metadata->isMappedSuperclass && !$property->isPrivate() || $metadata->isInheritedField($property->name)) { continue; } $mapping = array(); $mapping['fieldName'] = $property->getName(); if ($idAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\\OXM\\Mapping\\XmlId')) { $mapping['id'] = true; } if ($generatedValueAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\\OXM\\Mapping\\XmlGeneratedValue')) { $metadata->setIdGeneratorType(constant('Doctrine\\OXM\\Mapping\\ClassMetadata::GENERATOR_TYPE_' . $generatedValueAnnot->strategy)); } $referenceAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\\OXM\\Mapping\\XmlReferences'); if (isset($referenceAnnot->entityName)) { $mapping['references'] = $referenceAnnot->entityName; } // todo add Id Generator strategy support foreach ($this->reader->getPropertyAnnotations($property) as $fieldAnnot) { if ($fieldAnnot instanceof \Doctrine\OXM\Mapping\XmlField) { if ($fieldAnnot->type == null) { throw MappingException::propertyTypeIsRequired($className, $property->getName()); } $mapping = array_merge($mapping, (array) $fieldAnnot); $metadata->mapField($mapping); } } } // Evaluate @HasLifecycleCallbacks annotations if (isset($classAnnotations['Doctrine\\OXM\\Mapping\\HasLifecycleCallbacks'])) { foreach ($reflClass->getMethods() as $method) { // filter for the declaring class only, callbacks from parents will already be registered. if ($method->isPublic() && $method->getDeclaringClass()->getName() == $reflClass->name) { $annotations = $this->reader->getMethodAnnotations($method); // Compatibility with Doctrine Common 3.x if ($annotations && is_int(key($annotations))) { foreach ($annotations as $annot) { $annotations[get_class($annot)] = $annot; } } if (isset($annotations['Doctrine\\OXM\\Mapping\\PreMarshal'])) { $metadata->addLifecycleCallback($method->getName(), \Doctrine\OXM\Events::preMarshal); } if (isset($annotations['Doctrine\\OXM\\Mapping\\PostMarshal'])) { $metadata->addLifecycleCallback($method->getName(), \Doctrine\OXM\Events::postMarshal); } if (isset($annotations['Doctrine\\OXM\\Mapping\\PreUnmarshal'])) { $metadata->addLifecycleCallback($method->getName(), \Doctrine\OXM\Events::preUnmarshal); } if (isset($annotations['Doctrine\\OXM\\Mapping\\PostUnmarshal'])) { $metadata->addLifecycleCallback($method->getName(), \Doctrine\OXM\Events::postUnmarshal); } if (isset($annotations['Doctrine\\OXM\\Mapping\\PrePersist'])) { $metadata->addLifecycleCallback($method->getName(), \Doctrine\OXM\Events::prePersist); } if (isset($annotations['Doctrine\\OXM\\Mapping\\PostPersist'])) { $metadata->addLifecycleCallback($method->getName(), \Doctrine\OXM\Events::postPersist); } if (isset($annotations['Doctrine\\OXM\\Mapping\\PreUpdate'])) { $metadata->addLifecycleCallback($method->getName(), \Doctrine\OXM\Events::preUpdate); } if (isset($annotations['Doctrine\\OXM\\Mapping\\PostUpdate'])) { $metadata->addLifecycleCallback($method->getName(), \Doctrine\OXM\Events::postUpdate); } if (isset($annotations['Doctrine\\OXM\\Mapping\\PreRemove'])) { $metadata->addLifecycleCallback($method->getName(), \Doctrine\OXM\Events::preRemove); } if (isset($annotations['Doctrine\\OXM\\Mapping\\PostRemove'])) { $metadata->addLifecycleCallback($method->getName(), \Doctrine\OXM\Events::postRemove); } if (isset($annotations['Doctrine\\OXM\\Mapping\\PreLoad'])) { $metadata->addLifecycleCallback($method->getName(), \Doctrine\OXM\Events::preLoad); } if (isset($annotations['Doctrine\\OXM\\Mapping\\PostLoad'])) { $metadata->addLifecycleCallback($method->getName(), \Doctrine\OXM\Events::postLoad); } } } } }
/** * {@inheritdoc} */ public function loadMetadataForClass($className, ClassMetadata $class) { $reflClass = $class->getReflectionClass(); $classAnnotations = $this->reader->getClassAnnotations($reflClass); if (isset($classAnnotations['Doctrine\\ODM\\CouchDB\\Mapping\\Document'])) { $documentAnnot = $classAnnotations['Doctrine\\ODM\\CouchDB\\Mapping\\Document']; if ($documentAnnot->indexed) { $class->indexed = true; } $class->setCustomRepositoryClass($documentAnnot->repositoryClass); } elseif (isset($classAnnotations['Doctrine\\ODM\\CouchDB\\Mapping\\EmbeddedDocument'])) { $documentAnnot = $classAnnotations['Doctrine\\ODM\\CouchDB\\Mapping\\EmbeddedDocument']; $class->isEmbeddedDocument = true; } else { if (isset($classAnnotations['Doctrine\\ODM\\CouchDB\\Mapping\\MappedSuperclass'])) { $class->isMappedSuperclass = true; } else { throw MappingException::classIsNotAValidDocument($className); } } foreach ($reflClass->getProperties() as $property) { $mapping = array(); $mapping['fieldName'] = $property->getName(); foreach ($this->reader->getPropertyAnnotations($property) as $fieldAnnot) { if ($fieldAnnot instanceof \Doctrine\ODM\CouchDB\Mapping\Field) { if ($fieldAnnot instanceof \Doctrine\ODM\CouchDB\Mapping\Version) { $mapping['isVersionField'] = true; } $mapping = array_merge($mapping, (array) $fieldAnnot); unset($mapping['value']); $class->mapField($mapping); } else { if ($fieldAnnot instanceof \Doctrine\ODM\CouchDB\Mapping\ReferenceOne) { $cascade = 0; foreach ($fieldAnnot->cascade as $cascadeMode) { $cascade += constant('Doctrine\\ODM\\CouchDB\\Mapping\\ClassMetadata::CASCADE_' . strtoupper($cascadeMode)); } $fieldAnnot->cascade = $cascade; $mapping = array_merge($mapping, (array) $fieldAnnot); unset($mapping['value']); $class->mapManyToOne($mapping); } else { if ($fieldAnnot instanceof \Doctrine\ODM\CouchDB\Mapping\ReferenceMany) { $cascade = 0; foreach ($fieldAnnot->cascade as $cascadeMode) { $cascade += constant('Doctrine\\ODM\\CouchDB\\Mapping\\ClassMetadata::CASCADE_' . strtoupper($cascadeMode)); } $fieldAnnot->cascade = $cascade; $mapping = array_merge($mapping, (array) $fieldAnnot); unset($mapping['value']); $class->mapManyToMany($mapping); } else { if ($fieldAnnot instanceof \Doctrine\ODM\CouchDB\Mapping\Attachments) { $class->mapAttachments($mapping['fieldName']); } else { if ($fieldAnnot instanceof \Doctrine\ODM\CouchDB\Mapping\EmbedOne || $fieldAnnot instanceof \Doctrine\ODM\CouchDB\Mapping\EmbedMany) { $mapping = array_merge($mapping, (array) $fieldAnnot); unset($mapping['value']); $class->mapEmbedded($mapping); } } } } } } } }
protected function createFixtureAnnotation($entity, &$fieldMappings) { $anotationReader = new AnnotationReader(); foreach ($fieldMappings as $fieldName => $fieldValue) { $propertyAnnotations = $anotationReader->getPropertyAnnotations(new \ReflectionProperty($entity, $fieldName)); foreach ($propertyAnnotations as $annotation) { if ($annotation instanceof FixtureDataType) { $fieldMappings[$fieldName]["fixtureDataType"] = $annotation->value; } } } }
/** * {@inheritdoc} */ public function loadMetadataForClass($className, ClassMetadata $class) { $reflClass = $class->getReflectionClass(); $classAnnotations = $this->reader->getClassAnnotations($reflClass); if (isset($classAnnotations['Doctrine\\ODM\\MongoDB\\Mapping\\Document'])) { $documentAnnot = $classAnnotations['Doctrine\\ODM\\MongoDB\\Mapping\\Document']; } elseif (isset($classAnnotations['Doctrine\\ODM\\MongoDB\\Mapping\\MappedSuperclass'])) { $documentAnnot = $classAnnotations['Doctrine\\ODM\\MongoDB\\Mapping\\MappedSuperclass']; $class->isMappedSuperclass = true; } elseif (isset($classAnnotations['Doctrine\\ODM\\MongoDB\\Mapping\\EmbeddedDocument'])) { $documentAnnot = $classAnnotations['Doctrine\\ODM\\MongoDB\\Mapping\\EmbeddedDocument']; $class->isEmbeddedDocument = true; } else { throw MongoDBException::classIsNotAValidDocument($className); } if (isset($documentAnnot->db)) { $class->setDatabase($documentAnnot->db); } if (isset($documentAnnot->collection)) { $class->setCollection($documentAnnot->collection); } if (isset($documentAnnot->repositoryClass)) { $class->setCustomRepositoryClass($documentAnnot->repositoryClass); } if (isset($classAnnotations['Doctrine\\ODM\\MongoDB\\Mapping\\Indexes'])) { $indexes = $classAnnotations['Doctrine\\ODM\\MongoDB\\Mapping\\Indexes']->value; $indexes = is_array($indexes) ? $indexes : array($indexes); foreach ($indexes as $index) { $this->addIndex($class, $index); } } if (isset($classAnnotations['Doctrine\\ODM\\MongoDB\\Mapping\\Index'])) { $index = $classAnnotations['Doctrine\\ODM\\MongoDB\\Mapping\\Index']; $this->addIndex($class, $index); } if (isset($classAnnotations['Doctrine\\ODM\\MongoDB\\Mapping\\UniqueIndex'])) { $index = $classAnnotations['Doctrine\\ODM\\MongoDB\\Mapping\\UniqueIndex']; $this->addIndex($class, $index); } if (isset($documentAnnot->indexes)) { foreach ($documentAnnot->indexes as $index) { $this->addIndex($class, $index); } } if (isset($classAnnotations['Doctrine\\ODM\\MongoDB\\Mapping\\InheritanceType'])) { $inheritanceTypeAnnot = $classAnnotations['Doctrine\\ODM\\MongoDB\\Mapping\\InheritanceType']; $class->setInheritanceType(constant('Doctrine\\ODM\\MongoDB\\Mapping\\ClassMetadata::INHERITANCE_TYPE_' . $inheritanceTypeAnnot->value)); } if (isset($classAnnotations['Doctrine\\ODM\\MongoDB\\Mapping\\DiscriminatorField'])) { $discrFieldAnnot = $classAnnotations['Doctrine\\ODM\\MongoDB\\Mapping\\DiscriminatorField']; $class->setDiscriminatorField(array('fieldName' => $discrFieldAnnot->fieldName)); } if (isset($classAnnotations['Doctrine\\ODM\\MongoDB\\Mapping\\DiscriminatorMap'])) { $discrMapAnnot = $classAnnotations['Doctrine\\ODM\\MongoDB\\Mapping\\DiscriminatorMap']; $class->setDiscriminatorMap($discrMapAnnot->value); } if (isset($classAnnotations['Doctrine\\ODM\\MongoDB\\Mapping\\DiscriminatorValue'])) { $discrValueAnnot = $classAnnotations['Doctrine\\ODM\\MongoDB\\Mapping\\DiscriminatorValue']; $class->setDiscriminatorValue($discrValueAnnot->value); } if (isset($classAnnotations['Doctrine\\ODM\\MongoDB\\Mapping\\ChangeTrackingPolicy'])) { $changeTrackingAnnot = $classAnnotations['Doctrine\\ODM\\MongoDB\\Mapping\\ChangeTrackingPolicy']; $class->setChangeTrackingPolicy(constant('Doctrine\\ODM\\MongoDB\\Mapping\\ClassMetadata::CHANGETRACKING_' . $changeTrackingAnnot->value)); } $methods = $reflClass->getMethods(); foreach ($reflClass->getProperties() as $property) { if ($class->isMappedSuperclass && !$property->isPrivate() || $class->isInheritedField($property->name)) { continue; } $mapping = array(); $mapping['fieldName'] = $property->getName(); if ($alsoLoad = $this->reader->getPropertyAnnotation($property, 'Doctrine\\ODM\\MongoDB\\Mapping\\AlsoLoad')) { $mapping['alsoLoadFields'] = (array) $alsoLoad->value; } if ($notSaved = $this->reader->getPropertyAnnotation($property, 'Doctrine\\ODM\\MongoDB\\Mapping\\NotSaved')) { $mapping['notSaved'] = true; } if ($versionAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\\ODM\\MongoDB\\Mapping\\Version')) { $mapping['version'] = true; } if ($versionAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\\ODM\\MongoDB\\Mapping\\Lock')) { $mapping['lock'] = true; } $indexes = $this->reader->getPropertyAnnotation($property, 'Doctrine\\ODM\\MongoDB\\Mapping\\Indexes'); $indexes = $indexes ? $indexes : array(); if ($index = $this->reader->getPropertyAnnotation($property, 'Doctrine\\ODM\\MongoDB\\Mapping\\Index')) { $indexes[] = $index; } if ($index = $this->reader->getPropertyAnnotation($property, 'Doctrine\\ODM\\MongoDB\\Mapping\\UniqueIndex')) { $indexes[] = $index; } foreach ($this->reader->getPropertyAnnotations($property) as $fieldAnnot) { if ($fieldAnnot instanceof \Doctrine\ODM\MongoDB\Mapping\Field) { $mapping = array_merge($mapping, (array) $fieldAnnot); $class->mapField($mapping); } } if ($indexes) { foreach ($indexes as $index) { $name = isset($mapping['name']) ? $mapping['name'] : $mapping['fieldName']; $keys = array(); $keys[$name] = 'asc'; if (isset($index->order)) { $keys[$name] = $index->order; } $this->addIndex($class, $index, $keys); } } } foreach ($methods as $method) { if ($method->isPublic()) { if ($alsoLoad = $this->reader->getMethodAnnotation($method, 'Doctrine\\ODM\\MongoDB\\Mapping\\AlsoLoad')) { $fields = (array) $alsoLoad->value; foreach ($fields as $value) { $class->alsoLoadMethods[$value] = $method->getName(); } } } } if (isset($classAnnotations['Doctrine\\ODM\\MongoDB\\Mapping\\HasLifecycleCallbacks'])) { foreach ($methods as $method) { if ($method->isPublic()) { $annotations = $this->reader->getMethodAnnotations($method); if (isset($annotations['Doctrine\\ODM\\MongoDB\\Mapping\\PrePersist'])) { $class->addLifecycleCallback($method->getName(), \Doctrine\ODM\MongoDB\Events::prePersist); } if (isset($annotations['Doctrine\\ODM\\MongoDB\\Mapping\\PostPersist'])) { $class->addLifecycleCallback($method->getName(), \Doctrine\ODM\MongoDB\Events::postPersist); } if (isset($annotations['Doctrine\\ODM\\MongoDB\\Mapping\\PreUpdate'])) { $class->addLifecycleCallback($method->getName(), \Doctrine\ODM\MongoDB\Events::preUpdate); } if (isset($annotations['Doctrine\\ODM\\MongoDB\\Mapping\\PostUpdate'])) { $class->addLifecycleCallback($method->getName(), \Doctrine\ODM\MongoDB\Events::postUpdate); } if (isset($annotations['Doctrine\\ODM\\MongoDB\\Mapping\\PreRemove'])) { $class->addLifecycleCallback($method->getName(), \Doctrine\ODM\MongoDB\Events::preRemove); } if (isset($annotations['Doctrine\\ODM\\MongoDB\\Mapping\\PostRemove'])) { $class->addLifecycleCallback($method->getName(), \Doctrine\ODM\MongoDB\Events::postRemove); } if (isset($annotations['Doctrine\\ODM\\MongoDB\\Mapping\\PreLoad'])) { $class->addLifecycleCallback($method->getName(), \Doctrine\ODM\MongoDB\Events::preLoad); } if (isset($annotations['Doctrine\\ODM\\MongoDB\\Mapping\\PostLoad'])) { $class->addLifecycleCallback($method->getName(), \Doctrine\ODM\MongoDB\Events::postLoad); } } } } }
{ return $this->getProperty(); } } // Lets parse the annotations use Doctrine\Common\Annotations\AnnotationReader; $annotationReader = new AnnotationReader(); //Get class annotation $reflectionClass = new ReflectionClass('AnnotationDemo'); $classAnnotations = $annotationReader->getClassAnnotations($reflectionClass); echo "<pre>"; echo "========= CLASS ANNOTATIONS =========" . PHP_EOL; var_dump($classAnnotations); // You can also pass ReflectionObject to the same method to read annotations in runtime $annotationDemoObject = new AnnotationDemo(); $reflectionObject = new ReflectionObject($annotationDemoObject); $objectAnnotations = $annotationReader->getClassAnnotations($reflectionObject); echo "========= OBJECT ANNOTATIONS =========" . PHP_EOL; var_dump($objectAnnotations); //Property Annotations $reflectionProperty = new ReflectionProperty('AnnotationDemo', 'property'); $propertyAnnotations = $annotationReader->getPropertyAnnotations($reflectionProperty); echo "========= PROPERTY ANNOTATIONS =========" . PHP_EOL; var_dump($propertyAnnotations); var_dump($reflectionProperty); var_dump($annotationReader->getPropertyAnnotation($reflectionProperty, 'var')); // Method Annotations $reflectionMethod = new ReflectionMethod('AnnotationDemo', 'getProperty'); $methodAnnotations = $annotationReader->getMethodAnnotations($reflectionMethod); echo "========= Method ANNOTATIONS =========" . PHP_EOL; var_dump($methodAnnotations);
/** * @param \ReflectionProperty $property * @param $structure * @throws \Exception * @return array */ protected function buildPropertyAnnotation($property, &$structure) { $field = array('name' => $this->convertNaming($property->getName()), 'type' => 'string'); $association = array(); $validators = array(); $skipValidator = false; $saveField = false; $fieldIsId = false; $useMapping = false; $annotations = $this->annoReader->getPropertyAnnotations($property); foreach ($annotations as $annotation) { if (get_class($annotation) === 'Tpg\\ExtjsBundle\\Annotation\\UseMapping') { $useMapping = true; break; } } foreach ($annotations as $annotation) { $className = get_class($annotation); /** Get Constraints from Symfony Validator */ if (strpos(get_class($annotation), 'Symfony\\Component\\Validator\\Constraints') === 0) { $validators[] = array_merge(array('field' => $this->convertNaming($property->getName())), $this->getValidator(substr($className, 40), $annotation)); } switch (get_class($annotation)) { case 'Tpg\\ExtjsBundle\\Annotation\\Model\\Field': $field['type'] = $annotation->type; break; case 'Tpg\\ExtjsBundle\\Annotation\\DefaultValue': $field['defaultValue'] = $annotation->value; break; case 'Doctrine\\ORM\\Mapping\\Id': case 'Doctrine\\ODM\\MongoDB\\Mapping\\Annotations\\Id': $field['useNull'] = true; $field['persist'] = false; $skipValidator = true; $fieldIsId = true; break; case 'Doctrine\\ODM\\MongoDB\\Mapping\\Annotations\\Timestamp': case 'Doctrine\\ODM\\MongoDB\\Mapping\\Annotations\\Date': $field['type'] = "date"; break; case 'Doctrine\\ODM\\MongoDB\\Mapping\\Annotations\\Float': $field['type'] = "float"; break; case 'Doctrine\\ODM\\MongoDB\\Mapping\\Annotations\\Boolean': $field['type'] = "boolean"; break; case 'Doctrine\\ODM\\MongoDB\\Mapping\\Annotations\\Hash': $field['type'] = "auto"; break; case 'Doctrine\\ODM\\MongoDB\\Mapping\\Annotations\\Int': case 'Doctrine\\ODM\\MongoDB\\Mapping\\Annotations\\Increment': $field['type'] = "int"; break; case 'Doctrine\\ODM\\MongoDB\\Mapping\\Annotations\\String': $field['type'] = "string"; break; case 'Doctrine\\ODM\\MongoDB\\Mapping\\Annotations\\Field': $field['type'] = $this->getColumnType($annotation->type); break; case 'Doctrine\\ORM\\Mapping\\Column': $field['type'] = $this->getColumnType($annotation->type); if ($field['type'] === "date") { $field['dateFormat'] = \DateTime::ISO8601; } $validators[] = array('type' => 'presence', 'field' => $this->convertNaming($property->getName())); if ($annotation->nullable) { $field['useNull'] = true; } foreach ($annotations as $annotationToSearchUseNull) { if (get_class($annotationToSearchUseNull) == 'Tpg\\ExtjsBundle\\Annotation\\UseNull') { $field['useNull'] = $annotationToSearchUseNull->value; } } break; case 'JMS\\Serializer\\Annotation\\SerializedName': $field['name'] = $annotation->name; break; case 'JMS\\Serializer\\Annotation\\Type': if (stripos($annotation->name, "DateTime") === 0) { $type = $annotation->name; if ($type === "DateTime") { $field['dateFormat'] = \DateTime::ISO8601; } else { $format = explode(',', substr($type, stripos($type, '<') + 2, -2)); $field['dateFormat'] = $format[0]; } } break; case 'Doctrine\\ORM\\Mapping\\OneToOne': $association['type'] = substr(get_class($annotation), 21); $association['name'] = $property->getName(); $association['model'] = $this->getModelName($annotation->targetEntity); $association['entity'] = $annotation->targetEntity; if (!isset($association['key']) || empty($association['key'])) { $association['key'] = $this->tryToGetJoinColumnNameOfMappedBy($annotation); } break; case 'Doctrine\\ORM\\Mapping\\OneToMany': $association['type'] = substr(get_class($annotation), 21); $association['name'] = $property->getName(); $association['model'] = $this->getModelName($annotation->targetEntity); $association['entity'] = $annotation->targetEntity; $association['key'] = $this->tryToGetJoinColumnNameOfMappedBy($annotation); break; case 'Doctrine\\ODM\\MongoDB\\Mapping\\Annotations\\EmbedMany': case 'Doctrine\\ODM\\MongoDB\\Mapping\\Annotations\\EmbedOne': case 'Doctrine\\ODM\\MongoDB\\Mapping\\Annotations\\ReferenceMany': case 'Doctrine\\ODM\\MongoDB\\Mapping\\Annotations\\ReferenceOne': if ($annotation->targetDocument) { $association['type'] = substr(get_class($annotation), 41); $association['name'] = $property->getName(); $association['model'] = $this->getModelName($annotation->targetDocument); $association['entity'] = $annotation->targetDocument; } else { $field['type'] = "auto"; } break; case 'Doctrine\\ORM\\Mapping\\ManyToOne': $association['type'] = substr(get_class($annotation), 21); $association['name'] = $property->getName(); $association['model'] = $this->getModelName($annotation->targetEntity); $association['entity'] = $annotation->targetEntity; break; case 'Doctrine\\ORM\\Mapping\\ManyToMany': $association['type'] = 'ManyToMany'; $association['name'] = $property->getName(); $association['model'] = $this->getModelName($annotation->targetEntity); $association['entity'] = $annotation->targetEntity; break; case 'Doctrine\\ORM\\Mapping\\JoinColumns': if (count($annotation->value) > 1) { throw new \Exception('Multiple foreign key is not supported'); } $saveField = true; $field['name'] = $this->convertNaming($annotation->value[0]->name); $field['type'] = $this->getEntityColumnType($association['entity'], $annotation->value[0]->referencedColumnName); $field['useNull'] = true; $association['key'] = $this->convertNaming($annotation->value[0]->name); break; case 'Doctrine\\ORM\\Mapping\\JoinColumn': $saveField = true; $field['name'] = $this->convertNaming($annotation->name); $field['type'] = $this->getEntityColumnType($association['entity'], $annotation->referencedColumnName); $field['useNull'] = true; $association['key'] = $this->convertNaming($annotation->name); if ($useMapping) { $field['mapping'] = $property->getName() . '.' . $annotation->referencedColumnName; } break; } } if ($fieldIsId) { $structure['idProperty'] = $field['name']; } /** Add the ability to override field parameter */ if (isset($this->fieldsParams[$field['type']])) { $field = array_merge($field, $this->fieldsParams[$field['type']]); } if (!empty($association)) { if ($association['model'] === null) { /** Related model is not available, skip this field. */ return array(); } $structure['associations'][] = $association; } if ($saveField || empty($association)) { $structure['fields'][$field['name']] = $field; } if (!empty($validators) && !$skipValidator) { $structure['validators'] = array_merge($structure['validators'], $validators); } return $field; }