public function onFlush(OnFlushEventArgs $args)
{
$em = $args->getEntityManager();
$uow = $em->getUnitOfWork();
foreach ($uow->getScheduledEntityInsertions() as $entity) {
/*
* Check if the class is a child of the Meta class, the latter
* handling the automatic createDate and modifiedDate methods.
*/
if (!is_subclass_of($entity, 'CampaignChain\\CoreBundle\\Entity\\Meta')) {
continue;
}
$logMetadata = $em->getClassMetadata(get_class($entity));
$entity->setCreatedDate(new \DateTime('now', new \DateTimeZone('UTC')));
$entity->setModifiedDate($entity->getCreatedDate());
$em->persist($entity);
$classMetadata = $em->getClassMetadata(get_class($entity));
$uow->recomputeSingleEntityChangeSet($classMetadata, $entity);
}
foreach ($uow->getScheduledEntityUpdates() as $entity) {
if (!is_subclass_of($entity, 'CampaignChain\\CoreBundle\\Entity\\Meta')) {
continue;
}
$logMetadata = $em->getClassMetadata(get_class($entity));
$entity->setModifiedDate(new \DateTime('now', new \DateTimeZone('UTC')));
}
}
/**
* 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);
}
}
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 $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)
{
$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 = [];
}
}
/**
* @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)
{
/** @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);
}
}
}
}
}
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 $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);
}
}
}
/**
* 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);
}
}
/**
* @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);
}
}
}
}
}
}
}
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()));
}
}
}
/**
* @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)
{
$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();
}
}
}
/**
* @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 $event
*/
public function onFlush(OnFlushEventArgs $event)
{
if (!$this->enabled) {
return;
}
$this->loggableManager->handleLoggable($event->getEntityManager());
}
/**
* 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 \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();
}
}
/**
* @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);
}
}
/**
* 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 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);
}
}
}
/**
* 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);
}
}
}
}
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);
}
}
}
/**
* 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);
}
}
}
}
/**
* 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);
}
}
}
}
/**
* 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 . '.');
}
}
/**
* @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;
}
}
/**
* @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);
}
/**
* 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];
}
}
}
}
/**
* Handle onFlush event
*
* @param OnFlushEventArgs $event
*/
public function handleOnFlush(OnFlushEventArgs $event)
{
$em = $event->getEntityManager();
$uow = $em->getUnitOfWork();
$collections = array_merge($uow->getScheduledCollectionUpdates(), $uow->getScheduledCollectionDeletions());
// check if multi-enum modifications exist
$updates = [];
/** @var PersistentCollection $coll */
foreach ($collections as $coll) {
$mapping = $coll->getMapping();
if ($mapping['type'] === ClassMetadata::MANY_TO_MANY && $mapping['isOwningSide'] && is_subclass_of($mapping['targetEntity'], ExtendHelper::BASE_ENUM_VALUE_CLASS)) {
$owner = $coll->getOwner();
$suffix = $this->getSnapshotFieldMethodSuffix($mapping['fieldName']);
$snapshotValue = $this->buildSnapshotValue($coll);
if ($owner->{'get' . $suffix}() !== $snapshotValue) {
$ownerMetadata = $em->getClassMetadata(ClassUtils::getClass($owner));
$updates[] = [$ownerMetadata, $owner, 'set' . $suffix, $snapshotValue];
}
}
}
// if any, update corresponding snapshots
// $item = [entityClassMetadata, entity, snapshotFieldSetter, snapshotValue]
foreach ($updates as $item) {
$item[1]->{$item[2]}($item[3]);
$uow->recomputeSingleEntityChangeSet($item[0], $item[1]);
}
}
