/** * convert foreign identifiers into scalar foreign key values to avoid object to string conversion failures. * * @param ClassMetadata $class * @param array $id * * @return array */ public function flattenIdentifier(ClassMetadata $class, array $id) { $flatId = array(); foreach ($class->identifier as $field) { if (isset($class->associationMappings[$field]) && isset($id[$field]) && is_object($id[$field])) { /* @var $targetClassMetadata ClassMetadata */ $targetClassMetadata = $this->metadataFactory->getMetadataFor($class->associationMappings[$field]['targetEntity']); if ($this->unitOfWork->isInIdentityMap($id[$field])) { $associatedId = $this->flattenIdentifier($targetClassMetadata, $this->unitOfWork->getEntityIdentifier($id[$field])); } else { $associatedId = $this->flattenIdentifier($targetClassMetadata, $targetClassMetadata->getIdentifierValues($id[$field])); } $flatId[$field] = implode(' ', $associatedId); } elseif (isset($class->associationMappings[$field])) { $associatedId = array(); foreach ($class->associationMappings[$field]['joinColumns'] as $joinColumn) { $associatedId[] = $id[$joinColumn['name']]; } $flatId[$field] = implode(' ', $associatedId); } else { $flatId[$field] = $id[$field]; } } return $flatId; }
/** * @param string $class * @param string $fieldName * * @throws \Exception * * @return string */ public function getAssociationTargetClass($class, $fieldName) { $metadata = $this->classMetadataFactory->getMetadataFor($class); if (!$metadata->hasAssociation($fieldName)) { throw new \Exception(sprintf('Unable to find the association target class of "%s" in %s.', $fieldName, $class)); } return $metadata->getAssociationTargetClass($fieldName); }
/** * @param string $className * * @return ProxyDefinition * @throws FetchException */ protected function createProxyDefinition($className) { /** @var EntityMetadata $classMetadata */ $classMetadata = $this->manager->getClassMetadata($className); /** @var ApiPersister $persister */ $persister = $this->uow->getEntityPersister($className); return new ProxyDefinition(ClassUtils::generateProxyClassName($className, $this->manager->getConfiguration()->getProxyNamespace()), $classMetadata->getIdentifierFieldNames(), $classMetadata->getReflectionProperties(), $this->createInitializer($classMetadata, $persister), $this->createCloner($classMetadata, $persister)); }
/** * {@inheritdoc} */ public function getTypes($class, $property, array $context = array()) { try { $metadata = $this->classMetadataFactory->getMetadataFor($class); } catch (MappingException $exception) { return; } catch (OrmMappingException $exception) { return; } if ($metadata->hasAssociation($property)) { $class = $metadata->getAssociationTargetClass($property); if ($metadata->isSingleValuedAssociation($property)) { if ($metadata instanceof ClassMetadataInfo) { $associationMapping = $metadata->getAssociationMapping($property); $nullable = $this->isAssociationNullable($associationMapping); } else { $nullable = false; } return array(new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, $class)); } $collectionKeyType = Type::BUILTIN_TYPE_INT; if ($metadata instanceof ClassMetadataInfo) { $associationMapping = $metadata->getAssociationMapping($property); if (isset($associationMapping['indexBy'])) { $indexProperty = $associationMapping['indexBy']; $subMetadata = $this->classMetadataFactory->getMetadataFor($associationMapping['targetEntity']); $typeOfField = $subMetadata->getTypeOfField($indexProperty); $collectionKeyType = $this->getPhpType($typeOfField); } } return array(new Type(Type::BUILTIN_TYPE_OBJECT, false, 'Doctrine\\Common\\Collections\\Collection', true, new Type($collectionKeyType), new Type(Type::BUILTIN_TYPE_OBJECT, false, $class))); } if ($metadata->hasField($property)) { $typeOfField = $metadata->getTypeOfField($property); $nullable = $metadata instanceof ClassMetadataInfo && $metadata->isNullable($property); switch ($typeOfField) { case DBALType::DATE: case DBALType::DATETIME: case DBALType::DATETIMETZ: case 'vardatetime': case DBALType::TIME: return array(new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, 'DateTime')); case DBALType::TARRAY: return array(new Type(Type::BUILTIN_TYPE_ARRAY, $nullable, null, true)); case DBALType::SIMPLE_ARRAY: return array(new Type(Type::BUILTIN_TYPE_ARRAY, $nullable, null, true, new Type(Type::BUILTIN_TYPE_INT), new Type(Type::BUILTIN_TYPE_STRING))); case DBALType::JSON_ARRAY: return array(new Type(Type::BUILTIN_TYPE_ARRAY, $nullable, null, true)); default: $builtinType = $this->getPhpType($typeOfField); return $builtinType ? array(new Type($builtinType, $nullable)) : null; } } }
/** * {@inheritDoc} */ public function collect(MvcEvent $mvcEvent) { if (!$this->classMetadataFactory) { return; } /* @var $metadata \Doctrine\Common\Persistence\Mapping\ClassMetadata[] */ $metadata = $this->classMetadataFactory->getAllMetadata(); $this->classes = array(); foreach ($metadata as $class) { $this->classes[$class->getName()] = $class; } }
/** * {@inheritdoc} */ public function getTypes($class, $property, array $context = array()) { try { $metadata = $this->classMetadataFactory->getMetadataFor($class); } catch (MappingException $exception) { return; } catch (OrmMappingException $exception) { return; } if ($metadata->hasAssociation($property)) { $class = $metadata->getAssociationTargetClass($property); if ($metadata->isSingleValuedAssociation($property)) { if ($metadata instanceof ClassMetadataInfo) { $nullable = isset($metadata->discriminatorColumn['nullable']) ? $metadata->discriminatorColumn['nullable'] : false; } else { $nullable = false; } return array(new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, $class)); } return array(new Type(Type::BUILTIN_TYPE_OBJECT, false, 'Doctrine\\Common\\Collections\\Collection', true, new Type(Type::BUILTIN_TYPE_INT), new Type(Type::BUILTIN_TYPE_OBJECT, false, $class))); } if ($metadata->hasField($property)) { $typeOfField = $metadata->getTypeOfField($property); if ($metadata instanceof ClassMetadataInfo) { $nullable = $metadata->isNullable($property); } else { $nullable = false; } switch ($typeOfField) { case 'date': // No break // No break case 'datetime': // No break // No break case 'datetimetz': // No break // No break case 'time': return array(new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, 'DateTime')); case 'array': // No break // No break case 'simple_array': return array(new Type(Type::BUILTIN_TYPE_ARRAY, $nullable, null, true, new Type(Type::BUILTIN_TYPE_INT))); case 'json_array': return array(new Type(Type::BUILTIN_TYPE_ARRAY, $nullable, null, true)); default: return array(new Type($this->getPhpType($typeOfField), $nullable)); } } }
public function let(ManagerRegistry $managerRegistry, ObjectManager $objectManager, ClassMetadataFactory $metadataFactory, ClassMetadata $classMetadata, TranslatableListener $translatableListener, TranslatableMetadata $translatableMetadata, EntityRepository $entityRepository, TranslatableRepository $translatableRepository, ParamConverter $paramConverter) { $managerRegistry->getManagerForClass(Argument::type('string'))->willReturn($objectManager); $metadataFactory->isTransient(Argument::type('string'))->willReturn(false); $objectManager->getMetadataFactory()->willReturn($metadataFactory); $objectManager->getClassMetadata(Argument::type('string'))->willReturn($classMetadata); $objectManager->getRepository('NonTranslatableEntity')->willReturn($entityRepository); $objectManager->getRepository('TranslatableEntity')->willReturn($translatableRepository); $translatableListener->getExtendedMetadata($objectManager, Argument::type('string'))->willReturn($translatableMetadata); $paramConverter->getOptions()->willReturn(array()); $paramConverter->getName()->willReturn('object'); $this->beConstructedWith($managerRegistry, $translatableListener); }
/** * convert foreign identifiers into scalar foreign key values to avoid object to string conversion failures. * * @param \Doctrine\ORM\Mapping\ClassMetadata $class * @param array $id * @return array */ public function flattenIdentifier(ClassMetadata $class, array $id) { $flatId = array(); foreach ($id as $idField => $idValue) { if (isset($class->associationMappings[$idField]) && is_object($idValue)) { $targetClassMetadata = $this->metadataFactory->getMetadataFor($class->associationMappings[$idField]['targetEntity']); $associatedId = $this->unitOfWork->getEntityIdentifier($idValue); $flatId[$idField] = $associatedId[$targetClassMetadata->identifier[0]]; } else { $flatId[$idField] = $idValue; } } return $flatId; }
public function process(ClassMetadataFactory $factory, $data) { foreach ($factory->getAllMetadata() as $classMetadata) { $class = $classMetadata->getName(); $data['entities'][$class] = array('associations' => array(), 'fields' => array()); foreach ($classMetadata->fieldMappings as $name => $config) { $data['entities'][$class]['fields'][$name] = $config['type']; } // associations foreach ($classMetadata->getAssociationMappings() as $name => $mapping) { $field = $mapping['fieldName']; $targetEntity = $mapping['targetEntity']; $type = ''; switch ($mapping['type']) { case ClassMetadataInfo::ONE_TO_MANY: $type = 'one_to_many'; break; case ClassMetadataInfo::ONE_TO_ONE: $type = 'one_to_one'; break; case ClassMetadataInfo::MANY_TO_ONE: $type = 'many_to_one'; break; case ClassMetadataInfo::MANY_TO_MANY: $type = 'many_to_many'; break; default: throw new \RuntimeException('Unkown association type ' . $mapping['type']); } $label = $targetEntity; if ($type == 'one_to_many' || $type == 'many_to_many') { $label .= '[]'; } $data['entities'][$class]['associations'][$field] = $label; if ($mapping['sourceEntity'] === $mapping['targetEntity']) { continue; } $from = array($mapping['sourceEntity'], $field); $to = array($mapping['targetEntity'], '__class__'); foreach ($data['relations'] as $relation) { if ($relation['from'] === $from) { continue 2; } } $data['relations'][] = array('from' => $from, 'to' => $to, 'type' => $type); } } return $data; }
/** * @param array $data * * @return array */ private function mapFromSerialized(array $data) { $mappedEntityData = []; foreach ($data as $serializedName => $value) { if ($this->classMetadata->hasField($this->classMetadata->getFieldName($serializedName))) { $fieldName = $this->classMetadata->getFieldName($serializedName); $fieldMapping = $this->classMetadata->getFieldMapping($fieldName); if (isset($fieldMapping['association'])) { $embedded = []; $associationMetadata = $this->classMetadataFactory->getMetadataFor($fieldMapping['targetEntity']); $associationSerializer = new Serializer($associationMetadata, $this->unitOfWork, $this->classMetadataFactory); if ($fieldMapping['association'] === ClassMetadata::EMBED_ONE) { if (is_array($value)) { $associationData = $associationSerializer->mapFromSerialized($value); $associationSerializer->hydrateSingleEntity($associationData, $embedded); $value = reset($embedded); } else { $value = null; } } } else { $type = Type::getType($fieldMapping['type']); $value = $type->convertToPhpValue($value); } $mappedEntityData[$fieldName] = $value; } } return $mappedEntityData; }
/** * Get a proxy definition for the given class name. * * @return ProxyDefinition */ private function getProxyDefinition($className) { $classMetadata = $this->metadataFactory->getMetadataFor($className); $className = $classMetadata->getName(); // aliases and case sensitivity $this->definitions[$className] = $this->createProxyDefinition($className); $proxyClassName = $this->definitions[$className]->proxyClassName; if (!class_exists($proxyClassName, false)) { $fileName = $this->proxyGenerator->getProxyFileName($className); switch ($this->autoGenerate) { case self::AUTOGENERATE_NEVER: require $fileName; break; case self::AUTOGENERATE_FILE_NOT_EXISTS: if (!file_exists($fileName)) { $this->proxyGenerator->generateProxyClass($classMetadata, $fileName); } require $fileName; break; case self::AUTOGENERATE_ALWAYS: $this->proxyGenerator->generateProxyClass($classMetadata, $fileName); require $fileName; break; case self::AUTOGENERATE_EVAL: $this->proxyGenerator->generateProxyClass($classMetadata, false); break; } } return $this->definitions[$className]; }
/** * @param string $class * @return ClassMetadataInfo */ protected function getMetadata($class) { try { return $this->metadataFactory->getMetadataFor($class); } catch (MappingException $e) { // not an entity or mapped super class } }
/** * Builds a Hierarchy of every entity in the Class metadata. * @param ClassMetadataFactory $metadataFactory * @return MetadataNode[] */ protected function buildHierarchy(ClassMetadataFactory $metadataFactory) { $this->hierarchy = array(); $stack = new SplStack(); foreach ($metadataFactory->getAllMetadata() as $metadata) { $stack->push($metadata->getName()); } while (!$stack->isEmpty()) { $meta = $metadataFactory->getMetadataFor($stack->pop()); $name = $meta->getName(); $node = $this->getNode($name); $parent = $meta->getReflectionClass()->getParentClass(); if ($parent != null && $metadataFactory->hasMetadataFor($parent->getName())) { $parentNode = $this->getNode($metadataFactory->getMetadataFor($parent->getName())->getName()); $node->setParent($parentNode); $parentNode->addChild($node); } } return $this->hierarchy; }
public function process(ClassMetadataFactory $factory, $data) { foreach ($factory->getAllMetadata() as $classMetadata) { $actual = $classMetadata->getName(); $current = $classMetadata->getReflectionClass(); while (false !== ($current = $current->getParentClass())) { $name = $current->getName(); if (isset($data['entities'][$name])) { $data['relations'][] = array('from' => array($actual, '__class__'), 'to' => array($name, '__class__'), 'type' => 'extends'); break; } } // Inherited properties foreach ($classMetadata->getReflectionProperties() as $property) { $class = $property->getDeclaringClass()->getName(); $name = $property->getName(); if ($class !== $actual && isset($data['entities'][$class]['fields'][$name])) { unset($data['entities'][$actual]['fields'][$name]); } } } return $data; }
/** * Get a proxy definition for the given class name. * * @return ProxyDefinition */ private function getProxyDefinition($className) { $classMetadata = $this->metadataFactory->getMetadataFor($className); $className = $classMetadata->getName(); // aliases and case sensitivity $this->definitions[$className] = $this->createProxyDefinition($className); $proxyClassName = $this->definitions[$className]->proxyClassName; if (!class_exists($proxyClassName, false)) { $fileName = $this->proxyGenerator->getProxyFileName($className); if ($this->autoGenerate) { $this->proxyGenerator->generateProxyClass($classMetadata); } require $fileName; } return $this->definitions[$className]; }
/** * @covers \DoctrineORMModule\Collector\MappingCollector::serialize * @covers \DoctrineORMModule\Collector\MappingCollector::unserialize * @covers \DoctrineORMModule\Collector\MappingCollector::collect */ public function testSerializeUnserializeAndCollectWithNoMetadataFactory() { $m1 = $this->getMock('Doctrine\\Common\\Persistence\\Mapping\\ClassMetadata'); $m1->expects($this->any())->method('getName')->will($this->returnValue('M1')); $this->metadataFactory->expects($this->any())->method('getAllMetadata')->will($this->returnValue(array($m1))); $this->collector->collect($this->getMock('Zend\\Mvc\\MvcEvent')); /* @var $collector MappingCollector */ $collector = unserialize(serialize($this->collector)); $classes = $collector->getClasses(); $this->assertCount(1, $classes); $this->assertEquals($m1, $classes['M1']); $this->assertSame('test-collector', $collector->getName()); $collector->collect($this->getMock('Zend\\Mvc\\MvcEvent')); $classes = $collector->getClasses(); $this->assertCount(1, $classes); $this->assertEquals($m1, $classes['M1']); }
public function extractTypes(\ReflectionProperty $reflectionProperty) { $className = $reflectionProperty->getDeclaringClass()->getName(); try { $metadata = $this->classMetadataFactory->getMetadataFor($className); } catch (MappingException $exception) { return; } $type = new Type(); $propertyName = $reflectionProperty->getName(); if ($metadata->hasAssociation($propertyName)) { $class = $metadata->getAssociationTargetClass($propertyName); if ($metadata->isSingleValuedAssociation($propertyName)) { $type->setCollection(false); $type->setType('object'); $type->setClass($class); } else { $type->setCollection(true); $type->setType('object'); $type->setClass('Doctrine\\Common\\Collections\\Collection'); $collectionType = new Type(); $collectionType->setCollection(false); $collectionType->setType('object'); $collectionType->setClass($class); $type->setCollectionType($collectionType); } return [$type]; } if ($metadata->hasField($propertyName)) { $typeOfField = $metadata->getTypeOfField($propertyName); switch ($typeOfField) { case 'date': // No break // No break case 'datetime': // No break // No break case 'datetimetz': // No break // No break case 'time': $type->setType('object'); $type->setClass('DateTime'); $type->setCollection(false); return [$type]; case 'array': // No break // No break case 'simple_array': // No break // No break case 'json_array': $type->setType('array'); $type->setCollection(true); return [$type]; default: $type->setType($this->getPhpType($typeOfField)); $type->setCollection(false); return [$type]; } } }
/** * @param ClassMetadataFactory $factory * @param string $entityFQCN Class name * * @return mixed */ protected function getDiscriminatorValue(ClassMetadataFactory $factory, $entityFQCN) { if (!array_key_exists($entityFQCN, $this->collectedValues)) { $value = null; if ($factory->hasMetadataFor($entityFQCN)) { /** @var ClassMetadata $metadata */ $metadata = $factory->getMetadataFor($entityFQCN); $value = $metadata->discriminatorValue; } else { $ref = new \ReflectionClass($entityFQCN); $annotation = $this->annotationReader->getClassAnnotation($ref, self::ANNOTATION_DISCRIMINATOR_VALUE); if ($annotation instanceof DiscriminatorValue) { $value = $annotation->getValue(); } } $this->collectedValues[$entityFQCN] = $value; } return $this->collectedValues[$entityFQCN]; }
/** * Returns an array of all the loaded metadata currently in memory. * * @return ClassMetadata[] */ public function getLoadedMetadata() { return $this->wrapped->getLoadedMetadata(); }