/** @inheritDoc */
public function setReferenceRepository(ReferenceRepository $referenceRepository)
{
$this->em->getEventManager()->removeEventListener($this->listener->getSubscribedEvents(), $this->listener);
$this->referenceRepository = $referenceRepository;
$this->listener = new ORMReferenceListener($this->referenceRepository);
$this->em->getEventManager()->addEventSubscriber($this->listener);
}
/**
* Boot the extensions
*/
public function boot()
{
foreach ($this->registry->getManagers() as $em) {
$this->em = $em;
$this->evm = $this->em->getEventManager();
$this->metadata = $this->em->getConfiguration();
$this->reader = $this->driverChain->getReader();
foreach ($this->extensions as $extension) {
$this->bootExtension($extension);
}
}
}
/**
* Boot the extensions
*/
public function boot()
{
foreach ($this->registry->getManagers() as $em) {
$this->em = $em;
$this->evm = $this->em->getEventManager();
$this->metadata = $this->em->getConfiguration();
$this->reader = $this->driverChain->getReader();
$hash = spl_object_hash($em);
if (!isset($this->subscribedExtensions[$hash])) {
$this->subscribedExtensions[$hash] = [];
}
foreach ($this->extensions as $extension) {
$this->bootExtension($extension);
}
}
}
/**
* Boot the extensions
*/
public function boot()
{
foreach ($this->registry->getManagers() as $em) {
$this->em = $em;
$this->chain = new MappingDriverChain();
$this->evm = $this->em->getEventManager();
$this->metadata = $this->em->getConfiguration();
$this->reader = method_exists($this->metadata->getMetadataDriverImpl(), 'getReader') ? $this->metadata->getMetadataDriverImpl()->getReader() : false;
if ($this->gedmo['enabled']) {
$this->bootGedmoExtensions($this->gedmo['namespace'], $this->gedmo['all']);
}
foreach ($this->extensions as $extenion) {
$this->bootExtension($extenion);
}
}
}
/**
* Initiates a row-by-row hydration.
*
* @param object $stmt
* @param object $resultSetMapping
* @param array $hints
*
* @return IterableResult
*/
public function iterate($stmt, $resultSetMapping, array $hints = array())
{
$this->_stmt = $stmt;
$this->_rsm = $resultSetMapping;
$this->_hints = $hints;
$evm = $this->_em->getEventManager();
$evm->addEventListener(array(Events::onClear), $this);
$this->prepare();
return new IterableResult($this);
}
/**
* {@inheritdoc}
*/
protected function setUp()
{
$this->connection = new MysqlPersistentConnection();
$params = $this->connection->getConnectionParams();
$config = Setup::createAnnotationMetadataConfiguration([__DIR__ . '/Entity'], true, null, null, false);
$this->em = EntityManager::create($params, $config);
$event_manager = $this->em->getEventManager();
// create tables in the database
$metadata = $this->em->getMetadataFactory()->getAllMetadata();
$schema_tool = new SchemaTool($this->em);
$schema_tool->createSchema($metadata);
// default doctrine annotation reader
$annotation_reader = new AnnotationReader();
// setup required providers
$mutation_metadata_provider = new EntityMutationMetadataProvider($annotation_reader);
$annotation_metadata_provider = new EntityAnnotationMetadataProvider($annotation_reader);
// pre flush event listener that uses the @Tracked annotation
$entity_changed_listener = new EntityChangedListener($annotation_metadata_provider, $mutation_metadata_provider);
$event_manager->addEventListener('preFlush', $entity_changed_listener);
$event_manager->addEventListener('prePersist', $entity_changed_listener);
$event_manager->addEventListener('entityChanged', $this);
$this->events = [];
}
/**
* Removes the RevisionListener from the EventManager
*/
public function disableRevisionListener()
{
foreach ($this->em->getEventManager()->getListeners() as $event => $listeners) {
foreach ($listeners as $hash => $listener) {
if ($listener instanceof RevisionListener) {
$this->revisionListener = $listener;
break 2;
}
}
}
if ($this->revisionListener) {
$this->revisionListener->setActive(false);
}
}
/**
* Removes the RevisionListener from the EventManager
*/
public function killRevisionListener()
{
$listenerInst = false;
foreach ($this->em->getEventManager()->getListeners() as $event => $listeners) {
foreach ($listeners as $hash => $listener) {
if ($listener instanceof RevisionListener) {
$listenerInst = $listener;
break 2;
}
}
}
if ($listenerInst) {
$this->em->getEventManager()->removeEventListener(array(Events::onFlush, Events::postPersist, Events::postUpdate, Events::postFlush, SoftDeleteableListener::PRE_SOFT_DELETE, SoftDeleteableListener::POST_SOFT_DELETE), $listenerInst);
}
}
/**
* Initializes a new UnitOfWork instance, bound to the given EntityManager.
*
* @param EntityManagerInterface $em
*/
public function __construct(EntityManagerInterface $em)
{
$this->em = $em;
$this->evm = $em->getEventManager();
$this->listenersInvoker = new ListenersInvoker($em);
$this->hasCache = $em->getConfiguration()->isSecondLevelCacheEnabled();
$this->identifierFlattener = new IdentifierFlattener($this, $em->getMetadataFactory());
$this->hydrationCompleteHandler = new HydrationCompleteHandler($this->listenersInvoker, $em);
$this->reflectionPropertiesGetter = new ReflectionPropertiesGetter(new RuntimeReflectionService());
}
/**
* {@inheritDoc}
*/
protected function initialize()
{
$this->driver = $this->em->getConfiguration()->getMetadataDriverImpl();
$this->evm = $this->em->getEventManager();
$this->initialized = true;
}
/**
* Creates a Schema instance from a given set of metadata classes.
*
* @param array $classes
*
* @return Schema
*
* @throws \Doctrine\ORM\ORMException
*/
public function getSchemaFromMetadata(array $classes)
{
// Reminder for processed classes, used for hierarchies
$processedClasses = array();
$eventManager = $this->em->getEventManager();
$schemaManager = $this->em->getConnection()->getSchemaManager();
$metadataSchemaConfig = $schemaManager->createSchemaConfig();
$metadataSchemaConfig->setExplicitForeignKeyIndexes(false);
$schema = new Schema(array(), array(), $metadataSchemaConfig);
$addedFks = array();
$blacklistedFks = array();
foreach ($classes as $class) {
/** @var \Doctrine\ORM\Mapping\ClassMetadata $class */
if ($this->processingNotRequired($class, $processedClasses)) {
continue;
}
$table = $schema->createTable($this->quoteStrategy->getTableName($class, $this->platform));
if ($class->isInheritanceTypeSingleTable()) {
$this->gatherColumns($class, $table);
$this->gatherRelationsSql($class, $table, $schema, $addedFks, $blacklistedFks);
// Add the discriminator column
$this->addDiscriminatorColumnDefinition($class, $table);
// Aggregate all the information from all classes in the hierarchy
foreach ($class->parentClasses as $parentClassName) {
// Parent class information is already contained in this class
$processedClasses[$parentClassName] = true;
}
foreach ($class->subClasses as $subClassName) {
$subClass = $this->em->getClassMetadata($subClassName);
$this->gatherColumns($subClass, $table);
$this->gatherRelationsSql($subClass, $table, $schema, $addedFks, $blacklistedFks);
$processedClasses[$subClassName] = true;
}
} elseif ($class->isInheritanceTypeJoined()) {
// Add all non-inherited fields as columns
$pkColumns = array();
foreach ($class->fieldMappings as $fieldName => $mapping) {
if (!isset($mapping['inherited'])) {
$columnName = $this->quoteStrategy->getColumnName($mapping['fieldName'], $class, $this->platform);
$this->gatherColumn($class, $mapping, $table);
if ($class->isIdentifier($fieldName)) {
$pkColumns[] = $columnName;
}
}
}
$this->gatherRelationsSql($class, $table, $schema, $addedFks, $blacklistedFks);
// Add the discriminator column only to the root table
if ($class->name == $class->rootEntityName) {
$this->addDiscriminatorColumnDefinition($class, $table);
} else {
// Add an ID FK column to child tables
$inheritedKeyColumns = array();
foreach ($class->identifier as $identifierField) {
$idMapping = $class->fieldMappings[$identifierField];
if (isset($idMapping['inherited'])) {
$this->gatherColumn($class, $idMapping, $table);
$columnName = $this->quoteStrategy->getColumnName($identifierField, $class, $this->platform);
// TODO: This seems rather hackish, can we optimize it?
$table->getColumn($columnName)->setAutoincrement(false);
$pkColumns[] = $columnName;
$inheritedKeyColumns[] = $columnName;
}
}
if (!empty($inheritedKeyColumns)) {
// Add a FK constraint on the ID column
$table->addForeignKeyConstraint($this->quoteStrategy->getTableName($this->em->getClassMetadata($class->rootEntityName), $this->platform), $inheritedKeyColumns, $inheritedKeyColumns, array('onDelete' => 'CASCADE'));
}
}
$table->setPrimaryKey($pkColumns);
} elseif ($class->isInheritanceTypeTablePerClass()) {
throw ORMException::notSupported();
} else {
$this->gatherColumns($class, $table);
$this->gatherRelationsSql($class, $table, $schema, $addedFks, $blacklistedFks);
}
$pkColumns = array();
foreach ($class->identifier as $identifierField) {
if (isset($class->fieldMappings[$identifierField])) {
$pkColumns[] = $this->quoteStrategy->getColumnName($identifierField, $class, $this->platform);
} elseif (isset($class->associationMappings[$identifierField])) {
/* @var $assoc \Doctrine\ORM\Mapping\OneToOne */
$assoc = $class->associationMappings[$identifierField];
foreach ($assoc['joinColumns'] as $joinColumn) {
$pkColumns[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
}
}
}
if (!$table->hasIndex('primary')) {
$table->setPrimaryKey($pkColumns);
}
if (isset($class->table['indexes'])) {
foreach ($class->table['indexes'] as $indexName => $indexData) {
if (!isset($indexData['flags'])) {
$indexData['flags'] = array();
}
$table->addIndex($indexData['columns'], is_numeric($indexName) ? null : $indexName, (array) $indexData['flags'], isset($indexData['options']) ? $indexData['options'] : array());
}
}
if (isset($class->table['uniqueConstraints'])) {
foreach ($class->table['uniqueConstraints'] as $indexName => $indexData) {
$table->addUniqueIndex($indexData['columns'], is_numeric($indexName) ? null : $indexName, isset($indexData['options']) ? $indexData['options'] : array());
}
}
if (isset($class->table['options'])) {
foreach ($class->table['options'] as $key => $val) {
$table->addOption($key, $val);
}
}
$processedClasses[$class->name] = true;
if ($class->isIdGeneratorSequence() && $class->name == $class->rootEntityName) {
$seqDef = $class->sequenceGeneratorDefinition;
$quotedName = $this->quoteStrategy->getSequenceName($seqDef, $class, $this->platform);
if (!$schema->hasSequence($quotedName)) {
$schema->createSequence($quotedName, $seqDef['allocationSize'], $seqDef['initialValue']);
}
}
if ($eventManager->hasListeners(ToolEvents::postGenerateSchemaTable)) {
$eventManager->dispatchEvent(ToolEvents::postGenerateSchemaTable, new GenerateSchemaTableEventArgs($class, $schema, $table));
}
}
if (!$this->platform->supportsSchemas() && !$this->platform->canEmulateSchemas()) {
$schema->visit(new RemoveNamespacedAssets());
}
if ($eventManager->hasListeners(ToolEvents::postGenerateSchema)) {
$eventManager->dispatchEvent(ToolEvents::postGenerateSchema, new GenerateSchemaEventArgs($this->em, $schema));
}
return $schema;
}
/**
* @param array $settings
* @param EntityManagerInterface $manager
*/
protected function registerSubscribers(array $settings = [], EntityManagerInterface $manager)
{
if (isset($settings['events']['subscribers'])) {
foreach ($settings['events']['subscribers'] as $subscriber) {
try {
$resolvedSubscriber = $this->container->make($subscriber);
} catch (ReflectionException $e) {
throw new InvalidArgumentException("Listener {$subscriber} could not be resolved: {$e->getMessage()}");
}
$manager->getEventManager()->addEventSubscriber($resolvedSubscriber);
}
}
}
/**
* Initializes a new ListenersInvoker instance.
*
* @param EntityManagerInterface $em
*/
public function __construct(EntityManagerInterface $em)
{
$this->eventManager = $em->getEventManager();
$this->resolver = $em->getConfiguration()->getEntityListenerResolver();
}
/**
* {@inheritdoc}
*/
public function getEventManager()
{
return $this->wrapped->getEventManager();
}
/**
* @param array $settings
* @param EntityManagerInterface $manager
*/
protected function registerSubscribers($settings = [], EntityManagerInterface $manager)
{
if (isset($settings['events']['subscribers'])) {
foreach ($settings['events']['subscribers'] as $subscriber) {
if (!class_exists($subscriber, false)) {
throw new InvalidArgumentException("Subscriber {$subscriber} does not exist");
}
$manager->getEventManager()->addEventSubscriber(new $subscriber());
}
}
}
