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