/** * 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); }
/** * {@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; } } }
/** * @param string $className * * @return ClassMetadata * * @throws \Doctrine\Common\Persistence\Mapping\MappingException */ public function getMetadataFor($className) { if (isset($this->transformMetadata[$className])) { return $this->transformMetadata[$className]; } $class = $this->wrapped->getMetadataFor($className); if (in_array($className, $this->classNames)) { $class = $this->transformMetadata($class); $this->transformMetadata[$className] = $class; } return $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)); } } }
/** * 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; }
/** * 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 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; }
/** * @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; }
/** * 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]; }
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]; }