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