/** * Event triggered during metadata loading * * @param LoadClassMetadataEventArgs $eventArgs */ public function loadClassMetadata(LoadClassMetadataEventArgs $eventArgs) { $this->classMetadata = $eventArgs->getClassMetadata(); $reflectionClass = $this->classMetadata->getReflectionClass(); if (null === $reflectionClass) { return; } if ($this->hasMethod($reflectionClass, 'updateTimestamps')) { $this->addLifecycleCallbacks(); $this->mapFields(); } }
/** * {@inheritDoc} */ public function readExtendedMetadata(ClassMetadata $meta, array &$config) { $class = $meta->getReflectionClass(); // property annotations foreach ($class->getProperties() as $property) { if ($meta->isMappedSuperclass && !$property->isPrivate() || $meta->isInheritedField($property->name) || isset($meta->associationMappings[$property->name]['inherited'])) { continue; } if ($timestampable = $this->reader->getPropertyAnnotation($property, self::TIMESTAMPABLE)) { $field = $property->getName(); if (!$meta->hasField($field)) { throw new InvalidMappingException("Unable to find timestampable [{$field}] as mapped property in entity - {$meta->name}"); } if (!$this->isValidField($meta, $field)) { throw new InvalidMappingException("Field - [{$field}] type is not valid and must be 'date', 'datetime' or 'time' in class - {$meta->name}"); } if (!in_array($timestampable->on, array('update', 'create', 'change'))) { throw new InvalidMappingException("Field - [{$field}] trigger 'on' is not one of [update, create, change] in class - {$meta->name}"); } if ($timestampable->on == 'change') { if (!isset($timestampable->field) || !isset($timestampable->value)) { throw new InvalidMappingException("Missing parameters on property - {$field}, field and value must be set on [change] trigger in class - {$meta->name}"); } $field = array('field' => $field, 'trackedField' => $timestampable->field, 'value' => $timestampable->value); } // properties are unique and mapper checks that, no risk here $config[$timestampable->on][] = $field; } } }
/** * {@inheritDoc} */ public function readExtendedMetadata(ClassMetadata $meta, array &$config) { $class = $meta->getReflectionClass(); // property annotations foreach ($class->getProperties() as $property) { if ($meta->isMappedSuperclass && !$property->isPrivate() || $meta->isInheritedField($property->name) || isset($meta->associationMappings[$property->name]['inherited'])) { continue; } // position if ($position = $this->reader->getPropertyAnnotation($property, self::POSITION)) { $field = $property->getName(); if (!$meta->hasField($field)) { throw new InvalidMappingException("Unable to find 'position' - [{$field}] as mapped property in entity - {$meta->name}"); } if (!$this->isValidField($meta, $field)) { throw new InvalidMappingException("Sortable position field - [{$field}] type is not valid and must be 'integer' in class - {$meta->name}"); } $config['position'] = $field; } // group if ($group = $this->reader->getPropertyAnnotation($property, self::GROUP)) { $field = $property->getName(); if (!$meta->hasField($field) && !$meta->hasAssociation($field)) { throw new InvalidMappingException("Unable to find 'group' - [{$field}] as mapped property in entity - {$meta->name}"); } if (!isset($config['groups'])) { $config['groups'] = array(); } $config['groups'][] = $field; } } }
/** * @param ClassMetadata $metadata * * @return bool */ protected function isResource(ClassMetadata $metadata) { if (!($reflClass = $metadata->getReflectionClass())) { return false; } return $reflClass->implementsInterface(PersistableInterface::class); }
public function testInitializedProxyUnserialization() { // persister will retrieve the lazy object itself, so that we don't have to re-define all field values $this->proxyLoader->expects($this->once())->method('load')->will($this->returnValue($this->lazyObject)); $this->lazyObject->__setInitializer($this->getSuggestedInitializerImplementation()); $this->lazyObject->__load(); $serialized = serialize($this->lazyObject); $reflClass = $this->lazyLoadableObjectMetadata->getReflectionClass(); /* @var $unserialized LazyLoadableObject|Proxy */ $unserialized = unserialize($serialized); $this->assertTrue($unserialized->__isInitialized(), 'serialization didn\'t cause intialization'); // Checking transient fields $this->assertSame('publicTransientFieldValue', $unserialized->publicTransientField, 'transient fields are kept'); $protectedTransientField = $reflClass->getProperty('protectedTransientField'); $protectedTransientField->setAccessible(true); $this->assertSame('protectedTransientFieldValue', $protectedTransientField->getValue($unserialized), 'transient fields are kept'); // Checking persistent fields $this->assertSame('publicPersistentFieldValue', $unserialized->publicPersistentField, 'persistent fields are kept'); $protectedPersistentField = $reflClass->getProperty('protectedPersistentField'); $protectedPersistentField->setAccessible(true); $this->assertSame('protectedPersistentFieldValue', $protectedPersistentField->getValue($unserialized), 'persistent fields are kept'); // Checking identifiers $this->assertSame('publicIdentifierFieldValue', $unserialized->publicIdentifierField, 'identifiers are kept'); $protectedIdentifierField = $reflClass->getProperty('protectedIdentifierField'); $protectedIdentifierField->setAccessible(true); $this->assertSame('protectedIdentifierFieldValue', $protectedIdentifierField->getValue($unserialized), 'identifiers are kept'); // Checking associations $this->assertSame('publicAssociationValue', $unserialized->publicAssociation, 'associations are kept'); $protectedAssociationField = $reflClass->getProperty('protectedAssociation'); $protectedAssociationField->setAccessible(true); $this->assertSame('protectedAssociationValue', $protectedAssociationField->getValue($unserialized), 'associations are kept'); }
/** * {@inheritDoc} */ public function readExtendedMetadata(ClassMetadata $meta, array &$config) { $class = $meta->getReflectionClass(); // property annotations $config['fields'] = array(); $config['fields_delete'] = array(); foreach ($class->getProperties() as $property) { if ($meta->isMappedSuperclass && !$property->isPrivate() || $meta->isInheritedField($property->name) || isset($meta->associationMappings[$property->name]['inherited'])) { continue; } $field = null; if ($file = $this->reader->getPropertyAnnotation($property, self::FILE)) { $field['name'] = $property->getName(); $field['dir'] = CMSCore::init()->getUploadsDir() . '/' . $file->dir; if (!$meta->hasField($field['name'])) { throw new InvalidMappingException("Unable to find timestampable [{$field}] as mapped property in entity - {$meta->name}"); } } // if ($fileDelete = $this->reader->getPropertyAnnotation($property, self::FILE_DELETE)) { // // $config['fields_delete'][] = $property->getName(); // // } if ($field) { $config['fields'][] = $field; } } }
/** * {@inheritDoc} */ public function readExtendedMetadata(ClassMetadata $meta, array &$config) { $class = $meta->getReflectionClass(); // class annotations if ($annot = $this->reader->getClassAnnotation($class, self::LOGGABLE)) { $config['loggable'] = true; if ($annot->logEntryClass) { if (!class_exists($annot->logEntryClass)) { throw new InvalidMappingException("LogEntry class: {$annot->logEntryClass} does not exist."); } $config['logEntryClass'] = $annot->logEntryClass; } } // property annotations foreach ($class->getProperties() as $property) { if ($meta->isMappedSuperclass && !$property->isPrivate() || $meta->isInheritedField($property->name) || isset($meta->associationMappings[$property->name]['inherited'])) { continue; } // versioned property if ($versioned = $this->reader->getPropertyAnnotation($property, self::VERSIONED)) { $field = $property->getName(); if ($meta->isCollectionValuedAssociation($field)) { throw new InvalidMappingException("Cannot versioned [{$field}] as it is collection in object - {$meta->name}"); } // fields cannot be overrided and throws mapping exception $config['versioned'][] = $field; } } }
/** * Loads the metadata for the specified class into the provided container. * * @param string $className * @param ClassMetadata $metadata */ public function loadMetadataForClass($className, ClassMetadata $metadata) { $class = $metadata->getReflectionClass(); if (!$class) { // this happens when running annotation driver in combination with // static reflection services. This is not the nicest fix $class = new \ReflectionClass($metadata->name); } $entityAnnot = $this->reader->getClassAnnotation($class, 'Doctrine\\KeyValueStore\\Mapping\\Annotations\\Entity'); if (!$entityAnnot) { throw new \InvalidArgumentException($metadata->name . ' is not a valid key-value-store entity.'); } $metadata->storageName = $entityAnnot->storageName; // Evaluate annotations on properties/fields foreach ($class->getProperties() as $property) { $idAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\\KeyValueStore\\Mapping\\Annotations\\Id'); $transientAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\\KeyValueStore\\Mapping\\Annotations\\Transient'); if ($idAnnot) { $metadata->mapIdentifier($property->getName()); } elseif ($transientAnnot) { $metadata->skipTransientField($property->getName()); } else { $metadata->mapField(['fieldName' => $property->getName()]); } } }
/** * Loads the metadata for the specified class into the provided container. * * @param string $className * @param ClassMetadata $metadata * @throws \Doctrine\ORM\ODMAdapter\Exception\MappingException * @return void */ public function loadMetadataForClass($className, ClassMetadata $metadata) { /** @var $class \Doctrine\ORM\ODMAdapter\Mapping\ClassMetadata */ $reflClass = $metadata->getReflectionClass(); $documentAnnots = array(); foreach ($this->reader->getClassAnnotations($reflClass) as $annot) { foreach ($this->entityAnnotationClasses as $annotClass => $i) { if ($annot instanceof $annotClass) { $documentAnnots[$i] = $annot; } } } if (!$documentAnnots) { throw MappingException::classIsNotAValidDocument($className); } $metadata->className = $className; foreach ($reflClass->getProperties() as $property) { if ($metadata->className !== $property->getDeclaringClass()->getName()) { continue; } $mapping = array(); $mapping['fieldName'] = $property->getName(); foreach ($this->reader->getPropertyAnnotations($property) as $propertyAnnotation) { if ($propertyAnnotation instanceof Adapter\ReferencePhpcr) { $mapping['type'] = Reference::PHPCR; $this->extractReferencedObjects($propertyAnnotation, $metadata, $className, $mapping); } if ($propertyAnnotation instanceof Adapter\ReferenceDbalOrm) { $mapping['type'] = Reference::DBAL_ORM; $this->extractReferencedObjects($propertyAnnotation, $metadata, $className, $mapping); } } } }
/** * {@inheritdoc} */ public function loadMetadataForClass($className, ClassMetadata $metadata) { /** @var $class ClassMetadataInfo */ $reflClass = $metadata->getReflectionClass(); if ($entityAnnot = $this->reader->getClassAnnotation($reflClass, 'Pasinter\\OHM\\Mapping\\Annotations\\Entity')) { $metadata->database = $entityAnnot->database; } // Evaluate annotations on properties/fields foreach ($reflClass->getProperties() as $property) { if ($fieldAnnot = $this->reader->getPropertyAnnotation($property, 'Pasinter\\OHM\\Mapping\\Annotations\\Field')) { $mapping = $this->fieldToArray($property->getName(), $fieldAnnot); if ($this->reader->getPropertyAnnotation($property, 'Pasinter\\OHM\\Mapping\\Annotations\\Id')) { $mapping['id'] = true; } $metadata->mapField($mapping); } elseif ($referenceOneAnnot = $this->reader->getPropertyAnnotation($property, 'Pasinter\\OHM\\Mapping\\Annotations\\ReferenceOne')) { $mapping = $this->referenceOneToArray($property->getName(), $referenceOneAnnot); $metadata->mapOneReference($mapping); } elseif ($referenceManyAnnot = $this->reader->getPropertyAnnotation($property, 'Pasinter\\OHM\\Mapping\\Annotations\\ReferenceMany')) { $mapping = $this->referenceManyToArray($property->getName(), $referenceManyAnnot); $metadata->mapManyReference($mapping); } elseif ($embedOneAnnot = $this->reader->getPropertyAnnotation($property, 'Pasinter\\OHM\\Mapping\\Annotations\\EmbedOne')) { $mapping = $this->embedOneToArray($property->getName(), $embedOneAnnot); $metadata->mapOneEmbed($mapping); } elseif ($embedManyAnnot = $this->reader->getPropertyAnnotation($property, 'Pasinter\\OHM\\Mapping\\Annotations\\EmbedMany')) { $mapping = $this->embedManyToArray($property->getName(), $embedManyAnnot); $metadata->mapManyEmbed($mapping); } } }
public function readExtendedMetadata(ClassMetadata $meta, array &$config) { // load our available annotations require_once __DIR__ . '/../Annotations.php'; $reader = new AnnotationReader(); // set annotation namespace and alias //$reader->setAnnotationNamespaceAlias('Gedmo\Mapping\Mock\Extension\Encoder\Mapping\\', 'ext'); $class = $meta->getReflectionClass(); // check only property annotations foreach ($class->getProperties() as $property) { // skip inherited properties if ($meta->isMappedSuperclass && !$property->isPrivate() || $meta->isInheritedField($property->name) || isset($meta->associationMappings[$property->name]['inherited'])) { continue; } // now lets check if property has our annotation if ($encode = $reader->getPropertyAnnotation($property, 'Gedmo\\Mapping\\Mock\\Extension\\Encoder\\Mapping\\Encode')) { $field = $property->getName(); // check if field is mapped if (!$meta->hasField($field)) { throw new \Exception("Field is not mapped as object property"); } // allow encoding only strings if (!in_array($encode->type, array('sha1', 'md5'))) { throw new \Exception("Invalid encoding type supplied"); } // validate encoding type $mapping = $meta->getFieldMapping($field); if ($mapping['type'] != 'string') { throw new \Exception("Only strings can be encoded"); } // store the metadata $config['encode'][$field] = array('type' => $encode->type, 'secret' => $encode->secret); } } }
/** * Hydrate $object with the provided $data. * * @param array $data * @param object $object * @throws \Exception * @return object */ public function hydrate(array $data, $object) { $this->metadata = $this->objectManager->getClassMetadata(get_class($object)); $object = $this->tryConvertArrayToObject($data, $object); foreach ($data as $field => &$value) { $value = $this->hydrateValue($field, $value); if ($value === null) { continue; } // @todo DateTime (and other types) conversion should be handled by doctrine itself in future if (in_array($this->metadata->getTypeOfField($field), array('datetime', 'time', 'date'))) { if (is_int($value)) { $dt = new DateTime(); $dt->setTimestamp($value); $value = $dt; } elseif (is_string($value)) { $value = new DateTime($value); } } if ($this->metadata->hasAssociation($field)) { $target = $this->metadata->getAssociationTargetClass($field); if ($this->metadata->isSingleValuedAssociation($field)) { $value = $this->toOne($value, $target); } elseif ($this->metadata->isCollectionValuedAssociation($field)) { $value = $this->toMany($value, $target); // Automatically merge collections using helper utility $propertyRefl = $this->metadata->getReflectionClass()->getProperty($field); $propertyRefl->setAccessible(true); $previousValue = $propertyRefl->getValue($object); $value = CollectionUtils::intersectUnion($previousValue, $value); } } } return $this->hydrator->hydrate($data, $object); }
protected function appendConfigurationFromMetadata(ClassMetadata $metadata, &$configuration) { $serializationFilePath = $this->resolvePath($metadata->getReflectionClass()); if ($this->filesystem->exists($serializationFilePath)) { $content = file_get_contents($serializationFilePath); $configuration = array_replace_recursive($configuration, $this->parseContent($content)); } }
/** * {@inheritDoc} */ public function readExtendedMetadata(ClassMetadata $meta, array &$config) { $class = $meta->getReflectionClass(); // property annotations foreach ($class->getProperties() as $property) { if ($meta->isMappedSuperclass && !$property->isPrivate() || $meta->isInheritedField($property->name) || isset($meta->associationMappings[$property->name]['inherited'])) { continue; } // slug property if ($slug = $this->reader->getPropertyAnnotation($property, self::SLUG)) { $field = $property->getName(); if (!$meta->hasField($field)) { throw new InvalidMappingException("Unable to find slug [{$field}] as mapped property in entity - {$meta->name}"); } if (!$this->isValidField($meta, $field)) { throw new InvalidMappingException("Cannot use field - [{$field}] for slug storage, type is not valid and must be 'string' or 'text' in class - {$meta->name}"); } // process slug handlers $handlers = array(); if (is_array($slug->handlers) && $slug->handlers) { foreach ($slug->handlers as $handler) { if (!$handler instanceof SlugHandler) { throw new InvalidMappingException("SlugHandler: {$handler} should be instance of SlugHandler annotation in entity - {$meta->name}"); } if (!strlen($handler->class)) { throw new InvalidMappingException("SlugHandler class: {$handler->class} should be a valid class name in entity - {$meta->name}"); } $class = $handler->class; $handlers[$class] = array(); foreach ((array) $handler->options as $option) { if (!$option instanceof SlugHandlerOption) { throw new InvalidMappingException("SlugHandlerOption: {$option} should be instance of SlugHandlerOption annotation in entity - {$meta->name}"); } if (!strlen($option->name)) { throw new InvalidMappingException("SlugHandlerOption name: {$option->name} should be valid name in entity - {$meta->name}"); } $handlers[$class][$option->name] = $option->value; } $class::validate($handlers[$class], $meta); } } // process slug fields if (empty($slug->fields) || !is_array($slug->fields)) { throw new InvalidMappingException("Slug must contain at least one field for slug generation in class - {$meta->name}"); } foreach ($slug->fields as $slugField) { if (!$meta->hasField($slugField)) { throw new InvalidMappingException("Unable to find slug [{$slugField}] as mapped property in entity - {$meta->name}"); } if (!$this->isValidField($meta, $slugField)) { throw new InvalidMappingException("Cannot use field - [{$slugField}] for slug storage, type is not valid and must be 'string' or 'text' in class - {$meta->name}"); } } // set all options $config['slugs'][$field] = array('fields' => $slug->fields, 'slug' => $field, 'style' => $slug->style, 'updatable' => $slug->updatable, 'unique' => $slug->unique, 'separator' => $slug->separator, 'handlers' => $handlers); } } }
/** * {@inheritDoc} */ public function mapTranslation(ClassMetadata $meta, $translatableClassName) { $rc = $meta->getReflectionClass(); if (!$rc->hasProperty('object') || $meta->hasAssociation('object') || !$rc->isSubclassOf($this->personalTranslation)) { return; } $namingStrategy = $this->getObjectManager()->getConfiguration()->getNamingStrategy(); $meta->mapManyToOne(['targetEntity' => $translatableClassName, 'fieldName' => 'object', 'inversedBy' => 'translations', 'isOwningSide' => true, 'joinColumns' => [['name' => $namingStrategy->joinColumnName('object'), 'referencedColumnName' => $namingStrategy->referenceColumnName(), 'onDelete' => 'CASCADE', 'onUpdate' => 'CASCADE']]]); }
public function testLoadClassMetadata() { $this->loadClassMetadataEvent->getClassMetadata()->willReturn($this->classMetadata->reveal()); $this->classMetadata->getReflectionClass()->willReturn($this->refl->reveal()); $this->refl->implementsInterface('Sulu\\Component\\Persistence\\Model\\UserBlameInterface')->willReturn(true); $this->classMetadata->hasAssociation('creator')->shouldBeCalled(); $this->classMetadata->hasAssociation('changer')->shouldBeCalled(); $this->classMetadata->mapManyToOne(Argument::any())->shouldBeCalled(); $this->subscriber->loadClassMetadata($this->loadClassMetadataEvent->reveal()); }
/** * Extract values from an object using a by-reference logic (this means that values are * directly fetched without using the public API of the entity, in this case, getters) * * @param object $object * @return array */ protected function extractByReference($object) { $fieldNames = array_merge($this->metadata->getFieldNames(), $this->metadata->getAssociationNames()); $refl = $this->metadata->getReflectionClass(); $data = array(); foreach ($fieldNames as $fieldName) { $reflProperty = $refl->getProperty($fieldName); $reflProperty->setAccessible(true); $data[$fieldName] = $this->extractValue($fieldName, $reflProperty->getValue($object)); } return $data; }
/** * {@inheritdoc} */ public function readMetadata(ClassMetadata $doctrineMeta, array &$meta) { if (!isset($meta['defaultValues'])) { $meta['defaultValues'] = []; } foreach ($doctrineMeta->getReflectionClass()->getProperties() as $reflectionProperty) { $defaultValueAnnotation = $this->reader->getPropertyAnnotation($reflectionProperty, DefaultValue::ANNOTATION); if ($defaultValueAnnotation instanceof DefaultValue) { $meta['defaultValues'][$reflectionProperty->getName()] = $defaultValueAnnotation->sourcePropertyPath; } } }
/** * @param string $className * @param ClassMetadata|\Doctrine\Search\Mapping\ClassMetadata $metadata * * @throws \ReflectionException */ public function loadMetadataForClass($className, ClassMetadata $metadata) { $class = $metadata->getReflectionClass(); if (!$class) { $class = new \ReflectionClass((string) $className); } $classAnnotations = $this->reader->getClassAnnotations($class); $classMapping = array(); $validMapping = false; foreach ($classAnnotations as $annotation) { switch (get_class($annotation)) { case 'Doctrine\\Search\\Mapping\\Annotations\\ElasticSearchable': $classMapping = (array) $annotation; $classMapping['class'] = 'ElasticSearchable'; $validMapping = true; break; case 'Doctrine\\Search\\Mapping\\Annotations\\Searchable': $classMapping = (array) $annotation; $classMapping['class'] = 'Searchable'; $validMapping = true; break; case 'Doctrine\\Search\\Mapping\\Annotations\\ElasticRoot': $rootMapping = (array) $annotation; $metadata->mapRoot($this->rootToArray($rootMapping)); break; } } if (!$validMapping) { throw MappingException::classIsNotAValidDocument($className); } $this->annotateClassMetadata($classMapping, $metadata); $properties = $class->getProperties(); foreach ($properties as $property) { $propertyAnnotations = $this->reader->getPropertyAnnotations($property); foreach ($propertyAnnotations as $annotation) { switch (get_class($annotation)) { case 'Doctrine\\Search\\Mapping\\Annotations\\Id': $metadata->identifier = $property->getName(); break; case 'Doctrine\\Search\\Mapping\\Annotations\\Parameter': $mapping = $this->parameterToArray($property->getName(), (array) $annotation); $metadata->mapParameter($mapping); break; case 'Doctrine\\Search\\Mapping\\Annotations\\Field': case 'Doctrine\\Search\\Mapping\\Annotations\\ElasticField': case 'Doctrine\\Search\\Mapping\\Annotations\\SolrField': $mapping = $this->fieldToArray($property->getName(), (array) $annotation); $metadata->mapField($mapping); break; } } } }
/** * @param string $className * @param ClassMetadata|\Revinate\SearchBundle\Lib\Search\Mapping\ClassMetadata $metadata * * @throws \ReflectionException */ public function loadMetadataForClass($className, ClassMetadata $metadata) { $reflClass = $metadata->getReflectionClass(); if (!$reflClass) { $reflClass = new \ReflectionClass((string) $className); } $reflProperties = $reflClass->getProperties(); $reflMethods = $reflClass->getMethods(); $this->extractClassAnnotations($reflClass, $metadata); $this->extractPropertiesAnnotations($reflProperties, $metadata); $this->extractMethodsAnnotations($reflMethods, $metadata); }
/** * {@inheritDoc} */ public function mapHierarchy(ClassMetadata $meta) { if ($meta->isMappedSuperclass || !$meta->isRootEntity()) { return; } $rc = $meta->getReflectionClass(); if ($rc->hasProperty('parent') && !$meta->hasAssociation('parent')) { $meta->mapManyToOne(['targetEntity' => $meta->getName(), 'fieldName' => 'parent', 'inversedBy' => 'children', 'cascade' => ['persist']]); } if ($rc->hasProperty('children') && !$meta->hasAssociation('children')) { $meta->mapOneToMany(['targetEntity' => $meta->getName(), 'fieldName' => 'children', 'mappedBy' => 'parent', 'cascade' => ['persist', 'remove'], 'fetch' => 'EXTRA_LAZY']); } }
protected function processMethodAnnotations(ClassMetadata $source, ClassMetadata $target, $annotationReader, $eventManager) { $sourceReflClass = $source->getReflectionClass(); //Method annotations foreach ($sourceReflClass->getMethods() as $reflMethod) { foreach ($annotationReader->getMethodAnnotations($reflMethod) as $annotation) { if (defined(get_class($annotation) . '::EVENT')) { // Raise annotation event $eventManager->dispatchEvent($annotation::EVENT, new AnnotationEventArgs($target, EventType::METHOD, $annotation, $reflMethod, $eventManager)); } } } }
/** * {@inheritdoc} */ public function readMetadata(ClassMetadata $doctrineMeta, array &$meta) { if (!isset($meta['customObjects'])) { $meta['customObjects'] = []; } foreach ($doctrineMeta->getReflectionClass()->getProperties() as $reflectionProperty) { $customObjectAnnotation = $this->reader->getPropertyAnnotation($reflectionProperty, CustomObject::ANNOTATION); if (!$customObjectAnnotation instanceof CustomObject) { continue; } $this->validateAnnotation($customObjectAnnotation, $doctrineMeta->getName(), $reflectionProperty->getName()); $meta['customObjects'][$reflectionProperty->getName()] = get_object_vars($customObjectAnnotation); } }
/** * {@inheritdoc} */ public function readMetadata(ClassMetadata $doctrineMeta, array &$meta) { if (!isset($meta['transliteratable'])) { $meta['transliteratable'] = []; } foreach ($doctrineMeta->getReflectionClass()->getProperties() as $reflectionProperty) { $transliteratableAnnotation = $this->reader->getPropertyAnnotation($reflectionProperty, Transliteratable::ANNOTATION); if ($transliteratableAnnotation instanceof Transliteratable) { if (!$doctrineMeta->hasField($reflectionProperty->getName())) { throw $this->createPropertyAnnotationInvalidException(Transliteratable::ANNOTATION, $doctrineMeta->getName(), $reflectionProperty->getName(), 'property must be mapped field'); } $meta['transliteratable'][$reflectionProperty->getName()] = get_object_vars($transliteratableAnnotation); } } }
/** * Loads the metadata for the specified class into the provided container. * * @param string $className * @param ClassMetadata $metadata * * @return void */ public function loadMetadataForClass($className, ClassMetadata $metadata) { /* @var $metadata \Doctrine\ORM\Mapping\ClassMetadataInfo */ $metadata->hasEncryptedProperties = false; $metadata->encryptedProperties = array(); $class = $metadata->getReflectionClass(); foreach ($class->getProperties() as $name => $property) { /** @var \Giftcards\Encryption\Doctrine\Configuration\Annotation\Encrypted $annotation */ $annotation = $this->reader->getPropertyAnnotation($property, 'Giftcards\\Encryption\\Doctrine\\Configuration\\Annotation\\Encrypted'); if (!$annotation) { continue; } $metadata->hasEncryptedProperties = true; $metadata->encryptedProperties[$property->getName()] = array('profile' => $annotation->profile); } }
/** * Extract values from an object using a by-reference logic (this means that values are * directly fetched without using the public API of the entity, in this case, getters) * * @param object $object * @return array */ protected function extractByReference($object) { $fieldNames = array_merge($this->metadata->getFieldNames(), $this->metadata->getAssociationNames()); $refl = $this->metadata->getReflectionClass(); $filter = $object instanceof FilterProviderInterface ? $object->getFilter() : $this->filterComposite; $data = array(); foreach ($fieldNames as $fieldName) { if ($filter && !$filter->filter($fieldName)) { continue; } $reflProperty = $refl->getProperty($fieldName); $reflProperty->setAccessible(true); $data[$fieldName] = $this->extractValue($fieldName, $reflProperty->getValue($object), $object); } return $data; }
/** * {@inheritdoc} */ public function readMetadata(ClassMetadata $doctrineMeta, array &$meta) { if (!isset($meta['slugs'])) { $meta['slugs'] = []; } foreach ($doctrineMeta->getReflectionClass()->getProperties() as $reflectionProperty) { $slugAnnotation = $this->reader->getPropertyAnnotation($reflectionProperty, Slug::ANNOTATION); if ($slugAnnotation instanceof Slug) { $this->validateAnnotation($slugAnnotation, $doctrineMeta->getName(), $reflectionProperty->getName()); $meta['slugs'][$reflectionProperty->getName()] = get_object_vars($slugAnnotation); if (!empty($slugAnnotation->prefixProvider)) { $meta['slugs'][$reflectionProperty->getName()]['prefixProvider'] = get_object_vars($slugAnnotation->prefixProvider); } } } }
/** * {@inheritDoc} */ public function readExtendedMetadata(ClassMetadata $meta, array &$config) { $class = $meta->getReflectionClass(); // property annotations foreach ($class->getProperties() as $property) { if ($meta->isMappedSuperclass && !$property->isPrivate() || $meta->isInheritedField($property->name) || isset($meta->associationMappings[$property->name]['inherited'])) { continue; } if ($demo = $this->reader->getPropertyAnnotation($property, self::DEMO)) { $field = $property->getName(); $value = $demo->text; if (!$meta->hasField($field)) { throw new InvalidMappingException("Unable to find timestampable [{$field}] as mapped property in entity - {$meta->name}"); } $config['text'][] = array('field' => $field, 'value' => $value); } } }
/** * {@inheritDoc} */ public function readExtendedMetadata(ClassMetadata $meta, array &$config) { $class = $meta->getReflectionClass(); // property annotations foreach ($class->getProperties() as $property) { if ($meta->isMappedSuperclass && !$property->isPrivate() || $meta->isInheritedField($property->name) || isset($meta->associationMappings[$property->name]['inherited']) ) { continue; } // sluggable property if ($sluggable = $this->reader->getPropertyAnnotation($property, self::SLUGGABLE)) { $field = $property->getName(); if (!$meta->hasField($field)) { throw new InvalidMappingException("Unable to find sluggable [{$field}] as mapped property in entity - {$meta->name}"); } if (!$this->isValidField($meta, $field)) { throw new InvalidMappingException("Cannot slug field - [{$field}] type is not valid and must be 'string' in class - {$meta->name}"); } if (!is_null($sluggable->slugField) and !$meta->hasField($sluggable->slugField)) { throw new InvalidMappingException(sprintf('The "%s" property - which is defined as the "slugField" for the "%s" property - does not exist or is not mapped to Doctrine in "%s"', $sluggable->slugField, $field, $meta->name)); } $config['fields'][$sluggable->slugField][] = array('field' => $field, 'position' => $sluggable->position, 'slugField' => $sluggable->slugField); } // slug property if ($slug = $this->reader->getPropertyAnnotation($property, self::SLUG)) { $field = $property->getName(); if (!$meta->hasField($field)) { throw new InvalidMappingException("Unable to find slug [{$field}] as mapped property in entity - {$meta->name}"); } if (!$this->isValidField($meta, $field)) { throw new InvalidMappingException("Cannot use field - [{$field}] for slug storage, type is not valid and must be 'string' in class - {$meta->name}"); } $config['slugFields'][$field]['slug'] = $field; $config['slugFields'][$field]['style'] = $slug->style; $config['slugFields'][$field]['updatable'] = $slug->updatable; $config['slugFields'][$field]['unique'] = $slug->unique; $config['slugFields'][$field]['separator'] = $slug->separator; } } }
/** * {@inheritdoc} */ public function readMetadata(ClassMetadata $doctrineMeta, array &$meta) { $reflectionClass = $doctrineMeta->getReflectionClass(); $copyingPolicy = null; if (isset($meta['clonable'])) { $copyingPolicy = $meta['clonable']['copyingPolicy']; } $clonableAnnotation = $this->reader->getClassAnnotation($reflectionClass, Clonable::ANNOTATION); if ($clonableAnnotation instanceof Clonable) { $copyingPolicy = $clonableAnnotation->copyingPolicy; } if (empty($copyingPolicy)) { return; } if (!isset($meta['clonable'])) { $meta['clonable'] = []; } $meta['clonable']['copyingPolicy'] = $copyingPolicy; $properties = $this->getPropertiesToCopy($reflectionClass, $copyingPolicy, $doctrineMeta->getIdentifier()); $meta['clonable']['properties'] = isset($meta['clonable']['properties']) ? array_merge($meta['clonable']['properties'], $properties) : $properties; }