/** * @param LoadClassMetadataEventArgs $eventArgs */ public function loadClassMetadata(LoadClassMetadataEventArgs $eventArgs) { if ($this->userClass !== false) { // the $metadata is the whole mapping info for this class $metadata = $eventArgs->getClassMetadata(); if ($metadata->getName() != self::ENTITY_CLASS) { return; } $em = $eventArgs->getEntityManager(); $userMetadata = $em->getClassMetadata($this->userClass); $namingStrategy = $eventArgs->getEntityManager()->getConfiguration()->getNamingStrategy(); $metadata->mapManyToOne(array('targetEntity' => $userMetadata->getName(), 'fieldName' => 'userLogged', 'joinColumns' => array(array('name' => 'user_id')))); } }
public function testLoadClassMetadataWithoutParent() { $this->loadClassMetadataEvent->getClassMetadata()->willReturn($this->classMetadata->reveal()); $this->classMetadata->getName()->willReturn(get_class($this->object->reveal())); $this->classMetadata->setCustomRepositoryClass('Sulu\\Bundle\\ContactBundle\\Entity\\ContactRepository')->shouldNotBeCalled(); $this->loadClassMetadataEvent->getEntityManager()->willReturn($this->entityManager->reveal()); $this->entityManager->getConfiguration()->willReturn($this->configuration->reveal()); $this->configuration->getNamingStrategy()->willReturn(null); /** @var \Doctrine\Common\Persistence\Mapping\Driver\MappingDriver $mappingDriver */ $mappingDriver = $this->prophesize('Doctrine\\Common\\Persistence\\Mapping\\Driver\\MappingDriver'); $this->configuration->getMetadataDriverImpl()->willReturn($mappingDriver->reveal()); $mappingDriver->getAllClassNames()->willReturn([get_class($this->parentObject->reveal())]); $mappingDriver->loadMetadataForClass(get_class($this->parentObject->reveal()), Argument::type('Doctrine\\ORM\\Mapping\\ClassMetadata'))->shouldBeCalled(); $this->subscriber->loadClassMetadata($this->loadClassMetadataEvent->reveal()); }
/** * @param LoadClassMetadataEventArgs $args */ public function loadClassMetadata(LoadClassMetadataEventArgs $args) { $this->em = $args->getEntityManager(); $this->meta = $args->getClassMetadata(); if (!$this->em->getConnection()->getWrappedConnection() instanceof AbstractConnection) { return; } if ($this->meta->customPersisterClassName === null) { $this->meta->setCustomPersisterClass(EntityPersister::class); } $this->markIndex(); foreach ($this->meta->fieldMappings as $property => &$mapping) { $this->remapIdentifier($property, $mapping); $this->remapVersion($property, $mapping); $this->markField($property, $mapping); } foreach ($this->meta->associationMappings as $property => &$mapping) { $this->remapAnyToOneAssociation($property, $mapping); $this->remapAnyToManyAssociation($property, $mapping); $this->remapManyToManyAssociation($property, $mapping); } if ($cache = $this->em->getMetadataFactory()->getCacheDriver()) { $cache->save($this->meta->name . '$CLASSMETADATA', $this->meta, null); } }
/** * Adds doctrine point type * * @param LoadClassMetadataEventArgs $eventArgs */ public function loadClassMetadata(LoadClassMetadataEventArgs $eventArgs) { $classMetadata = $eventArgs->getClassMetadata(); if (null === $classMetadata->reflClass) { return; } if ($this->isGeocodable($classMetadata)) { if (!Type::hasType('point')) { Type::addType('point', 'Knp\\DoctrineBehaviors\\DBAL\\Types\\PointType'); } $em = $eventArgs->getEntityManager(); $con = $em->getConnection(); // skip non-postgres platforms if (!$con->getDatabasePlatform() instanceof PostgreSqlPlatform && !$con->getDatabasePlatform() instanceof MySqlPlatform) { return; } // skip platforms with registerd stuff if (!$con->getDatabasePlatform()->hasDoctrineTypeMappingFor('point')) { $con->getDatabasePlatform()->registerDoctrineTypeMapping('point', 'point'); if ($con->getDatabasePlatform() instanceof PostgreSqlPlatform) { $em->getConfiguration()->addCustomNumericFunction('DISTANCE', 'Knp\\DoctrineBehaviors\\ORM\\Geocodable\\Query\\AST\\Functions\\DistanceFunction'); } } $classMetadata->mapField(['fieldName' => 'location', 'type' => 'point', 'nullable' => true]); } }
/** * @param LoadClassMetadataEventArgs $args */ public function loadClassMetadata(LoadClassMetadataEventArgs $args) { $evm = $args->getEntityManager()->getEventManager(); $this->resolveTargetEntities->addResolveTargetEntity("Bigfish\\Bundle\\CoreBundle\\Model\\TemplateInterface", "Bigfish\\Bundle\\CoreBundle\\Entity\\Template", array()); $this->resolveTargetEntities->addResolveTargetEntity("Bigfish\\Bundle\\CoreBundle\\Model\\RouteInterface", "Bigfish\\Bundle\\CoreBundle\\Entity\\Route", array()); $evm->addEventListener(Events::loadClassMetadata, $this->resolveTargetEntities); }
/** * @param LoadClassMetadataEventArgs $eventArgs */ public function loadClassMetadata(LoadClassMetadataEventArgs $eventArgs) { $em = $eventArgs->getEntityManager(); /** @var ClassMetadata $metadata */ $metadata = $eventArgs->getClassMetadata(); $wasMappedSuperclass = $metadata->isMappedSuperclass; $this->setIsMappedSuperclass($metadata); if (!$metadata->isMappedSuperclass) { $this->setCustomRepositoryClasses($metadata, $eventArgs->getEntityManager()->getConfiguration()); $this->setAssociationMappings($metadata, $eventArgs->getEntityManager()->getConfiguration()); $this->setFieldMappings($metadata, $eventArgs->getEntityManager()->getConfiguration(), $em); } else { $this->unsetAssociationMappings($metadata); $this->unsetFieldMappings($metadata, $wasMappedSuperclass); } }
public function loadClassMetadata(LoadClassMetadataEventArgs $args) { $classMetadata = $args->getClassMetadata(); if ($classMetadata->isInheritanceTypeSingleTable() && !$classMetadata->isRootEntity()) { // if we are in an inheritance hierarchy, only apply this once return; } $classMetadata->setTableName($this->prefix . $classMetadata->getTableName()); foreach ($classMetadata->getAssociationMappings() as $fieldName => $mapping) { if ($mapping['type'] == \Doctrine\ORM\Mapping\ClassMetadataInfo::MANY_TO_MANY) { $mappedTableName = $classMetadata->associationMappings[$fieldName]['joinTable']['name']; $classMetadata->associationMappings[$fieldName]['joinTable']['name'] = $this->prefix . $mappedTableName; } } if ($classMetadata->isIdGeneratorSequence()) { $newDefinition = $classMetadata->sequenceGeneratorDefinition; $newDefinition['sequenceName'] = $this->prefix . $newDefinition['sequenceName']; $classMetadata->setSequenceGeneratorDefinition($newDefinition); $em = $args->getEntityManager(); if (isset($classMetadata->idGenerator)) { $sequenceGenerator = new \Doctrine\ORM\Id\SequenceGenerator($em->getConfiguration()->getQuoteStrategy()->getSequenceName($newDefinition, $classMetadata, $em->getConnection()->getDatabasePlatform()), $newDefinition['allocationSize']); $classMetadata->setIdGenerator($sequenceGenerator); } } }
public function loadClassMetadata(LoadClassMetadataEventArgs $args) { $classMetadata = $args->getClassMetadata(); // Get class annotations $classAnnotations = $this->annotatonReader->getClassAnnotations($classMetadata->getReflectionClass()); // Search for WordpressTable annotation $found = false; foreach ($classAnnotations as $classAnnotation) { if ($classAnnotation instanceof WordpressTable) { $found = true; break; } } // Only apply to classes having WPTable annotation if (!$found) { return; } // set table prefix $prefix = $this->getPrefix($classMetadata->name, $args->getEntityManager()); $classMetadata->setPrimaryTable(array('name' => $prefix . $classMetadata->getTableName())); // set table prefix to associated entity // TODO: make sure prefix won't apply to user table foreach ($classMetadata->associationMappings as &$mapping) { if (isset($mapping['joinTable']) && !empty($mapping['joinTable'])) { $mapping['joinTable']['name'] = $prefix . $mapping['joinTable']['name']; } } }
/** * @param LoadClassMetadataEventArgs $args */ public function loadClassMetadata(LoadClassMetadataEventArgs $args) { $meta = $args->getClassMetadata(); if ($this->_l) { if (Strings::endsWith($meta->associationMappings[$this->_lName]['targetEntity'], '::dynamic')) { $meta->associationMappings[$this->_lName]['targetEntity'] = $this->getTargetEntity($meta->name, $this->_l); } return; } foreach ($meta->getAssociationNames() as $name) { if (!Strings::endsWith($meta->associationMappings[$name]['targetEntity'], '::dynamic')) { continue; } $em = $args->getEntityManager(); $target = $this->getTargetEntity($meta, $name); $this->_l = $meta->name; $this->_lName = $meta->associationMappings[$name]['inversedBy']; if (!$this->_lName) { $this->_lName = $meta->associationMappings[$name]['mappedBy']; } if ($this->_lName) { $targetMeta = $em->getClassMetadata($target); } $this->_l = FALSE; $meta->associationMappings[$name]['targetEntity'] = $target; if ($this->_lName) { $targetMeta->associationMappings[$this->_lName]['targetEntity'] = $meta->name; } } }
public function loadClassMetadata(LoadClassMetadataEventArgs $args) { $metadata = $args->getClassMetadata(); $user = '******'; $basicProfile = 'FOM\\UserBundle\\Entity\\BasicProfile'; $profile = $this->container->getParameter('fom_user.profile_entity'); if ($user == $metadata->getName()) { $metadata->mapOneToOne(array('fieldName' => 'profile', 'targetEntity' => $profile, 'mappedBy' => 'uid', 'cascade' => array('persist'))); } $connection = $args->getEntityManager()->getConnection(); $platform = $connection->getDatabasePlatform(); $uidColname = $connection->quoteIdentifier('uid'); if ($platform instanceof OraclePlatform) { $uidColname = strtoupper($uidColname); } elseif ($platform instanceof MySqlPlatform) { $uidColname = 'uid'; } // need to add metadata for the basic profile, else doctrine // will whine in many situations if ($profile == $metadata->getName() || $basicProfile == $metadata->getName()) { $metadata->setIdentifier(array('uid')); $metadata->setIdGenerator(new AssignedGenerator()); $metadata->mapOneToOne(array('fieldName' => 'uid', 'targetEntity' => $user, 'inversedBy' => 'profile', 'id' => true, 'joinColumns' => array(array('name' => $uidColname, 'referencedColumnName' => 'id')))); } }
/** * @param LoadClassMetadataEventArgs $event */ public function loadClassMetadata(LoadClassMetadataEventArgs $event) { // HOT FIX for PIM-3683, when using MongoDB with PIM some queries are executed before that the schema is created return; /** @var OroEntityManager $em */ $em = $event->getEntityManager(); $configProvider = $em->getExtendManager()->getConfigProvider(); $className = $event->getClassMetadata()->getName(); if ($configProvider->hasConfig($className)) { $config = $configProvider->getConfig($className); if ($config->is('is_extend')) { $cmBuilder = new ClassMetadataBuilder($event->getClassMetadata()); if ($config->is('index')) { foreach ($config->get('index') as $columnName => $enabled) { $fieldConfig = $configProvider->getConfig($className, $columnName); if ($enabled && !$fieldConfig->is('state', ExtendManager::STATE_NEW)) { $cmBuilder->addIndex(array(ExtendConfigDumper::FIELD_PREFIX . $columnName), 'oro_idx_' . $columnName); } } } $this->prepareRelations($config, $cmBuilder); } $em->getMetadataFactory()->setMetadataFor($className, $event->getClassMetadata()); } }
public function loadClassMetadata(LoadClassMetadataEventArgs $args) { $em = $args->getEntityManager(); $meta = $args->getClassMetadata(); $class = $meta->name; $rootClass = $meta->rootEntityName; $info = Chalk::info($class); $parentClasses = array_merge([$class], $meta->parentClasses); $repositoryClasses = []; foreach ($parentClasses as $parentClass) { $parentInfo = Chalk::info($parentClass); $repositoryClasses[] = $parentInfo->module->class . '\\Repository\\' . $parentInfo->local->class; } $repositoryClasses[] = 'Chalk\\Repository'; foreach ($repositoryClasses as $repositoryClass) { if (class_exists($repositoryClass)) { $meta->setCustomRepositoryClass($repositoryClass); break; } } if ($meta->discriminatorMap) { $meta->discriminatorMap = [Chalk::info($rootClass)->name => $rootClass]; $allClasses = $em->getConfiguration()->getMetadataDriverImpl()->getAllClassNames(); foreach ($allClasses as $allClass) { if (is_subclass_of($allClass, $rootClass)) { $meta->discriminatorMap[Chalk::info($allClass)->name] = $allClass; } if (is_subclass_of($allClass, $class) && !in_array($allClass, $meta->subClasses)) { $meta->subClasses[] = $allClass; } } } }
public function loadClassMetadata(LoadClassMetadataEventArgs $eventArgs) { /** @var ClassMetadata $metadata */ $metadata = $eventArgs->getClassMetadata(); // Transform Librinfo entities only if (strpos($metadata->getName(), "Librinfo\\") !== 0) { return; } $this->logger->debug("[NamingListener] Entering NamingListener for « loadClassMetadata » event"); $namingStrategy = $eventArgs->getEntityManager()->getConfiguration()->getNamingStrategy(); // create a FQDN for the representing table if ($namingStrategy->classToTableName($metadata->getName()) == $metadata->table['name']) { $metadata->table['name'] = $this->buildTableName($metadata->name); } // create a FQDN for the ManyToMany induced tables foreach ($metadata->associationMappings as $field => $mapping) { if ($mapping['type'] == ClassMetadataInfo::MANY_TO_MANY && $mapping['isOwningSide']) { if ($namingStrategy->classToTableName($mapping['joinTable']['name']) == $mapping['joinTable']['name']) { $rc = new \ReflectionClass($mapping['targetEntity']); $fqdn = $mapping['sourceEntity'] . '__' . $rc->getShortName(); $metadata->associationMappings[$field]['joinTable']['name'] = $this->buildTableName($fqdn); } } } $this->logger->debug("[NamingListener] Added table naming strategy to Entity", ['class' => $metadata->getName()]); }
/** * @param LoadClassMetadataEventArgs $args */ public function loadClassMetadata(LoadClassMetadataEventArgs $args) { $evm = $args->getEntityManager()->getEventManager(); $this->resolveTargetEntities->addResolveTargetEntity("Bigfish\\Bundle\\EavBundle\\Model\\ModuleInterface", "Bigfish\\Bundle\\EavBundle\\Entity\\Module", array()); $this->resolveTargetEntities->addResolveTargetEntity("Bigfish\\Bundle\\EavBundle\\Model\\ContainerInterface", "Bigfish\\Bundle\\EavBundle\\Entity\\Container", array()); $this->resolveTargetEntities->addResolveTargetEntity("Bigfish\\Bundle\\EavBundle\\Model\\FieldInterface", "Bigfish\\Bundle\\EavBundle\\Entity\\Field", array()); $evm->addEventListener(Events::loadClassMetadata, $this->resolveTargetEntities); }
/** * @param LoadClassMetadataEventArgs $args * * @return void */ public function loadClassMetadata(LoadClassMetadataEventArgs $args) { //in the installer if (!defined('MAUTIC_TABLE_PREFIX')) { return; } /** @var \Doctrine\ORM\Mapping\ClassMetadataInfo $classMetadata */ $classMetadata = $args->getClassMetadata(); // Do not re-apply the prefix in an inheritance hierarchy. if ($classMetadata->isInheritanceTypeSingleTable() && !$classMetadata->isRootEntity()) { return; } if (FALSE !== strpos($classMetadata->namespace, 'Mautic')) { //if in the installer, use the prefix set by it rather than what is cached $prefix = MAUTIC_TABLE_PREFIX; // Prefix indexes $uniqueConstraints = array(); if (isset($classMetadata->table['uniqueConstraints'])) { foreach ($classMetadata->table['uniqueConstraints'] as $name => $uc) { $uniqueConstraints[$prefix . $name] = $uc; } } $indexes = array(); if (isset($classMetadata->table['indexes'])) { foreach ($classMetadata->table['indexes'] as $name => $uc) { $indexes[$prefix . $name] = $uc; } } // Prefix the table $classMetadata->setPrimaryTable(array('name' => $prefix . $classMetadata->getTableName(), 'indexes' => $indexes, 'uniqueConstraints' => $uniqueConstraints)); foreach ($classMetadata->getAssociationMappings() as $fieldName => $mapping) { if ($mapping['type'] == \Doctrine\ORM\Mapping\ClassMetadataInfo::MANY_TO_MANY && isset($classMetadata->associationMappings[$fieldName]['joinTable']['name'])) { $mappedTableName = $classMetadata->associationMappings[$fieldName]['joinTable']['name']; $classMetadata->associationMappings[$fieldName]['joinTable']['name'] = $prefix . $mappedTableName; } } // Prefix sequences if supported by the DB platform if ($classMetadata->isIdGeneratorSequence()) { $newDefinition = $classMetadata->sequenceGeneratorDefinition; $newDefinition['sequenceName'] = $prefix . $newDefinition['sequenceName']; $classMetadata->setSequenceGeneratorDefinition($newDefinition); $em = $args->getEntityManager(); if (isset($classMetadata->idGenerator)) { $sequenceGenerator = new \Doctrine\ORM\Id\SequenceGenerator($em->getConfiguration()->getQuoteStrategy()->getSequenceName($newDefinition, $classMetadata, $em->getConnection()->getDatabasePlatform()), $newDefinition['allocationSize']); $classMetadata->setIdGenerator($sequenceGenerator); } } $reader = new AnnotationReader(); $class = $classMetadata->getReflectionClass(); $annotation = $reader->getClassAnnotation($class, 'Mautic\\CoreBundle\\Doctrine\\Annotation\\LoadClassMetadataCallback'); if (null !== $annotation) { if (method_exists($class->getName(), $annotation->functionName['value'])) { $func = $class->getName() . '::' . $annotation->functionName['value']; call_user_func($func, $args); } } } }
/** * @param LoadClassMetadataEventArgs $eventArgs */ public function loadClassMetadata(LoadClassMetadataEventArgs $eventArgs) { $metadata = $eventArgs->getClassMetadata(); $this->convertToEntityIfNeeded($metadata); if (!$metadata->isMappedSuperclass) { $this->setAssociationMappings($metadata, $eventArgs->getEntityManager()->getConfiguration()); } else { $this->unsetAssociationMappings($metadata); } }
public function loadClassMetadata(LoadClassMetadataEventArgs $args) { /** @var $metadata ClassMetadata */ $metadata = $args->getClassMetadata(); if ($metadata->getName() != self::COMMENT_ENTITY_PATH) { return; } $namingStrategy = $args->getEntityManager()->getConfiguration()->getNamingStrategy(); $metadata->mapManyToOne(array('targetEntity' => $this->resolveClass, 'fieldName' => 'comment_object', 'inversedBy' => "comments", 'joinColumn' => array('name' => $namingStrategy->joinKeyColumnName('comment_object'), 'referencedColumnName' => $namingStrategy->referenceColumnName(), 'nullable' => 'false'))); }
/** * @param LoadClassMetadataEventArgs $args */ public function loadClassMetadata(LoadClassMetadataEventArgs $args) { $evm = $args->getEntityManager()->getEventManager(); $this->resolveTargetEntities->addResolveTargetEntity("Bigfish\\Bundle\\MediaBundle\\Model\\AttachmentInterface", "Bigfish\\Bundle\\MediaBundle\\Entity\\Attachment", array()); $this->resolveTargetEntities->addResolveTargetEntity("Bigfish\\Bundle\\MediaBundle\\Model\\CategoryInterface", "Bigfish\\Bundle\\MediaBundle\\Entity\\Category", array()); $this->resolveTargetEntities->addResolveTargetEntity("Bigfish\\Bundle\\MediaBundle\\Model\\AttachmentImageCroppingInterface", "Bigfish\\Bundle\\MediaBundle\\Entity\\ImageCropping", array()); $this->resolveTargetEntities->addResolveTargetEntity("Bigfish\\Bundle\\MediaBundle\\Model\\ImageDimensionInterface", "Bigfish\\Bundle\\MediaBundle\\Entity\\ImageDimension", array()); $this->resolveTargetEntities->addResolveTargetEntity("Bigfish\\Bundle\\MediaBundle\\Model\\ImageInstanceInterface", "Bigfish\\Bundle\\MediaBundle\\Entity\\ImageInstance", array()); $evm->addEventListener(Events::loadClassMetadata, $this->resolveTargetEntities); }
function it_maps_values_one_to_many_association_from_the_attribute_model_to_the_attribute_value_model(LoadClassMetadataEventArgs $eventArgs, ClassMetadataInfo $metadata, EntityManager $entityManager, ClassMetadataFactory $classMetadataFactory) { $eventArgs->getEntityManager()->willReturn($entityManager); $entityManager->getMetadataFactory()->willReturn($classMetadataFactory); $eventArgs->getClassMetadata()->willReturn($metadata); $metadata->getName()->willReturn('Some\\App\\Product\\Entity\\Attribute'); $valuesMapping = ['fieldName' => 'values', 'targetEntity' => 'Some\\App\\Product\\Entity\\AttributeValue', 'mappedBy' => 'attribute']; $metadata->mapOneToMany($valuesMapping)->shouldBeCalled(); $this->loadClassMetadata($eventArgs); }
/** * Overrides the discriminator maps for class table inheritance for roles and authorizations. */ public function loadClassMetadata(LoadClassMetadataEventArgs $eventArgs) { /** @var ClassMetadata $metadata */ $metadata = $eventArgs->getClassMetadata(); if ($metadata->getName() === 'MyCLabs\\ACL\\Model\\Role') { $metadata->setDiscriminatorMap($this->roles); } if ($this->actionsClass !== null && $metadata->getName() === 'MyCLabs\\ACL\\Model\\Authorization') { $this->remapActions($metadata, $eventArgs->getEntityManager()->getMetadataFactory()); } }
/** * @param LoadClassMetadataEventArgs $event */ public function loadClassMetadata(LoadClassMetadataEventArgs $event) { /** @var ClassMetadataInfo $metadata */ $metadata = $event->getClassMetadata(); $this->process($metadata); if (!$metadata->isMappedSuperclass) { $this->setAssociationMappings($metadata, $event->getEntityManager()->getConfiguration()); } else { $this->unsetAssociationMappings($metadata); } }
function it_skips_mapping_configuration_if_metadata_name_is_not_different(ClassMetadataFactory $metadataFactory, ClassMetadataInfo $metadata, EntityManager $entityManager, LoadClassMetadataEventArgs $eventArguments) { $this->beConstructedWith(['reviewable' => ['subject' => 'AcmeBundle\\Entity\\ReviewableModel', 'review' => ['classes' => ['model' => 'AcmeBundle\\Entity\\BadReviewModel']], 'reviewer' => ['classes' => ['model' => 'AcmeBundle\\Entity\\ReviewerModel']]]]); $eventArguments->getClassMetadata()->willReturn($metadata); $eventArguments->getEntityManager()->willReturn($entityManager); $entityManager->getMetadataFactory()->willReturn($metadataFactory); $metadata->getName()->willReturn('AcmeBundle\\Entity\\ReviewModel'); $metadata->mapManyToOne(Argument::type('array'))->shouldNotBeCalled(); $metadata->mapManyToOne(Argument::type('array'))->shouldNotBeCalled(); $this->loadClassMetadata($eventArguments); }
/** * Event action to add the mapping to any entity using the context interface * * @param LoadClassMetadataEventArgs $eventArgs Doctrine event args */ public function loadClassMetadata(LoadClassMetadataEventArgs $eventArgs) { // Filter out metadata that is not using the context interface if (!in_array(self::CONTEXT_INTERFACE, class_implements($eventArgs->getClassMetadata()->getName()))) { return; } // Create a variable to the naming strategy for code clarity reasons $namingStrategy = $eventArgs->getEntityManager()->getConfiguration()->getNamingStrategy(); // Create a many to many mapping between the context entity and the instance entity $eventArgs->getClassMetadata()->mapManyToMany(array('targetEntity' => self::INSTANCE_ENTITY, 'fieldName' => 'workflowInstances', 'cascade' => array('persist'), 'joinTable' => array('name' => strtolower($namingStrategy->classToTableName($eventArgs->getClassMetadata()->getName())) . '__tyhand_workflow_instance', 'joinColumns' => array(array('name' => $namingStrategy->joinKeyColumnName($eventArgs->getClassMetadata()->getName()), 'referencedColumnName' => $namingStrategy->referenceColumnName(), 'onDelete' => 'CASCADE', 'onUpdate' => 'CASCADE')), 'inverseJoinColumns' => array(array('name' => 'workflow_instance_id', 'referencedColumnName' => $namingStrategy->referenceColumnName(), 'onDelete' => 'CASCADE', 'onUpdate' => 'CASCADE'))))); }
/** * @param LoadClassMetadataEventArgs $event */ public function loadClassMetadata(LoadClassMetadataEventArgs $event) { $classMetadata = $event->getClassMetadata(); $className = $classMetadata->getName(); /** @var ExtendMetadataBuilder $metadataBuilder */ $metadataBuilder = $this->metadataBuilderServiceLink->getService(); if ($metadataBuilder->supports($className)) { $classMetadataBuilder = new ClassMetadataBuilder($classMetadata); $metadataBuilder->build($classMetadataBuilder, $className); $event->getEntityManager()->getMetadataFactory()->setMetadataFor($className, $classMetadata); } }
/** * Load class metdata event * * @param LoadClassMetadataEventArgs $event */ public function loadClassMetadata(LoadClassMetadataEventArgs $event) { $entityManager = $event->getEntityManager(); $configuration = $entityManager->getConfiguration(); $driver = $configuration->getMetadataDriverImpl(); $classMetadata = $event->getClassMetadata(); // Name of the current class $class = $classMetadata->name; if ($classMetadata->isMappedSuperclass) { return; } // Create an array that'll store our sub class names $values = array(); // Build cache for classnames if not exists if (empty($this->allClassNamesCache)) { $this->allClassNamesCache = $driver->getAllClassNames(); } // Loop through all the registered entities foreach ($this->allClassNamesCache as $name) { // Reflect them try { $r = new \ReflectionClass($name); // and if it has a parent and the parent is our current entity if ($r->isSubclassOf($class)) { // now store the name of the sub class in the array. // we'll use the full class name as both the key and value for this. $values[$name] = $name; } } catch (\ReflectionException $e) { // Most likely the class doesn't exist or could not be loaded // Assume Doctrine will handle this issue later... continue; } } if (!empty($values)) { $values[$class] = $class; if (!$classMetadata->discriminatorColumn) { $classMetadata->setDiscriminatorColumn(array('name' => 'object_type', 'type' => 'string', 'length' => 1024)); } if ($classMetadata->inheritanceType == ClassMetadataInfo::INHERITANCE_TYPE_NONE) { $classMetadata->setInheritanceType(ClassMetadataInfo::INHERITANCE_TYPE_JOINED); } if (!empty($classMetadata->discriminatorMap)) { foreach ($classMetadata->discriminatorMap as $dName => $dClass) { if (in_array($dClass, $values)) { unset($values[$dClass]); } } $values = array_merge($classMetadata->discriminatorMap, $values); } $classMetadata->setDiscriminatorMap($values); } }
/** * Adds doctrine point, apoint type * * @param LoadClassMetadataEventArgs $eventArgs */ public function loadClassMetadata(LoadClassMetadataEventArgs $eventArgs) { $classMetadata = $eventArgs->getClassMetadata(); if (null === $classMetadata->reflClass) { return; } if ($this->isEntitySupported($classMetadata->reflClass)) { if (!Type::hasType('point')) { Type::addType('point', 'geodata\\DBAL\\Types\\PointType'); } $em = $eventArgs->getEntityManager(); $con = $em->getConnection(); // skip non-postgres platforms if (!$con->getDatabasePlatform() instanceof PostgreSqlPlatform) { return; } // skip platforms with registerd stuff if ($con->getDatabasePlatform()->hasDoctrineTypeMappingFor('point')) { return; } $con->getDatabasePlatform()->registerDoctrineTypeMapping('point', 'point'); } if ($this->isEntitySupported($classMetadata->reflClass)) { if (!Type::hasType('locpoint')) { Type::addType('locpoint', 'geodata\\DBAL\\Types\\LocPointType'); } $em = $eventArgs->getEntityManager(); $con = $em->getConnection(); // skip non-postgres platforms if (!$con->getDatabasePlatform() instanceof PostgreSqlPlatform) { return; } // skip platforms with registerd stuff if ($con->getDatabasePlatform()->hasDoctrineTypeMappingFor('locpoint')) { return; } $con->getDatabasePlatform()->registerDoctrineTypeMapping('locpoint', 'locpoint'); } }
/** * @param LoadClassMetadataEventArgs $eventArgs */ public function loadClassMetadata(LoadClassMetadataEventArgs $eventArgs) { $metadata = $eventArgs->getClassMetadata(); $metadataFactory = $eventArgs->getEntityManager()->getMetadataFactory(); foreach ($this->subjects as $subject => $class) { if ($class['attribute_value']['classes']['model'] === $metadata->getName()) { $this->mapSubjectOnAttributeValue($subject, $class['subject'], $metadata, $metadataFactory); $this->mapAttributeOnAttributeValue($class['attribute']['classes']['model'], $metadata, $metadataFactory); } if ($class['attribute']['classes']['model'] === $metadata->getName()) { $this->mapValuesOnAttribute($class['attribute_value']['classes']['model'], $metadata); } } }
/** * @param LoadClassMetadataEventArgs $args * * @return void */ public function loadClassMetadata(LoadClassMetadataEventArgs $args) { //in the installer if (!defined('MAUTIC_TABLE_PREFIX') && empty($this->tablePrefix)) { return; } elseif (empty($this->tablePrefix)) { $this->tablePrefix = MAUTIC_TABLE_PREFIX; } /** @var \Doctrine\ORM\Mapping\ClassMetadataInfo $classMetadata */ $classMetadata = $args->getClassMetadata(); // Do not re-apply the prefix in an inheritance hierarchy. if ($classMetadata->isInheritanceTypeSingleTable() && !$classMetadata->isRootEntity()) { return; } if (false !== strpos($classMetadata->namespace, 'Mautic')) { //if in the installer, use the prefix set by it rather than what is cached // Prefix indexes $uniqueConstraints = []; if (isset($classMetadata->table['uniqueConstraints'])) { foreach ($classMetadata->table['uniqueConstraints'] as $name => $uc) { $uniqueConstraints[$this->tablePrefix . $name] = $uc; } } $indexes = []; if (isset($classMetadata->table['indexes'])) { foreach ($classMetadata->table['indexes'] as $name => $uc) { $indexes[$this->tablePrefix . $name] = $uc; } } // Prefix the table $classMetadata->setPrimaryTable(['name' => $this->tablePrefix . $classMetadata->getTableName(), 'indexes' => $indexes, 'uniqueConstraints' => $uniqueConstraints]); foreach ($classMetadata->getAssociationMappings() as $fieldName => $mapping) { if ($mapping['type'] == \Doctrine\ORM\Mapping\ClassMetadataInfo::MANY_TO_MANY && isset($classMetadata->associationMappings[$fieldName]['joinTable']['name'])) { $mappedTableName = $classMetadata->associationMappings[$fieldName]['joinTable']['name']; $classMetadata->associationMappings[$fieldName]['joinTable']['name'] = $this->tablePrefix . $mappedTableName; } } // Prefix sequences if supported by the DB platform if ($classMetadata->isIdGeneratorSequence()) { $newDefinition = $classMetadata->sequenceGeneratorDefinition; $newDefinition['sequenceName'] = $this->tablePrefix . $newDefinition['sequenceName']; $classMetadata->setSequenceGeneratorDefinition($newDefinition); $em = $args->getEntityManager(); if (isset($classMetadata->idGenerator)) { $sequenceGenerator = new \Doctrine\ORM\Id\SequenceGenerator($em->getConfiguration()->getQuoteStrategy()->getSequenceName($newDefinition, $classMetadata, $em->getConnection()->getDatabasePlatform()), $newDefinition['allocationSize']); $classMetadata->setIdGenerator($sequenceGenerator); } } } }
/** * Adds mapping to the translatable and translations. * * @param LoadClassMetadataEventArgs $eventArgs The event arguments */ public function loadClassMetadata(LoadClassMetadataEventArgs $eventArgs) { $classMetadata = $eventArgs->getClassMetadata(); if (null === $classMetadata->reflClass) { return; } if ($this->isTranslatable($classMetadata)) { $this->mapTranslatable($classMetadata); } if ($this->isTranslation($classMetadata)) { $this->mapTranslation($classMetadata); $this->mapId($classMetadata, $eventArgs->getEntityManager()); } }
/** * @param LoadClassMetadataEventArgs $eventArgs */ public function loadClassMetadata(LoadClassMetadataEventArgs $eventArgs) { /** @var ClassMetadata $metadata */ $metadata = $eventArgs->getClassMetadata(); // if ($metadata->name == 'AppBundle\Entity\User') { $this->process($metadata, $eventArgs->getEntityManager()->getConfiguration()); // } // // if (!$metadata->isMappedSuperclass) { // $this->setAssociationMappings($metadata, $eventArgs->getEntityManager()->getConfiguration()); // } else { // $this->unsetAssociationMappings($metadata); // } }