/** {@inheritdoc} */
public function getAssociationMapping($name)
{
if (!$this->classMetadata->hasAssociation($name)) {
throw new MetadataException("Association '{$name}' not found in class '{$this->getClass()}'.");
}
return $this->classMetadata->getAssociationMapping($name);
}
public function test_custom_region_gets_set_on_the_meta_data_on_build()
{
$cache = $this->factory('READ_ONLY', 'custom_region');
$cache->build();
$mapping = $this->metadata->getAssociationMapping($this->field);
$this->assertEquals('custom_region', $mapping['cache']['region']);
}
public function testClassMetadataInstanceSerialization()
{
$cm = new ClassMetadata('Doctrine\\Tests\\Models\\CMS\\CmsUser');
// Test initial state
$this->assertTrue(count($cm->getReflectionProperties()) == 0);
$this->assertTrue($cm->reflClass instanceof \ReflectionClass);
$this->assertEquals('Doctrine\\Tests\\Models\\CMS\\CmsUser', $cm->name);
$this->assertEquals('Doctrine\\Tests\\Models\\CMS\\CmsUser', $cm->rootEntityName);
$this->assertEquals(array(), $cm->subClasses);
$this->assertEquals(array(), $cm->parentClasses);
// Customize state
$cm->setSubclasses(array("One", "Two", "Three"));
$cm->setParentClasses(array("UserParent"));
$cm->setCustomRepositoryClass("UserRepository");
$cm->setDiscriminatorColumn(array('name' => 'disc', 'type' => 'integer'));
$cm->mapOneToOne(array('fieldName' => 'phonenumbers', 'targetEntity' => 'Bar', 'mappedBy' => 'foo'));
$this->assertTrue($cm->getAssociationMapping('phonenumbers') instanceof \Doctrine\ORM\Mapping\OneToOneMapping);
$this->assertEquals(1, count($cm->associationMappings));
$serialized = serialize($cm);
$cm = unserialize($serialized);
// Check state
$this->assertTrue(count($cm->getReflectionProperties()) > 0);
$this->assertTrue($cm->reflClass instanceof \ReflectionClass);
$this->assertEquals('Doctrine\\Tests\\Models\\CMS\\CmsUser', $cm->name);
$this->assertEquals('UserParent', $cm->rootEntityName);
$this->assertEquals(array('One', 'Two', 'Three'), $cm->subClasses);
$this->assertEquals(array('UserParent'), $cm->parentClasses);
$this->assertEquals('UserRepository', $cm->getCustomRepositoryClass());
$this->assertEquals(array('name' => 'disc', 'type' => 'integer'), $cm->discriminatorColumn);
$this->assertTrue($cm->getAssociationMapping('phonenumbers') instanceof \Doctrine\ORM\Mapping\OneToOneMapping);
$this->assertEquals(1, count($cm->associationMappings));
$oneOneMapping = $cm->getAssociationMapping('phonenumbers');
$this->assertEquals('phonenumbers', $oneOneMapping->getSourceFieldName());
$this->assertEquals('Doctrine\\Tests\\Models\\CMS\\Bar', $oneOneMapping->getTargetEntityName());
}
/**
* @param string $association
* @return array
* @throws InvalidAssociationException
*/
protected function getAssociationMapping($association)
{
try {
return $this->metadata->getAssociationMapping($association);
} catch (MappingException $e) {
throw InvalidAssociationException::associationNotExist($this->entity, $association, $e);
}
}
/**
* {@inheritdoc}
*/
public function isIgnoredRelation(ClassMetadata $metadata, $associationName)
{
$mapping = $metadata->getAssociationMapping($associationName);
if (!$mapping['isOwningSide'] || !($mapping['type'] & ClassMetadata::TO_ONE)) {
return false;
}
return $associationName === 'workflowItem' || $associationName === 'workflowStep';
}
/**
* Gibt das Property für eine Objekt-Fremd-Beziehung zurück
*
* dies ist z.B. bei der ManyToOne Seite möglich
* @return Psc\CMS\EntityPropertyMeta
*/
public function getForeignPropertyMeta(EntityMeta $foreignEntity)
{
throw new \Psc\Code\NotImplementedException();
$foreignField = \Psc\Inflector::create()->propertyName($foreignEntity->getGClass()->getClassName());
//var_dump($foreignEntity->getClassMetadata()->associationMappings);
//var_dump($this->classMetadata->associationMappings);
//var_dump($this->classMetadata->getFieldForColumn($foreignField));
$mapping = $this->classMetadata->getAssociationMapping();
//var_dump($mapping);
return $this->getPropertyMeta($mapping);
}
/**
* {@inheritdoc}
*/
public function isIgnoredRelation(ClassMetadata $metadata, $associationName)
{
if ($metadata->name !== 'Oro\\Bundle\\AttachmentBundle\\Entity\\Attachment') {
return false;
}
$mapping = $metadata->getAssociationMapping($associationName);
if (!$mapping['isOwningSide'] || !($mapping['type'] & ClassMetadata::MANY_TO_ONE)) {
return false;
}
return $associationName === ExtendHelper::buildAssociationName($mapping['targetEntity']);
}
public static function getAssociationMapping(ClassMetadata $classMetadata, $name, $type = NULL)
{
if (!$classMetadata->hasAssociation($name)) {
return NULL;
}
$mapping = $classMetadata->getAssociationMapping($name);
$type = $type ? (array) $type : NULL;
if ($type === NULL || in_array($mapping['type'], $type, TRUE)) {
return $mapping;
}
return NULL;
}
/**
* {@inheritdoc}
*/
public function isIgnoredRelation(ClassMetadata $metadata, $associationName)
{
if ($metadata->name !== 'Oro\\Bundle\\TrackingBundle\\Entity\\TrackingVisit') {
return false;
}
$mapping = $metadata->getAssociationMapping($associationName);
if (!$mapping['isOwningSide'] || !($mapping['type'] & ClassMetadata::MANY_TO_ONE)) {
return false;
}
$identifierEventAssociationName = ExtendHelper::buildAssociationName($mapping['targetEntity'], IdentifierEventExtension::ASSOCIATION_KIND);
return $associationName === $identifierEventAssociationName;
}
/**
* {@inheritdoc}
*/
public function isIgnoredRelation(ClassMetadata $metadata, $associationName)
{
if (!$this->configManager->hasConfig($metadata->name, $associationName)) {
return false;
}
$groups = $this->configManager->getEntityConfig('grouping', $metadata->name)->get('groups');
if (empty($groups) || !in_array(ActivityScope::GROUP_ACTIVITY, $groups, true)) {
return false;
}
$mapping = $metadata->getAssociationMapping($associationName);
if (!$mapping['isOwningSide'] || !($mapping['type'] & ClassMetadata::MANY_TO_MANY)) {
return false;
}
$activityAssociationName = ExtendHelper::buildAssociationName($mapping['targetEntity'], ActivityScope::ASSOCIATION_KIND);
return $associationName === $activityAssociationName;
}
/**
* Merge DoctrineClassMetadata and DataAuditClassMetadata
* @param DoctrineClassMetadata $doctrineClassMetadata
* @return null|ClassMetadata
* @throws \InvalidArgumentException
*/
public function extendLoadMetadataForClass(DoctrineClassMetadata $doctrineClassMetadata)
{
if ($doctrineClassMetadata->isMappedSuperclass || !($classMetadata = $this->loadMetadataForClass($doctrineClassMetadata->getReflectionClass()))) {
return null;
}
/** @var $property PropertyMetadata */
foreach ($classMetadata->propertyMetadata as $name => $property) {
if ($doctrineClassMetadata->isInheritedField($name) || isset($doctrineClassMetadata->associationMappings[$property->name]['inherited'])) {
unset($classMetadata->propertyMetadata[$name]);
continue;
}
if ($doctrineClassMetadata->isCollectionValuedAssociation($name)) {
$property->isCollection = true;
$targetMapping = $doctrineClassMetadata->getAssociationMapping($name);
if (!method_exists($targetMapping['targetEntity'], $property->method)) {
throw new \InvalidArgumentException(sprintf("Method %s in Class %s is not defined. Class must implement " . "a method '__toString' or configure getMethod with Versioned annotation", $property->method, $targetMapping['targetEntity']));
}
}
}
return $classMetadata;
}
private function getAssociationMetadata(ClassMetadata $meta, $associationName)
{
if (!$meta->hasAssociation($associationName)) {
return FALSE;
}
$association = $meta->getAssociationMapping($associationName);
if (!$association & ClassMetadata::TO_ONE) {
return FALSE;
}
return $association;
}
/**
* @param FormBuilder $form
* @param ClassMetadata $metaData
* @param string $fieldName
*/
public function createAssociationField($form, $metaData, $fieldName)
{
$formField = new SelectField(array());
$formField->setLabel($this->translateName($fieldName));
$formField->setName($fieldName);
$mapping = $metaData->getAssociationMapping($fieldName);
$required = false;
$targetEntityName = $metaData->getAssociationTargetClass($fieldName);
$targetEntity = $this->doctrineService->getRepository($targetEntityName);
if ($metaData->isCollectionValuedAssociation($fieldName)) {
$formField->setMultiple(true);
$formField->setRequired(false);
} else {
foreach ($mapping['joinColumns'] as $joinColumn) {
if (!$joinColumn['nullable']) {
$required = true;
break;
}
}
$formField->setRequired($required);
}
$collection = static::entityToCollection($targetEntity->findAll(), !$formField->isMultiple());
$formField->setCollection($collection);
$form->addField($formField);
}
/**
* @param EntityMetadata $entityMetadata
* @param ClassMetadata $classMetadata
*/
protected function addDoctrineAssociations(EntityMetadata $entityMetadata, ClassMetadata $classMetadata)
{
$associations = array_diff($classMetadata->getAssociationNames(), $this->getDeletedFields($classMetadata->name));
foreach ($associations as $fieldName) {
$fieldMetadata = $this->metadataFactory->createFieldMetadata(['field_name' => $fieldName], $classMetadata->getAssociationMapping($fieldName));
$entityMetadata->addFieldMetadata($fieldMetadata);
}
}
private function getFromClause(ClassMetadata $metadataActivity, ClassMetadata $metadataPerson)
{
$associationMapping = $metadataActivity->getAssociationMapping('person');
return $metadataActivity->getTableName() . ' JOIN ' . $metadataPerson->getTableName() . ' ON ' . $metadataPerson->getTableName() . '.' . $associationMapping['joinColumns'][0]['referencedColumnName'] . ' = ' . $associationMapping['joinColumns'][0]['name'];
}
/**
* @param ClassMetadata $metaData
* @param $fieldName
*
* @return array
*
* @throws MappingException
*/
protected function getAssociationTypeOptions(ClassMetadata $metaData, $fieldName)
{
$fieldInfo = $metaData->getAssociationMapping($fieldName);
$data = ['type' => 'entity'];
if ($fieldInfo['type'] === ClassMetadataInfo::MANY_TO_ONE || $fieldInfo['type'] === ClassMetadataInfo::ONE_TO_ONE) {
$data['options'] = ['class' => $fieldInfo['targetEntity'], 'choice_label' => $fieldInfo['joinColumns'][0]['referencedColumnName']];
}
if ($fieldInfo['type'] === ClassMetadataInfo::MANY_TO_MANY) {
$data['options'] = ['class' => $fieldInfo['targetEntity'], 'choice_label' => $fieldInfo['joinTable']['joinColumns'][0]['referencedColumnName'], 'multiple' => true];
}
return $data;
}
/**
* Get mappings.
*
* @param ClassMetadata $metadata
* @param array $fields
*
* @return array
* @throws MappingException
*/
protected function getMappings(ClassMetadata $metadata, array $fields)
{
$mappings = array();
foreach ($fields as $field) {
try {
// Gets the mapping of a regular field
$mappings[$field] = $metadata->getFieldMapping($field);
} catch (MappingException $e) {
// Gets the mapping of an association
$mappings[$field] = $metadata->getAssociationMapping($field);
}
}
return $mappings;
}
/**
* Gets a list of all indexed associations
*
* @param ClassMetadata $metadata
*
* @return array [field name => target field data-type, ...]
*/
public function getIndexedAssociations(ClassMetadata $metadata)
{
$relations = [];
$fieldNames = $metadata->getAssociationNames();
foreach ($fieldNames as $fieldName) {
$mapping = $metadata->getAssociationMapping($fieldName);
if ($mapping['type'] & ClassMetadata::TO_ONE) {
$targetMetadata = $this->getEntityMetadataForClass($mapping['targetEntity']);
$targetIdFieldNames = $targetMetadata->getIdentifierFieldNames();
if (count($targetIdFieldNames) === 1) {
$relations[$fieldName] = $targetMetadata->getTypeOfField(reset($targetIdFieldNames));
}
}
}
return $relations;
}
/**
* Transform a class entityMetadata object to a more user-friendly array
*
* @param ClassMetadata $metaData
* @return array
* @throws \Exception
*/
public function parseMetaDataToFieldArray(ClassMetadata $metaData)
{
$columns = array();
foreach (array_keys($metaData->reflFields) as $fieldName) {
if (array_key_exists($fieldName, $metaData->fieldMappings)) {
$fieldData = $metaData->getFieldMapping($fieldName);
$columns[$fieldName] = $fieldData;
} elseif (array_key_exists($fieldName, $metaData->associationMappings)) {
$fieldData = $metaData->getAssociationMapping($fieldName);
$fieldData['associationType'] = $fieldData['type'];
$fieldData['type'] = 'association';
$columns[$fieldName] = $fieldData;
} else {
throw new \Exception(sprintf('Can\'t map %s in the %s Entity', $fieldName, $metaData->name));
}
}
return $columns;
}
/**
* Handle an associative property field
* @param string $name - name of the field
* @param \Zend\Code\Generator\ClassGenerator $cg - The class generator object to attach to
* @param \Doctrine\ORM\Mapping\ClassMetadata $ormClassMetaData - The ORM class meta data
*/
private function handleAssocProperty($name, Generator\ClassGenerator &$cg, ORMClassMetadata $ormClassMetaData)
{
$assocMapping = $ormClassMetaData->getAssociationMapping($name);
$property = $this->createProperty($name);
if ($assocMapping['type'] & $ormClassMetaData::TO_MANY) {
// This is a collection (should be an Array)
$property->setDocBlock('@var array $' . $name);
$property->setDefaultValue(array());
$paramType = self::PARAM_TYPE_RELATION_COLLECTION;
} else {
// This is a single relation
$property->setDocBlock('@var ' . $assocMapping['targetEntity'] . ' $' . $name);
$paramType = self::PARAM_TYPE_RELATION_SINGLE;
}
if (!$cg->hasProperty($name)) {
$cg->addProperties(array($property));
$cg->addMethods($this->getSetterMethods($cg, $name, $paramType, $assocMapping['targetEntity']));
}
}
/**
* Maps ids of associations to references
*
* @param ClassMetadata $class
* @param string $field
* @param mixed $value
*/
protected function mapValue(ClassMetadata $class, $field, &$value)
{
if (!$class->isSingleValuedAssociation($field)) {
return;
}
$mapping = $class->getAssociationMapping($field);
$value = $value ? $this->em->getReference($mapping['targetEntity'], $value) : null;
}
/**
* @param ClassMetadata $targetEntityMetadata
* @return array
*/
protected function processIdentifier(ClassMetadata $targetEntityMetadata)
{
$identifierFields = $targetEntityMetadata->identifier;
$this->identifierFields = array_filter($identifierFields, function ($value) use($targetEntityMetadata) {
if (isset($targetEntityMetadata->associationMappings[$value])) {
$associationMapping = $targetEntityMetadata->getAssociationMapping($value);
return $this->wrappedEntity->getMetadata()->getName() != $associationMapping['targetEntity'];
}
return TRUE;
});
return $identifierFields;
}
public function getPropertyDoctrineAssociationMapping($property)
{
if ($this->orm_metadata->hasAssociation($property)) {
return $this->orm_metadata->getAssociationMapping($property);
}
}
/**
* Returns the mapping of an association
*
* @param string $fieldName
*
* @return array
*/
public function getAssociationMapping($fieldName)
{
return $this->metadata->getAssociationMapping($fieldName);
}
/**
* @param ClassMetadata $objectMeta
* @param string $field
* @param mixed $value
*/
protected function mapValue($om, ClassMetadata $objectMeta, $field, &$value)
{
if (!$objectMeta->isSingleValuedAssociation($field)) {
return;
}
$mapping = $objectMeta->getAssociationMapping($field);
$value = $value ? $om->getReference($mapping['targetEntity'], $value) : null;
}
/**
* @param Builder\Metadata $meta
* @param \Doctrine\ORM\Mapping\ClassMetadata $cm
*/
private function loadMeta(Builder\Metadata $meta, \Doctrine\ORM\Mapping\ClassMetadata $cm)
{
$type = null;
if ($cm->hasField($meta->name)) {
$map = $cm->getFieldMapping($meta->name);
$type = $map['type'];
switch ($type) {
case 'smallint':
case 'bigint':
$type = 'integer';
break;
default:
break;
}
if (!isset($map['nullable']) || $map['nullable'] === false && !isset($meta->conditions['required'])) {
$meta->conditions['required'] = true;
}
if (isset($map['length']) && $map['length'] && !isset($meta->conditions['maxLenght'])) {
$meta->conditions['maxLength'] = $map['length'];
}
if ($type === 'decimal' && isset($map['scale'])) {
$type = 'float';
$meta->custom['step'] = pow(10, -$map['scale']);
}
} elseif ($cm->hasAssociation($meta->name)) {
$map = $cm->getAssociationMapping($meta->name);
$type = $map['targetEntity'];
}
if (!$meta->type) {
$meta->type = $type;
}
}
/**
* @param ClassMetadata $metaData
* @param $fieldName
*
* @return array
*
* @throws MappingException
*/
protected function getAssociationTypeOptions(ClassMetadata $metaData, $fieldName)
{
$fieldInfo = $metaData->getAssociationMapping($fieldName);
$data = ['type' => 'entity'];
if ($fieldInfo['type'] == 2) {
$data['options'] = ['class' => $fieldInfo['targetEntity'], 'choice_label' => $fieldInfo['joinColumns'][0]['referencedColumnName']];
}
return $data;
}