PHP UnitOfWork::getScheduledEntityUpdates方法代码示例

 /**
  * @param OnFlushEventArgs $args
  */
 public function onFlush(OnFlushEventArgs $args)
 {
     $this->initializeFromEventArgs($args);
     $entities = array_merge($this->uow->getScheduledEntityInsertions(), $this->uow->getScheduledEntityDeletions(), $this->uow->getScheduledEntityUpdates());
     /** @var Opportunity[] $entities */
     $entities = array_filter($entities, function ($entity) {
         return 'OroCRM\\Bundle\\SalesBundle\\Entity\\Opportunity' === ClassUtils::getClass($entity);
     });
     foreach ($entities as $entity) {
         if (!$entity->getId() && $this->isValuable($entity)) {
             // handle creation, just add to prev lifetime value and recalculate change set
             $b2bCustomer = $entity->getCustomer();
             $b2bCustomer->setLifetime($b2bCustomer->getLifetime() + $entity->getCloseRevenue());
             $this->scheduleUpdate($b2bCustomer);
             $this->uow->computeChangeSet($this->em->getClassMetadata(ClassUtils::getClass($b2bCustomer)), $b2bCustomer);
         } elseif ($this->uow->isScheduledForDelete($entity) && $this->isValuable($entity)) {
             $this->scheduleUpdate($entity->getCustomer());
         } elseif ($this->uow->isScheduledForUpdate($entity)) {
             // handle update
             $changeSet = $this->uow->getEntityChangeSet($entity);
             if ($this->isChangeSetValuable($changeSet)) {
                 if (!empty($changeSet['customer']) && $changeSet['customer'][0] instanceof B2bCustomer && B2bCustomerRepository::VALUABLE_STATUS === $this->getOldStatus($entity, $changeSet)) {
                     // handle change of b2b customer
                     $this->scheduleUpdate($changeSet['customer'][0]);
                 }
                 if ($this->isValuable($entity, isset($changeSet['closeRevenue'])) || B2bCustomerRepository::VALUABLE_STATUS === $this->getOldStatus($entity, $changeSet) && $entity->getCustomer()) {
                     $this->scheduleUpdate($entity->getCustomer());
                 }
             }
         }
     }
 }

 /**
  * On flush
  *
  * @param OnFlushEventArgs $args
  */
 public function onFlush(OnFlushEventArgs $args)
 {
     $this->manager = $args->getEntityManager();
     $this->uow = $this->manager->getUnitOfWork();
     foreach ($this->uow->getScheduledEntityUpdates() as $entity) {
         $this->preUpdate($entity);
     }
     foreach ($this->uow->getScheduledEntityDeletions() as $entity) {
         $this->preRemove($entity);
     }
 }

 /**
  * @return array|CustomerIdentityInterface[]
  */
 protected function getChangedTrackedEntities()
 {
     $entities = array_merge($this->uow->getScheduledEntityInsertions(), $this->uow->getScheduledEntityDeletions(), $this->uow->getScheduledEntityUpdates());
     $collections = array_merge($this->uow->getScheduledCollectionDeletions(), $this->uow->getScheduledCollectionUpdates());
     /** @var PersistentCollection $collectionToChange */
     foreach ($collections as $collectionToChange) {
         $entities = array_merge($entities, $collectionToChange->unwrap()->toArray());
     }
     return array_filter($entities, function ($entity) {
         return $entity instanceof CustomerIdentityInterface && array_key_exists(ClassUtils::getClass($entity), $this->customerIdentities);
     });
 }

 /**
  * @internal
  * @return bool
  * @author Andreas Glaser
  */
 protected function executeEvents()
 {
     $reRun = false;
     foreach ($this->unitOfWork->getScheduledEntityInsertions() as $hash => $entity) {
         if (array_key_exists($hash, $this->processedEntities['persist'])) {
             continue;
         }
         $this->initPersist($entity, true);
         $this->processRecalculationQueue();
         $reRun = true;
     }
     foreach ($this->unitOfWork->getScheduledEntityUpdates() as $hash => $entity) {
         if (array_key_exists($hash, $this->processedEntities['update']) || array_key_exists($hash, $this->processedEntities['remove'])) {
             continue;
         }
         $this->initUpdate($entity, true);
         $this->processRecalculationQueue();
         $reRun = true;
     }
     foreach ($this->unitOfWork->getScheduledEntityDeletions() as $hash => $entity) {
         if (array_key_exists($hash, $this->processedEntities['remove'])) {
             continue;
         }
         $this->initRemove($entity, true);
         $this->processRecalculationQueue();
         $reRun = true;
     }
     return $reRun;
 }

 /**
  * @param UnitOfWork $uow
  * @return array|Order[]
  */
 protected function getChangedOrders(UnitOfWork $uow)
 {
     $entities = array_merge($uow->getScheduledEntityInsertions(), $uow->getScheduledEntityDeletions(), $uow->getScheduledEntityUpdates());
     $collections = array_merge($uow->getScheduledCollectionDeletions(), $uow->getScheduledCollectionUpdates());
     /** @var PersistentCollection $collectionToChange */
     foreach ($collections as $collectionToChange) {
         $entities = array_merge($entities, $collectionToChange->unwrap()->toArray());
     }
     return array_filter($entities, function ($entity) {
         return $this->isOrderValid($entity);
     });
 }

 /**
  * @param OnFlushEventArgs $eventArgs
  */
 public function onFlush(OnFlushEventArgs $eventArgs)
 {
     $this->em = $eventArgs->getEntityManager();
     $this->unitOfWork = $this->em->getUnitOfWork();
     // New localization creation, could contain children already, need to recurse into children
     foreach ($this->unitOfWork->getScheduledEntityInsertions() as $entity) {
         if ($entity instanceof PageLocalization) {
             $this->pageLocalizationChange($entity, true);
         }
     }
     // Page path is not set from inserts, updates only
     foreach ($this->unitOfWork->getScheduledEntityUpdates() as $entity) {
         if ($entity instanceof PageLocalization) {
             $this->pageLocalizationChange($entity);
         }
         // this should be covered by the move trigger
         if ($entity instanceof Page) {
             // Run for all children, every locale
             $this->pageChange($entity);
         }
     }
 }

 /**
  * Main method: get all entities scheduled to be inserted, updated or deleted,
  * then remove duplicates and call setTags() method
  *
  * @param OnFlushEventArgs $args
  */
 public function onFlush(OnFlushEventArgs $args)
 {
     $this->em = $args->getEntityManager();
     $this->uow = $this->em->getUnitOfWork();
     $entities = $this->uow->getScheduledEntityInsertions();
     foreach ($this->uow->getScheduledEntityUpdates() as $key => $entity) {
         if (!in_array($entity, $entities)) {
             $entities[$key] = $entity;
         }
     }
     foreach ($entities as $entity) {
         if ($entity instanceof TaggableInterface) {
             $this->setTags($entity, true);
         }
     }
     if ($this->purge) {
         foreach ($this->uow->getScheduledEntityDeletions() as $key => $entity) {
             if ($entity instanceof TaggableInterface) {
                 $this->purgeTags($entity);
             }
         }
     }
 }

 /**
  * Collect updated activities
  *
  * @param UnitOfWork $uof
  */
 protected function collectUpdates(UnitOfWork $uof)
 {
     $entities = $uof->getScheduledEntityUpdates();
     foreach ($entities as $hash => $entity) {
         if ($this->activityListManager->isSupportedEntity($entity) && empty($this->updatedEntities[$hash])) {
             $this->updatedEntities[$hash] = $entity;
         }
     }
     $updatedCollections = array_merge($uof->getScheduledCollectionUpdates(), $uof->getScheduledCollectionDeletions());
     foreach ($updatedCollections as $hash => $collection) {
         /** @var $collection PersistentCollection */
         $ownerEntity = $collection->getOwner();
         $entityHash = spl_object_hash($ownerEntity);
         if ($this->activityListManager->isSupportedEntity($ownerEntity) && $this->doctrineHelper->getSingleEntityIdentifier($ownerEntity) !== null && empty($this->updatedEntities[$entityHash])) {
             $this->updatedEntities[$entityHash] = $ownerEntity;
         }
     }
 }

 /**
  * @param $changeset The changeset for the entity
  * @param $expectedFields List of filds which should be updated/set
  *
  * @dataProvider provideLifecycle
  */
 public function testOnFlush($changeset, $expectedFields)
 {
     $entity = $this->userBlameObject->reveal();
     $this->unitOfWork->getScheduledEntityInsertions()->willReturn([$entity]);
     $this->unitOfWork->getScheduledEntityUpdates()->willReturn([]);
     $this->entityManager->getClassMetadata(get_class($entity))->willReturn($this->classMetadata);
     $this->unitOfWork->getEntityChangeSet($this->userBlameObject->reveal())->willReturn($changeset);
     foreach (['creator', 'changer'] as $field) {
         $prophecy = $this->classMetadata->setFieldValue($this->userBlameObject->reveal(), $field, $this->user->reveal());
         if (in_array($field, $expectedFields)) {
             $prophecy->shouldBeCalled();
             continue;
         }
         $prophecy->shouldNotBeCalled();
     }
     if (count($expectedFields)) {
         $this->unitOfWork->recomputeSingleEntityChangeSet($this->classMetadata->reveal(), $this->userBlameObject->reveal())->shouldBeCalled();
     }
     $this->subscriber->onFlush($this->onFlushEvent->reveal());
 }

 public function onFlush(OnFlushEventArgs $eventArgs)
 {
     $this->em = $eventArgs->getEntityManager();
     $this->quoteStrategy = $this->em->getConfiguration()->getQuoteStrategy();
     $this->conn = $this->em->getConnection();
     $this->uow = $this->em->getUnitOfWork();
     $this->platform = $this->conn->getDatabasePlatform();
     $this->revisionId = null;
     // reset revision
     $processedEntities = array();
     foreach ($this->uow->getScheduledEntityDeletions() as $entity) {
         //doctrine is fine deleting elements multiple times. We are not.
         $hash = $this->getHash($entity);
         if (in_array($hash, $processedEntities)) {
             continue;
         }
         $processedEntities[] = $hash;
         $class = $this->em->getClassMetadata(get_class($entity));
         if (!$this->metadataFactory->isAudited($class->name)) {
             continue;
         }
         $entityData = array_merge($this->getOriginalEntityData($entity), $this->uow->getEntityIdentifier($entity));
         $this->saveRevisionEntityData($class, $entityData, 'DEL');
     }
     foreach ($this->uow->getScheduledEntityInsertions() as $entity) {
         if (!$this->metadataFactory->isAudited(get_class($entity))) {
             continue;
         }
         $this->extraUpdates[spl_object_hash($entity)] = $entity;
     }
     foreach ($this->uow->getScheduledEntityUpdates() as $entity) {
         if (!$this->metadataFactory->isAudited(get_class($entity))) {
             continue;
         }
         $this->extraUpdates[spl_object_hash($entity)] = $entity;
     }
 }

 /**
  * Schedule updates for routing
  *
  * @param EntityManager $em
  * @param UnitOfWork $uow
  */
 protected function updateRouting(EntityManager $em, UnitOfWork $uow)
 {
     // 302 old routes to the new 200
     foreach ($uow->getScheduledEntityUpdates() as $entity) {
         if ($entity instanceof FieldableEntity) {
             $changeSet = $uow->getEntityChangeSet($entity);
             $oldRoute = $entity->getRoute();
             // Check if we have a route. If not, create one and continue
             if (!$oldRoute instanceof Route) {
                 // create the new route
                 $oldRoute = $this->getEntityRoute($entity);
                 $entity->setRoute($oldRoute);
                 $this->computeChangeSet($em, $oldRoute);
                 $this->recomputeSingleEntityChangeSet($em, $entity);
             }
             // Check if the route has been manually updated
             $newRoute = $this->getEntityRoute($entity);
             // if the route changed, update it
             if ($newRoute->getPath() !== $oldRoute->getPath()) {
                 // create the new route entity
                 $entity->setRoute($newRoute);
                 $this->computeChangeSet($em, $newRoute);
                 // set any old route to redirect to the new route
                 $this->redirectRoute($oldRoute);
                 $this->recomputeSingleEntityChangeSet($em, $oldRoute);
             }
             if (isset($changeSet['deletedOn'])) {
                 if ($changeSet['deletedOn'] instanceof \DateTime) {
                     // delete
                     $this->deletedRoute($oldRoute);
                     $this->recomputeSingleEntityChangeSet($em, $oldRoute);
                 } else {
                     // un-delete
                     $newRoute = $this->getEntityRoute($entity);
                     $entity->setRoute($newRoute);
                     $uow->scheduleForDelete($oldRoute);
                     $this->computeChangeSet($em, $newRoute);
                     $this->recomputeSingleEntityChangeSet($em, $oldRoute);
                 }
             }
             $em->persist($entity);
             $this->recomputeSingleEntityChangeSet($em, $entity);
         }
     }
 }

 /**
  * @param callable $callback    Callback
  * @param string   $entityClass Entity class filter
  *
  * @return AbstractOnFlushListener
  */
 protected function onUpdate(callable $callback, $entityClass = null)
 {
     $this->checkIfInitialized();
     return $this->processEntities($this->uow->getScheduledEntityUpdates(), self::OPERATION_UPDATE, $callback, $entityClass);
 }

 /**
  * Get the scheduled object updates from a UnitOfWork.
  *
  * @param \Doctrine\ORM\UnitOfWork $uow
  * @return array
  */
 public function getScheduledObjectUpdates(UnitOfWork $uow)
 {
     return $uow->getScheduledEntityUpdates();
 }

 /**
  * Creates data
  *
  * @param UnitOfWork $uow
  * @return array
  */
 public function createEmailAddressData(UnitOfWork $uow)
 {
     return ['updates' => array_map(function ($entity) use($uow) {
         return ['entity' => $entity, 'changeSet' => $uow->getEntityChangeSet($entity)];
     }, array_filter(array_merge($uow->getScheduledEntityInsertions(), $uow->getScheduledEntityUpdates()), $this->getEntityFilter())), 'deletions' => array_filter($uow->getScheduledEntityDeletions(), $this->getEntityFilter())];
 }

 public function onFlush(OnFlushEventArgs $e)
 {
     $this->init($e);
     if ($this->stats) {
         foreach ($this->uow->getScheduledEntityInsertions() as $entity) {
             if ($entity instanceof Deposit) {
                 // deposit arrived
                 if ($entity->isConfirmed()) {
                     // it is confirmed
                     $this->addConfirmedDeposit($entity);
                 } else {
                     // it is pending
                     $entity->getAccount()->addTotalPendingDeposit($entity->getAmount());
                     $this->stats->addTotalPendingDeposit($entity->getAmount());
                 }
                 $this->stats->setLastDeposit($entity->getReceivedTime());
                 $this->recoumputeChanges($entity->getAccount());
             }
             if ($entity instanceof PayoutTx) {
                 // transaction has just been sent
                 $this->stats->addTotalTxFees($entity->getTxFee() * -1);
             }
         }
         foreach ($this->uow->getScheduledEntityUpdates() as $entity) {
             if ($entity instanceof Deposit) {
                 $changes = $this->uow->getEntityChangeSet($entity);
                 if (isset($changes['confirmed'])) {
                     $oldConfirmed = $changes['confirmed'][0];
                     $newConfirmed = $changes['confirmed'][1];
                     if (!$oldConfirmed && $newConfirmed) {
                         // subtract pending if not referrer
                         $this->stats->subtractTotalPendingDeposit($entity->getAmount());
                         $entity->getAccount()->subtractTotalPendingDeposit($entity->getAmount());
                         // add confirmed
                         $this->addConfirmedDeposit($entity);
                         $this->recoumputeChanges($entity->getAccount());
                     }
                 }
             }
             if ($entity instanceof Payout) {
                 $changes = $this->uow->getEntityChangeSet($entity);
                 if (isset($changes['paid'])) {
                     $oldPaid = $changes['paid'][0];
                     $newPaid = $changes['paid'][1];
                     if (!$oldPaid && $newPaid) {
                         if ($entity->isDefaultPayout() || $entity->isRemainingFundsReturn() || $entity->isLastPayout()) {
                             $this->stats->addTotalPayout($entity->getAmount());
                             $entity->getAccount()->addTotalPayout($entity->getAmount());
                             if ($entity->isDefaultPayout()) {
                                 $this->stats->setLastPayout($entity->getPaidOutTime());
                             }
                         } elseif ($entity->isReferrerPayout()) {
                             $this->stats->addTotalReferralPayout($entity->getAmount());
                             $entity->getAccount()->addTotalReferralPayout($entity->getAmount());
                         }
                         if (!$entity->isLastAdminPayout()) {
                             $this->recoumputeChanges($entity->getAccount());
                         }
                         $this->stats->addTotalFees($entity->getFee());
                     }
                 }
             }
         }
         $this->recoumputeChanges($this->stats);
         $this->uow->computeChangeSets();
     }
 }