/**
* 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();
}
