public static function loadMetadata(ORM\ClassMetadata $metadata)
{
$builder = new ORM\Builder\ClassMetadataBuilder($metadata);
$builder->setTable('tasks');
$builder->createField('id', 'integer')->isPrimaryKey()->generatedValue()->build();
$builder->createField('name', 'string')->columnName('name')->build();
$builder->createField('dueDate', 'datetime')->columnName('due_date')->build();
$builder->createField('isCompleted', 'boolean')->columnName('is_completed')->build();
$builder->createField('dateAdded', 'datetime')->columnName('date_added')->build();
$builder->createField('dateCompleted', 'datetime')->columnName('date_completed')->nullable()->build();
$builder->createManyToOne('lead', 'Mautic\\LeadBundle\\Entity\\Lead')->addJoinColumn('lead_id', 'id', true, false, 'CASCADE')->build();
$builder->createManyToOne('assignUser', 'Mautic\\UserBundle\\Entity\\User')->addJoinColumn('assign_user_id', 'id', true, false, 'CASCADE')->build();
}
/**
* @param ClassMetadataBuilder $metadataBuilder
* @param FieldConfigId $fieldId
* @param string $targetEntity
* @param FieldConfigId|null $targetFieldId
* @param string[] $cascade
*/
protected function buildManyToOneRelation(ClassMetadataBuilder $metadataBuilder, FieldConfigId $fieldId, $targetEntity, FieldConfigId $targetFieldId = null, array $cascade = [])
{
$builder = $metadataBuilder->createManyToOne($fieldId->getFieldName(), $targetEntity);
if ($targetFieldId) {
$builder->inversedBy($targetFieldId->getFieldName());
}
$builder->addJoinColumn($this->nameGenerator->generateManyToOneRelationColumnName($fieldId->getFieldName()), 'id', true, false, 'SET NULL');
foreach ($cascade as $cascadeType) {
$builder->{'cascade' . ucfirst($cascadeType)}();
}
$builder->build();
}
/**
* @param ConfigInterface $config
* @param ClassMetadataBuilder $cmBuilder
*/
protected function prepareRelations(ConfigInterface $config, ClassMetadataBuilder $cmBuilder)
{
if ($config->is('relation')) {
foreach ($config->get('relation') as $relation) {
/** @var FieldConfigId $fieldId */
if ($relation['assign'] && ($fieldId = $relation['field_id'])) {
/** @var FieldConfigId $targetFieldId */
$targetFieldId = $relation['target_field_id'];
$targetFieldName = $targetFieldId ? ExtendConfigDumper::FIELD_PREFIX . $targetFieldId->getFieldName() : null;
$fieldName = ExtendConfigDumper::FIELD_PREFIX . $fieldId->getFieldName();
$defaultName = ExtendConfigDumper::DEFAULT_PREFIX . $fieldId->getFieldName();
switch ($fieldId->getFieldType()) {
case 'manyToOne':
$builder = $cmBuilder->createManyToOne($fieldName, $relation['target_entity']);
if ($targetFieldName) {
$builder->inversedBy($targetFieldName);
}
$builder->addJoinColumn($fieldName . '_id', 'id', true, false, 'SET NULL');
$builder->cascadeDetach();
$builder->build();
break;
case 'oneToMany':
/** create 1:* */
$builder = $cmBuilder->createOneToMany($fieldName, $relation['target_entity']);
$builder->mappedBy($targetFieldName);
$builder->cascadeDetach();
$builder->build();
/** create 1:1 default */
$builder = $cmBuilder->createOneToOne($defaultName, $relation['target_entity']);
$builder->addJoinColumn($defaultName . '_id', 'id', true, false, 'SET NULL');
$builder->build();
break;
case 'manyToMany':
if ($relation['owner']) {
$builder = $cmBuilder->createManyToMany($fieldName, $relation['target_entity']);
if ($targetFieldName) {
$builder->inversedBy($targetFieldName);
}
$builder->setJoinTable(ExtendHelper::generateManyToManyJoinTableName($fieldId, $relation['target_entity']));
$builder->build();
$builder = $cmBuilder->createOneToOne($defaultName, $relation['target_entity']);
$builder->addJoinColumn($defaultName . '_id', 'id', true, false, 'SET NULL');
$builder->build();
} else {
$cmBuilder->addInverseManyToMany($fieldName, $relation['target_entity'], $targetFieldName);
}
break;
}
}
}
}
}
/**
* @param ClassMetadataBuilder $metadataBuilder
* @param FieldConfigId $fieldId
* @param array $relation
*/
protected function buildManyToOneRelation(ClassMetadataBuilder $metadataBuilder, FieldConfigId $fieldId, array $relation)
{
$targetEntity = $relation['target_entity'];
$cascade = !empty($relation['cascade']) ? $relation['cascade'] : [];
$cascade[] = 'detach';
$builder = $metadataBuilder->createManyToOne($fieldId->getFieldName(), $targetEntity);
if (!empty($relation['target_field_id'])) {
$builder->inversedBy($relation['target_field_id']->getFieldName());
}
$builder->addJoinColumn($this->getManyToOneColumnName($fieldId), 'id', true, false, 'SET NULL');
foreach ($cascade as $cascadeType) {
$builder->{'cascade' . ucfirst($cascadeType)}();
}
$builder->build();
}
/**
* Loads the metadata for the specified class into the provided container.
*
* @param string $className
* @param ClassMetadata $metadata
*/
function loadMetadataForClass($className, ClassMetadata $metadata)
{
$moduleOptions = \SoliantEntityAudit\Module::getModuleOptions();
$entityManager = $moduleOptions->getEntityManager();
$metadataFactory = $entityManager->getMetadataFactory();
$builder = new ClassMetadataBuilder($metadata);
if ($className == 'SoliantEntityAudit\\Entity\\RevisionEntity') {
$builder->createField('id', 'integer')->isPrimaryKey()->generatedValue()->build();
$builder->addManyToOne('revision', 'SoliantEntityAudit\\Entity\\Revision', 'revisionEntities');
$builder->addField('entityKeys', 'string');
$builder->addField('auditEntityClass', 'string');
$builder->addField('targetEntityClass', 'string');
$builder->addField('revisionType', 'string');
$builder->addField('title', 'string', array('nullable' => true));
$metadata->setTableName($moduleOptions->getRevisionEntityTableName());
return;
}
// Revision is managed here rather than a separate namespace and driver
if ($className == 'SoliantEntityAudit\\Entity\\Revision') {
$builder->createField('id', 'integer')->isPrimaryKey()->generatedValue()->build();
$builder->addField('comment', 'text', array('nullable' => true));
$builder->addField('timestamp', 'datetime');
// Add association between RevisionEntity and Revision
$builder->addOneToMany('revisionEntities', 'SoliantEntityAudit\\Entity\\RevisionEntity', 'revision');
// Add assoication between User and Revision
$userMetadata = $metadataFactory->getMetadataFor($moduleOptions->getUserEntityClassName());
$builder->createManyToOne('user', $userMetadata->getName())->addJoinColumn('user_id', $userMetadata->getSingleIdentifierColumnName())->build();
$metadata->setTableName($moduleOptions->getRevisionTableName());
return;
}
# $builder->createField('audit_id', 'integer')->isPrimaryKey()->generatedValue()->build();
$identifiers = array();
# $metadata->setIdentifier(array('audit_id'));
// Build a discovered many to many join class
$joinClasses = $moduleOptions->getJoinClasses();
if (in_array($className, array_keys($joinClasses))) {
$builder->createField('id', 'integer')->isPrimaryKey()->generatedValue()->build();
$builder->addManyToOne('targetRevisionEntity', 'SoliantEntityAudit\\Entity\\RevisionEntity');
$builder->addManyToOne('sourceRevisionEntity', 'SoliantEntityAudit\\Entity\\RevisionEntity');
$metadata->setTableName($moduleOptions->getTableNamePrefix() . $joinClasses[$className]['joinTable']['name'] . $moduleOptions->getTableNameSuffix());
// $metadata->setIdentifier($identifiers);
return;
}
// Get the entity this entity audits
$metadataClassName = $metadata->getName();
$metadataClass = new $metadataClassName();
$auditedClassMetadata = $metadataFactory->getMetadataFor($metadataClass->getAuditedEntityClass());
try {
$builder->addManyToOne($moduleOptions->getRevisionEntityFieldName(), 'SoliantEntityAudit\\Entity\\RevisionEntity');
} catch (MappingException $e) {
// do nothing
}
// Compound keys removed in favor of auditId (audit_id)
$identifiers[] = $moduleOptions->getRevisionEntityFieldName();
// Add fields from target to audit entity
foreach ($auditedClassMetadata->getFieldNames() as $fieldName) {
$fieldMapping = $auditedClassMetadata->getFieldMapping($fieldName);
if (!isset($fieldMapping['inherited']) && !isset($fieldMapping['declared'])) {
$fieldMapping['nullable'] = true;
$fieldMapping['quoted'] = true;
$builder->addField($fieldName, $auditedClassMetadata->getTypeOfField($fieldName), $fieldMapping);
}
if ($auditedClassMetadata->isIdentifier($fieldName)) {
$identifiers[] = $fieldName;
}
}
foreach ($auditedClassMetadata->getAssociationMappings() as $mapping) {
if (!isset($mapping['inherited']) && !isset($mapping['declared'])) {
if (!$mapping['isOwningSide']) {
continue;
}
if (isset($mapping['joinTable'])) {
continue;
}
if (isset($mapping['joinTableColumns'])) {
foreach ($mapping['joinTableColumns'] as $field) {
$builder->addField($mapping['fieldName'], 'integer', array('nullable' => true, 'columnName' => $field));
}
} elseif (isset($mapping['joinColumnFieldNames'])) {
foreach ($mapping['joinColumnFieldNames'] as $field) {
$builder->addField($mapping['fieldName'], 'integer', array('nullable' => true, 'columnName' => $field));
}
} else {
throw new \Exception('Unhandled association mapping');
}
}
}
if ($auditedClassMetadata->isInheritanceTypeJoined() || $auditedClassMetadata->isInheritanceTypeSingleTable()) {
$metadata->setInheritanceType($auditedClassMetadata->inheritanceType);
$metadata->setDiscriminatorColumn($auditedClassMetadata->discriminatorColumn);
$parentAuditClasses = array();
$subAuditClasses = array();
foreach ($auditedClassMetadata->parentClasses as $idx => $parentClass) {
$parentAuditClass = 'SoliantEntityAudit\\Entity\\' . str_replace('\\', '_', $parentClass);
$parentAuditClasses[$idx] = $parentAuditClass;
}
$metadata->setParentClasses($parentAuditClasses);
foreach ($auditedClassMetadata->subClasses as $idx => $subClass) {
$subAuditClass = 'SoliantEntityAudit\\Entity\\' . str_replace('\\', '_', $subClass);
$subAuditClasses[$idx] = $subAuditClass;
}
$metadata->setSubClasses($subAuditClasses);
foreach ($auditedClassMetadata->discriminatorMap as $mapName => $mapClass) {
$mapAuditClass = 'SoliantEntityAudit\\Entity\\' . str_replace('\\', '_', $mapClass);
$metadata->addDiscriminatorMapClass($mapName, $mapAuditClass);
}
}
$metadata->setPrimaryTable(array('name' => $moduleOptions->getTableNamePrefix() . $auditedClassMetadata->getTableName() . $moduleOptions->getTableNameSuffix()));
$metadata->setIdentifier($identifiers);
return;
}
public function testCreateManyToOne()
{
$this->assertIsFluent($this->builder->createManyToOne('groups', 'Doctrine\\Tests\\Models\\CMS\\CmsGroup')->addJoinColumn('group_id', 'id', true, false, 'CASCADE')->cascadeAll()->fetchExtraLazy()->build());
$this->assertEquals(array('groups' => array('fieldName' => 'groups', 'targetEntity' => 'Doctrine\\Tests\\Models\\CMS\\CmsGroup', 'cascade' => array(0 => 'remove', 1 => 'persist', 2 => 'refresh', 3 => 'merge', 4 => 'detach'), 'fetch' => 4, 'joinColumns' => array(0 => array('name' => 'group_id', 'referencedColumnName' => 'id', 'nullable' => true, 'unique' => false, 'onDelete' => 'CASCADE', 'columnDefinition' => NULL)), 'type' => 2, 'mappedBy' => NULL, 'inversedBy' => NULL, 'isOwningSide' => true, 'sourceEntity' => 'Doctrine\\Tests\\Models\\CMS\\CmsUser', 'isCascadeRemove' => true, 'isCascadePersist' => true, 'isCascadeRefresh' => true, 'isCascadeMerge' => true, 'isCascadeDetach' => true, 'sourceToTargetKeyColumns' => array('group_id' => 'id'), 'joinColumnFieldNames' => array('group_id' => 'group_id'), 'targetToSourceKeyColumns' => array('id' => 'group_id'), 'orphanRemoval' => false)), $this->cm->associationMappings);
}
/**
* Loads the metadata for the specified class into the provided container.
*
* @param string $className
* @param ClassMetadata $metadata
*/
function loadMetadataForClass($className, ClassMetadata $metadata)
{
$moduleOptions = \ZF\Doctrine\Audit\Module::getModuleOptions();
$entityManager = $moduleOptions->getEntityManager();
$metadataFactory = $entityManager->getMetadataFactory();
$builder = new ClassMetadataBuilder($metadata);
if ($className == 'ZF\\Doctrine\\Audit\\Entity\\RevisionEntity') {
$builder->createField('id', 'integer')->isPrimaryKey()->generatedValue()->build();
$builder->addManyToOne('revision', 'ZF\\Doctrine\\Audit\\Entity\\Revision', 'revisionEntities');
$builder->addField('entityKeys', 'string');
$builder->addField('auditEntityClass', 'string');
$builder->addField('targetEntityClass', 'string');
$builder->addField('revisionType', 'string');
$builder->addField('title', 'string', array('nullable' => true));
$metadata->setTableName($moduleOptions->getRevisionEntityTableName());
return;
}
// Revision is managed here rather than a separate namespace and driver
if ($className == 'ZF\\Doctrine\\Audit\\Entity\\Revision') {
$builder->createField('id', 'integer')->isPrimaryKey()->generatedValue()->build();
$builder->addField('comment', 'text', array('nullable' => true));
$builder->addField('timestamp', 'datetime');
// Add association between RevisionEntity and Revision
$builder->addOneToMany('revisionEntities', 'ZF\\Doctrine\\Audit\\Entity\\RevisionEntity', 'revision');
// Add assoication between User and Revision
$userMetadata = $metadataFactory->getMetadataFor($moduleOptions->getUserEntityClassName());
$builder->createManyToOne('user', $userMetadata->getName())->addJoinColumn('user_id', $userMetadata->getSingleIdentifierColumnName())->build();
$metadata->setTableName($moduleOptions->getRevisionTableName());
return;
}
# $builder->createField('audit_id', 'integer')->isPrimaryKey()->generatedValue()->build();
$identifiers = array();
# $metadata->setIdentifier(array('audit_id'));
// Build a discovered many to many join class
$joinClasses = $moduleOptions->getJoinClasses();
if (in_array($className, array_keys($joinClasses))) {
$builder->createField('id', 'integer')->isPrimaryKey()->generatedValue()->build();
$builder->addManyToOne('targetRevisionEntity', 'ZF\\Doctrine\\Audit\\Entity\\RevisionEntity');
$builder->addManyToOne('sourceRevisionEntity', 'ZF\\Doctrine\\Audit\\Entity\\RevisionEntity');
$metadata->setTableName($moduleOptions->getTableNamePrefix() . $joinClasses[$className]['joinTable']['name'] . $moduleOptions->getTableNameSuffix());
// $metadata->setIdentifier($identifiers);
return;
}
// Get the entity this entity audits
$metadataClassName = $metadata->getName();
$metadataClass = new $metadataClassName();
$auditedClassMetadata = $metadataFactory->getMetadataFor($metadataClass->getAuditedEntityClass());
$builder->addManyToOne($moduleOptions->getRevisionEntityFieldName(), 'ZF\\Doctrine\\Audit\\Entity\\RevisionEntity');
# Compound keys removed in favor of auditId (audit_id)
$identifiers[] = $moduleOptions->getRevisionEntityFieldName();
// Add fields from target to audit entity
foreach ($auditedClassMetadata->getFieldNames() as $fieldName) {
$builder->addField($fieldName, $auditedClassMetadata->getTypeOfField($fieldName), array('nullable' => true, 'quoted' => true));
if ($auditedClassMetadata->isIdentifier($fieldName)) {
$identifiers[] = $fieldName;
}
}
foreach ($auditedClassMetadata->getAssociationMappings() as $mapping) {
if (!$mapping['isOwningSide']) {
continue;
}
if (isset($mapping['joinTable'])) {
continue;
}
if (isset($mapping['joinTableColumns'])) {
foreach ($mapping['joinTableColumns'] as $field) {
$builder->addField($mapping['fieldName'], 'integer', array('nullable' => true, 'columnName' => $field));
}
} elseif (isset($mapping['joinColumnFieldNames'])) {
foreach ($mapping['joinColumnFieldNames'] as $field) {
$builder->addField($mapping['fieldName'], 'integer', array('nullable' => true, 'columnName' => $field));
}
} else {
throw new \Exception('Unhandled association mapping');
}
}
$metadata->setTableName($moduleOptions->getTableNamePrefix() . $auditedClassMetadata->getTableName() . $moduleOptions->getTableNameSuffix());
$metadata->setIdentifier($identifiers);
return;
}
protected function setUp()
{
$this->builder = new ClassMetadataBuilder(new ClassMetadataInfo(StubEntity::class));
$this->builder->addOwningManyToMany('manyToMany', StubEntity::class);
$this->builder->createManyToOne('manyToOne', StubEntity::class)->build();
}
/**
* @param ClassMetadataBuilder $metadataBuilder
* @param FieldConfigId $fieldId
* @param string $targetEntity
*/
protected function buildDefaultRelation(ClassMetadataBuilder $metadataBuilder, FieldConfigId $fieldId, $targetEntity)
{
$builder = $metadataBuilder->createManyToOne(ExtendConfigDumper::DEFAULT_PREFIX . $fieldId->getFieldName(), $targetEntity);
$builder->addJoinColumn($this->nameGenerator->generateRelationDefaultColumnName($fieldId->getFieldName()), 'id', true, false, 'SET NULL');
$builder->build();
}
public function testExceptionOnOrphanRemovalOnManyToOne()
{
$this->setExpectedException('Doctrine\\ORM\\Mapping\\MappingException');
$this->builder->createManyToOne('groups', 'Doctrine\\Tests\\Models\\CMS\\CmsGroup')->addJoinColumn('group_id', 'id', true, false, 'CASCADE')->orphanRemoval()->build();
}
