/** * Change cssHash of views when a widget is updated or deleted. * * @param OnFlushEventArgs $args */ public function onFlush(OnFlushEventArgs $args) { $this->em = $args->getEntityManager(); $this->uow = $this->em->getUnitOfWork(); $this->widgetRepo = $this->em->getRepository('Victoire\\Bundle\\WidgetBundle\\Entity\\Widget'); $this->viewRepo = $this->em->getRepository('Victoire\\Bundle\\CoreBundle\\Entity\\View'); $updatedEntities = $this->uow->getScheduledEntityUpdates(); $deletedEntities = $this->uow->getScheduledEntityDeletions(); //Update View's CSS and inheritors of updated and deleted widgets foreach (array_merge($updatedEntities, $deletedEntities) as $entity) { if (!$entity instanceof Widget) { continue; } $view = $entity->getView(); $this->updateViewCss($view); $this->updateTemplateInheritorsCss($view); } //Remove CSS of deleted View and update its inheritors foreach ($deletedEntities as $entity) { if (!$entity instanceof View) { continue; } $this->viewCssBuilder->removeCssFile($entity->getCssHash()); $this->updateTemplateInheritorsCss($entity); } //Update CSS of updated View and its inheritors foreach ($updatedEntities as $entity) { if (!$entity instanceof View) { continue; } $this->updateViewCss($entity); $this->updateTemplateInheritorsCss($entity); } }
/** * Collect activities changes * * @param OnFlushEventArgs $args */ public function onFlush(OnFlushEventArgs $args) { $entitiesToDelete = $args->getEntityManager()->getUnitOfWork()->getScheduledEntityDeletions(); $entitiesToUpdate = $args->getEntityManager()->getUnitOfWork()->getScheduledEntityUpdates(); if (!empty($entitiesToDelete) || !empty($entitiesToUpdate)) { foreach ($entitiesToDelete as $entity) { $class = $this->doctrineHelper->getEntityClass($entity); $id = $this->doctrineHelper->getSingleEntityIdentifier($entity); $key = $class . '_' . $id; if ($this->activityContactProvider->isSupportedEntity($class) && !isset($this->deletedEntities[$key])) { $targets = $entity->getActivityTargetEntities(); $targetsInfo = []; foreach ($targets as $target) { $targetsInfo[] = ['class' => $this->doctrineHelper->getEntityClass($target), 'id' => $this->doctrineHelper->getSingleEntityIdentifier($target), 'direction' => $this->activityContactProvider->getActivityDirection($entity, $target)]; } $this->deletedEntities[$key] = ['class' => $class, 'id' => $id, 'contactDate' => $this->activityContactProvider->getActivityDate($entity), 'targets' => $targetsInfo]; } } foreach ($entitiesToUpdate as $entity) { $class = $this->doctrineHelper->getEntityClass($entity); $id = $this->doctrineHelper->getSingleEntityIdentifier($entity); $key = $class . '_' . $id; if ($this->activityContactProvider->isSupportedEntity($class) && !isset($this->updatedEntities[$key])) { $changes = $args->getEntityManager()->getUnitOfWork()->getEntityChangeSet($entity); $isDirectionChanged = $this->activityContactProvider->getActivityDirectionProvider($entity)->isDirectionChanged($changes); $targets = $entity->getActivityTargetEntities(); $targetsInfo = []; foreach ($targets as $target) { $targetsInfo[] = ['class' => $this->doctrineHelper->getEntityClass($target), 'id' => $this->doctrineHelper->getSingleEntityIdentifier($target), 'direction' => $this->activityContactProvider->getActivityDirection($entity, $target), 'is_direction_changed' => $isDirectionChanged]; } $this->updatedEntities[$key] = ['class' => $class, 'id' => $id, 'contactDate' => $this->activityContactProvider->getActivityDate($entity), 'targets' => $targetsInfo]; } } } }
public function onFlush(OnFlushEventArgs $args) { $unitOfWork = $args->getEntityManager()->getUnitOfWork(); foreach ($unitOfWork->getScheduledEntityDeletions() as $entity) { if (is_callable(array($entity, 'setDeleted'))) { $entity->setDeleted(true); $unitOfWork->propertyChanged($entity, 'deleted', false, true); $unitOfWork->scheduleExtraUpdate($entity, array('deleted' => array(false, true))); $args->getEntityManager()->persist($entity); } } }
public function onFlush(OnFlushEventArgs $eventArgs) { /* @var $entity SoftDeletable */ $entityManager = $eventArgs->getEntityManager(); $unitOfWork = $eventArgs->getEntityManager()->getUnitOfWork(); foreach ($unitOfWork->getScheduledEntityDeletions() as $entity) { if ($entity instanceof SoftDeletable) { $meta = $entityManager->getClassMetadata(get_class($entity)); $entity->onDelete(); $unitOfWork->computeChangeSet($meta, $entity); $entityManager->persist($entity); $unitOfWork->scheduleExtraUpdate($entity, $unitOfWork->getEntityChangeSet($entity)); } } }
/** * @link http://docs.doctrine-project.org/en/latest/reference/events.html */ public function onFlush(OnFlushEventArgs $args) { $em = $args->getEntityManager(); $uow = $em->getUnitOfWork(); $primitivelyChangedEntities = new SplObjectStorage(); foreach ($uow->getScheduledEntityInsertions() as $entity) { if (property_exists($entity, 'created_by')) { $entity->created_by = $this->identifier; $primitivelyChangedEntities->attach($entity); } if (property_exists($entity, 'updated_by')) { $entity->updated_by = $this->identifier; $primitivelyChangedEntities->attach($entity); } } foreach ($uow->getScheduledEntityUpdates() as $entity) { if (property_exists($entity, 'updated_by')) { $entity->updated_by = $this->identifier; $primitivelyChangedEntities->attach($entity); } } foreach ($primitivelyChangedEntities as $entity) { $meta = $em->getClassMetadata(get_class($entity)); $uow->recomputeSingleEntityChangeSet($meta, $entity); } }
/** * Upload the files on new and updated entities * * @param OnFlushEventArgs $eventArgs */ public function onFlush(OnFlushEventArgs $eventArgs) { $em = $eventArgs->getEntityManager(); $uow = $em->getUnitOfWork(); $entities = array_merge($uow->getScheduledEntityInsertions(), $uow->getScheduledEntityUpdates()); foreach ($entities as $entity) { $classMetadata = $em->getClassMetadata(get_class($entity)); if (!$this->isEntitySupported($classMetadata)) { continue; } if (0 === count($entity->getUploadableFields())) { continue; } // If there is an error when moving the file, an exception will // be automatically thrown by move(). This will properly prevent // the entity from being persisted to the database on error foreach ($entity->getUploadableFields() as $field => $uploadDir) { // If a file has been uploaded if (null !== $entity->getUploadField($field)) { // Generate the filename $filename = $entity->generateFilename($entity->getUploadField($field), $field); // Set the filename $entity->setUploadPath($field, $filename); $entity->getUploadField($field)->move($entity->getUploadRootDir($field), $entity->getUploadPath($field)); // Remove the previous file if necessary $entity->removeUpload($field, true); $entity->unsetUploadField($field); } } $em->persist($entity); $uow->recomputeSingleEntityChangeSet($classMetadata, $entity); } }
public function onFlush(OnFlushEventArgs $args) { if ($this->_isFlushing) { return; } $em = $args->getEntityManager(); $uow = $em->getUnitOfWork(); $entities = array_merge($uow->getScheduledEntityInsertions(), $uow->getScheduledEntityUpdates(), $uow->getScheduledEntityDeletions()); foreach ($entities as $entity) { $structures = []; if ($entity instanceof Structure) { $structures[] = $entity; } else { if ($entity instanceof Node) { $structures[] = $entity->structure; } else { if ($entity instanceof Content) { foreach ($entity->nodes as $node) { $structures[] = $node->structure; } } else { continue; } } } foreach ($structures as $structure) { if (!in_array($structure, $this->_structures, true)) { $this->_structures[] = $structure; } } } }
/** * @param OnFlushEventArgs $event */ public function onFlush(OnFlushEventArgs $event) { $em = $event->getEntityManager(); $uow = $em->getUnitOfWork(); foreach ($uow->getScheduledEntityInsertions() as $entity) { if ($entity instanceof User) { $userSettings = new UserSettings(); $userSettings->setUser($entity); $em->persist($userSettings); $uow->computeChangeSet($em->getClassMetadata(UserSettings::clazz()), $userSettings); } if ($entity instanceof Group) { $groupSettings = new GroupSettings(); $groupSettings->setGroup($entity); $em->persist($groupSettings); $uow->computeChangeSet($em->getClassMetadata(GroupSettings::clazz()), $groupSettings); } } foreach ($uow->getScheduledEntityDeletions() as $entity) { if ($entity instanceof User) { $query = $em->createQuery(sprintf('DELETE FROM %s us WHERE us.user = ?0', UserSettings::clazz())); $query->execute(array($entity)); } if ($entity instanceof Group) { $query = $em->createQuery(sprintf('DELETE FROM %s us WHERE us.group = ?0', GroupSettings::clazz())); $query->execute(array($entity)); } } }
public function onFlush(OnFlushEventArgs $args) { //echo "---preFlush".PHP_EOL; $em = $args->getEntityManager(); $uow = $em->getUnitOfWork(); foreach ($uow->getScheduledEntityInsertions() as $entity) { if ($entity instanceof CmsUser) { // Adds a phonenumber to every newly persisted CmsUser ... $phone = new CmsPhonenumber(); $phone->phonenumber = 12345; // Update object model $entity->addPhonenumber($phone); // Invoke regular persist call $em->persist($phone); // Explicitly calculate the changeset since onFlush is raised // after changeset calculation! $uow->computeChangeSet($em->getClassMetadata(get_class($phone)), $phone); // Take a snapshot because the UoW wont do this for us, because // the UoW did not visit this collection. // Alternatively we could provide an ->addVisitedCollection() method // on the UoW. $entity->getPhonenumbers()->takeSnapshot(); } /*foreach ($uow->getEntityChangeSet($entity) as $field => $change) { list ($old, $new) = $change; var_dump($old); }*/ } }
/** * @param OnFlushEventArgs $args */ public function onFlush(OnFlushEventArgs $args) { $uow = $args->getEntityManager()->getUnitOfWork(); foreach ($uow->getScheduledEntityDeletions() as $entity) { $this->addPendingUpdates($entity); } }
public function onFlush(OnFlushEventArgs $args) { $em = $args->getEntityManager(); $uow = $em->getUnitOfWork(); $entities = array_merge($uow->getScheduledEntityInsertions(), $uow->getScheduledEntityUpdates()); foreach ($entities as $entity) { if (!$entity instanceof Searchable) { continue; } $this->_updates[] = $entity; } $entities = array_merge($uow->getScheduledEntityDeletions()); foreach ($entities as $entity) { if (!$entity instanceof Searchable) { continue; } $this->_deletions[] = $entity; } if (count($this->_deletions)) { $indexes = $em->getRepository('Chalk\\Core\\Index')->entities($this->_deletions); foreach ($indexes as $index) { $em->remove($index); } $this->_deletions = []; } }
/** * Update event's exclude dates and recurrenceIds when start datetime changes. * * @param OnFlushEventArgs $eventArgs */ public function onFlush(OnFlushEventArgs $eventArgs) { $em = $eventArgs->getEntityManager(); $uow = $em->getUnitOfWork(); $entities = array_merge($uow->getScheduledEntityUpdates(), $uow->getScheduledEntityInsertions()); $eventUtil = new EventUtil($em); foreach ($entities as $entity) { if (!$entity instanceof Event) { continue; } /** @var $entity \Xima\ICalBundle\Entity\Component\Event */ $eventUtil->cleanUpEvent($entity); $uow->recomputeSingleEntityChangeSet($em->getClassMetadata(get_class($entity)), $entity); // apply changed $dtStart values to child events $recurrenceIds if any $changeSet = $uow->getEntityChangeSet($entity); if (isset($changeSet['dtStart']) && isset($changeSet['dtStart'][0])) { $interval = $changeSet['dtStart'][0]->diff($entity->getDtStart()); $q = $em->createQuery("select e from Xima\\ICalBundle\\Entity\\Component\\Event e where e.uniqueId = '" . $entity->getUniqueId() . "' AND e.recurrenceId IS NOT NULL"); $detachedEvents = $q->getResult(); foreach ($detachedEvents as $detachedEvent) { /** @var $detachedEvent \Xima\ICalBundle\Entity\Component\Event */ $recurrenceId = $detachedEvent->getRecurrenceId(); $recurrenceId->getDatetime()->add($interval); // make Doctrine accept a DateTime as changed $recurrenceId->setDatetime(clone $recurrenceId->getDatetime()); $uow->recomputeSingleEntityChangeSet($em->getClassMetadata(get_class($recurrenceId)), $recurrenceId); } } } }
/** * Logs the entity changes * * @param \Doctrine\ORM\Event\OnFlushEventArgs $eventArgs */ public function onFlush(OnFlushEventArgs $eventArgs) { $em = $eventArgs->getEntityManager(); $uow = $em->getUnitOfWork(); foreach ($uow->getScheduledEntityInsertions() as $entity) { $this->debug('Inserting entity ' . get_class($entity) . '. Fields: ' . json_encode($uow->getEntityChangeSet($entity))); } foreach ($uow->getScheduledEntityUpdates() as $entity) { $add = ''; if (method_exists($entity, '__toString')) { $add = ' ' . $entity->__toString(); } elseif (method_exists($entity, 'getId')) { $add = ' with id ' . $entity->getId(); } $this->debug('Updating entity ' . get_class($entity) . $add . '. Data: ' . json_encode($uow->getEntityChangeSet($entity))); } foreach ($uow->getScheduledEntityDeletions() as $entity) { $add = ''; if (method_exists($entity, '__toString')) { $add = ' ' . $entity->__toString(); } elseif (method_exists($entity, 'getId')) { $add = ' with id ' . $entity->getId(); } $this->debug('Deleting entity ' . get_class($entity) . $add . '.'); } }
public function onFlush(OnFlushEventArgs $args) { if (!$this->container->has('orocrm_contact.contact.manager')) { return; } $em = $args->getEntityManager(); $uow = $em->getUnitOfWork(); $insertedEntities = $uow->getScheduledEntityInsertions(); $updatedEntities = $uow->getScheduledEntityUpdates(); $entities = array_merge($insertedEntities, $updatedEntities); foreach ($entities as $entity) { if (!$entity instanceof DiamanteUser) { continue; } $contactManager = $this->container->get('orocrm_contact.contact.manager'); $contact = $contactManager->getRepository()->findOneBy(['email' => $entity->getEmail()]); if (empty($contact)) { continue; } if ($entity->getFirstName() == null) { $entity->setFirstName($contact->getFirstName()); } if ($entity->getLastName() == null) { $entity->setLastName($contact->getLastName()); } try { $em->persist($entity); $md = $em->getClassMetadata(get_class($entity)); $uow->recomputeSingleEntityChangeSet($md, $entity); } catch (\Exception $e) { $this->container->get('monolog.logger.diamante')->addWarning(sprintf('Error saving Contact Information for Diamante User with email: %s', $entity->getEmail())); } } }
/** * Handle onFlush event * * @param OnFlushEventArgs $event */ public function handleOnFlush(OnFlushEventArgs $event) { $em = $event->getEntityManager(); $uow = $em->getUnitOfWork(); $newEntities = $uow->getScheduledEntityInsertions(); foreach ($newEntities as $entity) { if ($entity instanceof Call) { $hasChanges = $this->activityManager->addActivityTarget($entity, $entity->getOwner()); // recompute change set if needed if ($hasChanges) { $uow->computeChangeSet($em->getClassMetadata(ClassUtils::getClass($entity)), $entity); } } } $changedEntities = $uow->getScheduledEntityUpdates(); foreach ($changedEntities as $entity) { if ($entity instanceof Call) { $hasChanges = false; $changeSet = $uow->getEntityChangeSet($entity); foreach ($changeSet as $field => $values) { if ($field === 'owner') { list($oldValue, $newValue) = $values; if ($oldValue !== $newValue) { $hasChanges |= $this->activityManager->replaceActivityTarget($entity, $oldValue, $newValue); } break; } } // recompute change set if needed if ($hasChanges) { $uow->computeChangeSet($em->getClassMetadata(ClassUtils::getClass($entity)), $entity); } } } }
/** * Collect changes that were done * Generates tags and store in protected variable * * @param OnFlushEventArgs $event */ public function onFlush(OnFlushEventArgs $event) { if (!$this->isApplicationInstalled) { return; } $em = $event->getEntityManager(); $uow = $em->getUnitOfWork(); $entities = array_merge($uow->getScheduledEntityDeletions(), $uow->getScheduledEntityInsertions(), $uow->getScheduledEntityUpdates()); $collections = array_merge($uow->getScheduledCollectionUpdates(), $uow->getScheduledCollectionDeletions()); foreach ($collections as $collection) { $owner = $collection->getOwner(); if (!in_array($owner, $entities, true)) { $entities[] = $owner; } } $generator = $this->sender->getGenerator(); foreach ($entities as $entity) { if (!in_array(ClassUtils::getClass($entity), $this->skipTrackingFor)) { // invalidate collection view pages only when entity has been added or removed $includeCollectionTag = $uow->isScheduledForInsert($entity) || $uow->isScheduledForDelete($entity); $this->collectedTags = array_merge($this->collectedTags, $generator->generate($entity, $includeCollectionTag)); } } $this->collectedTags = array_unique($this->collectedTags); }
/** * @param \Doctrine\Common\EventArgs * @return void */ public function onFlush(\Doctrine\ORM\Event\OnFlushEventArgs $args) { $em = $args->getEntityManager(); $uow = $em->getUnitOfWork(); // Process updated entities foreach ($uow->getScheduledEntityUpdates() as $entity) { if ($entity instanceof IVersionableEntity) { $this->takeSnapshot($em, $entity); } } // Process removed entities $sources = array(); foreach ($uow->getScheduledEntityDeletions() as $entity) { if ($entity instanceof IVersionableEntity) { $sources[get_class($entity)][] = $entity->getId(); } } if ($sources) { $qb = $em->createQueryBuilder() ->delete('Nella\Doctrine\Listeners\VersionEntity', 'v'); foreach ($sources as $class => $ids) { $qb->andWhere('v.entityClass = :class', $qb->expr()->in('v.entityId', $ids))->setParameter('class', $class); } $qb->getQuery()->execute(); } }
/** * @param OnFlushEventArgs $eventArgs */ public function onFlush(OnFlushEventArgs $eventArgs) { $em = $eventArgs->getEntityManager(); $uow = $em->getUnitOfWork(); foreach ($uow->getScheduledEntityInsertions() as $entity) { if ($entity instanceof Customer) { $this->getLogger()->info('[CustomerConnectorSubscriber][onFlush] Scheduled for insertion'); $this->getSubscriptionAdapter()->createCustomer($entity); $this->persistAndRecomputeChangeset($em, $uow, $entity); } } foreach ($uow->getScheduledEntityUpdates() as $entity) { if ($entity instanceof Customer) { $this->getLogger()->info('[CustomerConnectorSubscriber][onFlush] Scheduled for updates'); $changeset = $uow->getEntityChangeSet($entity); $keys = array('email', 'firstName', 'lastName', 'companyName', 'billingCity', 'billingCountry', 'billingStreet'); if ($this->arrayHasKeys($changeset, $keys)) { $entity->setSubscriptionSynced(false); } if ($entity->getSubscriptionCustomerId() && $entity->isSubscriptionSynced() == false) { $this->getSubscriptionAdapter()->updateCustomer($entity); } elseif (is_null($entity->getSubscriptionCustomerId())) { $this->getSubscriptionAdapter()->createCustomer($entity); } $this->persistAndRecomputeChangeset($em, $uow, $entity); } } }
public function onFlush(OnFlushEventArgs $args) { /** @var $om EntityManager */ $om = $args->getEntityManager(); $uow = $om->getUnitOfWork(); $arm = $this->getAutoRouteManager(); $this->contentResolver->setEntityManager($om); $this->insertions = $uow->getScheduledEntityInsertions(); $scheduledUpdates = $uow->getScheduledEntityUpdates(); // $updates = array_merge($scheduledInserts, $scheduledUpdates); foreach ($scheduledUpdates as $document) { $this->handleInsertOrUpdate($document, $arm, $om, $uow); } $removes = $uow->getScheduledCollectionDeletions(); foreach ($removes as $document) { if ($this->isAutoRouteable($document)) { $referrers = $om->getRepository('Symfony\\Cmf\\Bundle\\RoutingAutoBundle\\Doctrine\\Orm\\AutoRoute')->findBy(array('contentCode' => $this->contentResolver->getContentCode($document))); if ($referrers) { foreach ($referrers as $autoRoute) { $uow->scheduleForDelete($autoRoute); } } } } }
/** * @param OnFlushEventArgs $event * @param ContainerInterface $container * @return mixed */ public function onFlush(OnFlushEventArgs $event, ContainerInterface $container) { $this->timelineRepository = $container->get('diamante.ticket_timeline.repository'); $em = $event->getEntityManager(); $uof = $em->getUnitOfWork(); foreach ($uof->getScheduledEntityInsertions() as $entity) { if ($entity instanceof Ticket && (string) $entity->getStatus()->getValue() === 'new') { $this->increaseNewCounter(); $this->persistCurrentDayRecord($em); } } foreach ($uof->getScheduledEntityUpdates() as $entity) { if ($entity instanceof Ticket) { $changes = $uof->getEntityChangeSet($entity); if (!isset($changes['status'])) { continue; } $from = $changes['status'][0]->getValue(); $to = $changes['status'][1]->getValue(); if (isset($changes['status']) && $from !== $to) { if ($to === 'closed') { $this->increaseClosedCounter(); $this->persistCurrentDayRecord($em); } if ($from === 'closed') { $this->increaseReopenCounter(); $this->persistCurrentDayRecord($em); } } } } }
/** * @param OnFlushEventArgs $args */ public function onFlush(OnFlushEventArgs $args) { /* @var $em Doctrine\ORM\EntityManager */ $em = $args->getEntityManager(); /* @var $uow Doctrine\ORM\UnitOfWork */ $uow = $em->getUnitOfWork(); /* @var $resourceClass Doctrine\ORM\Mapping\ClassMetadata */ $resourceClass = $em->getClassMetadata('DoctrineExtensions\\Versionable\\Entity\\ResourceVersion'); foreach ($uow->getScheduledEntityUpdates() as $entity) { if ($entity instanceof Versionable) { $entityClass = $em->getClassMetadata(get_class($entity)); if (!$entityClass->isVersioned) { throw Exception::versionedEntityRequired(); } $entityId = $entityClass->getIdentifierValues($entity); if (count($entityId) == 1 && current($entityId)) { $entityId = current($entityId); } else { throw Exception::singleIdentifierRequired(); } $oldValues = array_map(function ($changeSetField) { return $changeSetField[0]; }, $uow->getEntityChangeSet($entity)); $entityVersion = $entityClass->reflFields[$entityClass->versionField]->getValue($entity); unset($oldValues[$entityClass->versionField]); unset($oldValues[$entityClass->getSingleIdentifierFieldName()]); $resourceVersion = new ResourceVersion($entityClass->name, $entityId, $oldValues, $entityVersion); $em->persist($resourceVersion); $uow->computeChangeSet($resourceClass, $resourceVersion); } } }
/** * @param OnFlushEventArgs $onFlushEventArgs */ public function onFlush(OnFlushEventArgs $onFlushEventArgs) { $entityManager = $onFlushEventArgs->getEntityManager(); $unitOfWork = $entityManager->getUnitOfWork(); $this->processEntities($unitOfWork->getScheduledEntityInsertions(), $entityManager, $unitOfWork); $this->processEntities($unitOfWork->getScheduledEntityUpdates(), $entityManager, $unitOfWork); }
public function onFlush(OnFlushEventArgs $args) { if (static::$disableProcessing) { return; } $this->init(); $this->toFlush = array(); $em = $args->getEntityManager(); $uow = $em->getUnitOfWork(); foreach ($uow->getScheduledEntityInsertions() as $entity) { $this->process($entity, $em, $uow); } foreach ($uow->getScheduledEntityUpdates() as $entity) { $this->process($entity, $em, $uow); } // Process the aliases after the other stuff foreach ($uow->getScheduledEntityInsertions() as $entity) { $metadata = $em->getClassMetadata(get_class($entity)); if ($metadata->name == 'CMF\\Model\\URL') { $this->processUrlItem($entity, $em, $uow); } } foreach ($uow->getScheduledEntityUpdates() as $entity) { $metadata = $em->getClassMetadata(get_class($entity)); if ($metadata->name == 'CMF\\Model\\URL') { $this->processUrlItem($entity, $em, $uow); } } }
/** * @param OnFlushEventArgs $args */ public function onFlush(OnFlushEventArgs $args) { $em = $args->getEntityManager(); $uow = $em->getUnitOfWork(); $emails = []; foreach ($uow->getScheduledEntityInsertions() as $oid => $entity) { if ($entity instanceof EmailUser) { /* * Collect already flushed emails with bodies and later check * if there is new binding to mailbox. * (email was sent from the system and now mailbox is synchronized) */ $email = $entity->getEmail(); if ($email && $email->getId() && $email->getEmailBody() && $entity->getMailboxOwner()) { $emails[$email->getId()] = $email; } } elseif ($entity instanceof EmailBody) { $this->emailBodies[$oid] = $entity; } } if ($emails) { $emailsToProcess = $this->filterEmailsWithNewlyBoundMailboxes($em, $emails); foreach ($emailsToProcess as $email) { $this->emailBodies[spl_object_hash($email->getEmailBody())] = $email->getEmailBody(); } } }
/** * Grab all of the entities that have a relationship with session and update the session * they are associated with * * We have to do this operation usign onFlush so we can catch inserts, updated * and deletes for all associations * * @param OnFlushEventArgs $eventArgs */ public function onFlush(OnFlushEventArgs $eventArgs) { $entityManager = $eventArgs->getEntityManager(); $uow = $entityManager->getUnitOfWork(); $entities = array_merge($uow->getScheduledEntityInsertions(), $uow->getScheduledEntityUpdates(), $uow->getScheduledEntityDeletions()); $sessionMetadata = $entityManager->getClassMetadata('IliosCoreBundle:Session'); $sessions = []; foreach ($entities as $entity) { switch (get_class($entity)) { case 'Ilios\\CoreBundle\\Entity\\IlmSessionFacet': $session = $entity->getSession(); if (!empty($session)) { $sessions[] = $session; } break; } } $sessions = array_unique($sessions); foreach ($sessions as $session) { if (!$uow->isScheduledForDelete($session)) { $session->stampUpdate(); if ($uow->isScheduledForUpdate($session) or $uow->isScheduledForInsert($session)) { $uow->recomputeSingleEntityChangeSet($sessionMetadata, $session); } else { $entityManager->persist($session); $uow->computeChangeSet($sessionMetadata, $session); } } } }
/** * @param OnFlushEventArgs $event */ public function onFlush(OnFlushEventArgs $event) { if (!$this->enabled) { return; } $this->loggableManager->handleLoggable($event->getEntityManager()); }
/** * @param OnFlushEventArgs $eventArgs */ public function onFlush(OnFlushEventArgs $eventArgs) { /** @var $em ModelManager */ $em = $eventArgs->getEntityManager(); $uow = $em->getUnitOfWork(); // Entity deletions foreach ($uow->getScheduledEntityDeletions() as $entity) { $backlog = $this->getDeleteBacklog($entity); if (!$backlog) { continue; } $this->queue[] = $backlog; } // Entity Insertions foreach ($uow->getScheduledEntityInsertions() as $entity) { $this->inserts[] = $entity; } // Entity updates foreach ($uow->getScheduledEntityUpdates() as $entity) { $backlog = $this->getUpdateBacklog($entity); if (!$backlog) { continue; } $this->queue[] = $backlog; } }
/** * The onFlush method will reassign loans to loan officer sites if they have one * @param OnFlushEventArgs $eventArgs */ public function onFlush(OnFlushEventArgs $eventArgs) { $em = $eventArgs->getEntityManager(); $uow = $em->getUnitOfWork(); foreach ($uow->getScheduledEntityUpdates() as $entity) { if ($entity instanceof LoanApplication) { // reassign the loan application to the LO site $lo = $entity->getLoanOfficer(); //echo 'here 1'; if (isset($lo)) { $hasSite = $lo->hasSite(); if ($hasSite) { // check if they are different //print_r('Loan ID: ' . $entity->getId() . '---'. $lo->getOfficerSite()->getId() . ':' . $entity->getSite()->getId() . ' '); $additionalSiteIds = array(); $additionalSites = $entity->getAdditionalSite(); if (isset($additionalSites)) { foreach ($entity->getAdditionalSite() as $site) { array_push($additionalSiteIds, $site->getId()); } } //print_r($additionalSiteIds); if ($lo->getOfficerSite()->getId() != $entity->getSite()->getId() && !in_array($lo->getOfficerSite()->getId(), $additionalSiteIds)) { $entity->addAdditionalSite($lo->getOfficerSite()); $uow->persist($entity); //print_r('add site'); } } } } } $uow->computeChangeSets(); }
/** * @param OnFlushEventArgs $eventArgs */ public function onFlush(OnFlushEventArgs $eventArgs) { $em = $eventArgs->getEntityManager(); $uow = $em->getUnitOfWork(); foreach ($uow->getScheduledEntityInsertions() as $entity) { if ($entity instanceof Plan) { $this->getLogger()->info('[PlanConnectorSubscriber][onFlush] Scheduled for insertion'); $this->getSubscriptionAdapter()->createPlan($entity); $this->persistAndRecomputeChangeset($em, $uow, $entity); } } foreach ($uow->getScheduledEntityUpdates() as $entity) { if ($entity instanceof Plan) { $changeset = $uow->getEntityChangeSet($entity); $keys = array('amount', 'trialPeriod', 'trialPeriodUnit'); if ($this->arrayHasKeys($changeset, $keys)) { $entity->setSubscriptionSynced(false); } $this->getLogger()->info('[PlanConnectorSubscriber][onFlush] Scheduled for updates'); if ($entity->getSubscriptionPlanId() && $entity->isSubscriptionSynced() == false) { $this->getSubscriptionAdapter()->updatePlan($entity); } elseif (is_null($entity->getSubscriptionPlanId())) { $this->getSubscriptionAdapter()->createPlan($entity); } $this->persistAndRecomputeChangeset($em, $uow, $entity); } } }
/** * @param OnFlushEventArgs $args * @return mixed|void */ public function onFlush(OnFlushEventArgs $args) { $em = $args->getEntityManager(); $unitOfWork = $em->getUnitOfWork(); foreach ($unitOfWork->getScheduledEntityUpdates() as $entity) { if ($entity instanceof PageInterface) { if ($contentRoute = $entity->getContentRoute()) { $contentRoute->setPath(PageHelper::getPageRoutePath($entity->getPath())); $em->persist($contentRoute); $unitOfWork->computeChangeSet($em->getClassMetadata(get_class($contentRoute)), $contentRoute); foreach ($entity->getAllChildren() as $child) { $contentRoute = $child->getContentRoute(); $contentRoute->setPath(PageHelper::getPageRoutePath($child->getPath())); $em->persist($contentRoute); $unitOfWork->computeChangeSet($em->getClassMetadata(get_class($contentRoute)), $contentRoute); if ($entity->getStatus() == Page::STATUS_PUBLISHED) { if ($childSnapshot = $child->getSnapshot()) { $snapshotRoute = $childSnapshot->getContentRoute(); $newPath = PageHelper::getPageRoutePath($child->getPath()); $snapshotRoute->setPath($newPath); $childSnapshot->setPath($newPath); $em->persist($childSnapshot); $em->persist($snapshotRoute); $unitOfWork->computeChangeSet($em->getClassMetadata(get_class($childSnapshot)), $childSnapshot); $unitOfWork->computeChangeSet($em->getClassMetadata(get_class($snapshotRoute)), $snapshotRoute); } } } } } } }