public function preFlush(PreFlushEventArgs $event) { $em = $event->getEntityManager(); /* @var $em \Doctrine\ORM\EntityManager */ foreach ($em->getUnitOfWork()->getScheduledEntityInsertions() as $entity) { $this->synchronizeValueObjects($entity); } foreach ($em->getUnitOfWork()->getIdentityMap() as $identities) { foreach ($identities as $entity) { $this->synchronizeValueObjects($entity); } } }
public function preFlush(PreFlushEventArgs $eventArgs) { $uow = $eventArgs->getEntityManager()->getUnitOfWork(); $insertions = $uow->getScheduledEntityInsertions(); $updates = $uow->getScheduledEntityUpdates(); $entities = array_merge($insertions, $updates); foreach ($entities as $entity) { $refl = new \ReflectionObject($entity); foreach ($refl->getProperties() as $prop) { /** @var TsVector $annot */ $annot = $this->reader->getPropertyAnnotation($prop, TsVector::class); if (is_null($annot)) { continue; } $fields = $annot->fields; $tsVectorVal = []; foreach ($fields as $field) { $field = $refl->getProperty($field); $field->setAccessible(true); $fieldValue = $field->getValue($entity); if (is_array($fieldValue)) { $fieldValue = implode(' ', $fieldValue); } $tsVectorVal[] = $fieldValue; } $prop->setAccessible(true); $value = ['data' => join(' ', $tsVectorVal), 'language' => $annot->language, 'weight' => $annot->weight]; $prop->setValue($entity, $value); } } }
/** * Pre Flush event callback * * Checks if the entity contains an @Tracked (or derived) * annotation. If so, it will attempt to calculate changes * made and dispatch 'Events::ENTITY_CHANGED' with the current * and original entity states. Note that the original entity * is not managed. * * @param PreFlushEventArgs $event */ public function preFlush(PreFlushEventArgs $event) { $em = $event->getEntityManager(); $changes = $this->meta_mutation_provider->getFullChangeSet($em); foreach ($changes as $updates) { if (0 === count($updates)) { continue; } if (false === $this->meta_annotation_provider->isTracked($em, current($updates))) { continue; } foreach ($updates as $entity) { if (!$this->meta_mutation_provider->isEntityManaged($em, $entity) || $entity instanceof Proxy && !$entity->__isInitialized()) { continue; } $original = $this->meta_mutation_provider->createOriginalEntity($em, $entity); // New entities are handled in the pre-persist event. if (!$original) { continue; } $mutated_fields = $this->meta_mutation_provider->getMutatedFields($em, $entity, $original); if (!empty($mutated_fields)) { $this->logger->debug('Going to notify a change (preFlush) to {entity_class}, which has {mutated_fields}', ['entity_class' => get_class($entity), 'mutated_fields' => $mutated_fields]); $em->getEventManager()->dispatchEvent(Events::ENTITY_CHANGED, new EntityChangedEvent($em, $entity, $original, $mutated_fields)); } } } }
/** @ORM\PreFlush */ public function preFlushHandler(RouteEntity $route, PreFlushEventArgs $event) { if ($this->inPreFlush) { return; } $this->inPreFlush = true; $em = $event->getEntityManager(); $uow = $em->getUnitOfWork(); foreach ($uow->getScheduledEntityUpdates() as $entity) { if ($entity instanceof RouteEntity) { $changeSet = $uow->getEntityChangeSet($entity); if (isset($changeSet['url'])) { $routeAliasEntity = new RouteAliasEntity(); $routeAliasEntity->setRoute($entity); $routeAliasEntity->setAliasUrl($changeSet['url'][0]); $routeAliasEntity->setAliasLang($entity->getLanguage() !== null ? $entity->getLanguage()->getAlias() : null); $routeAliasEntity->setAliasDomain($entity->getDomain() !== null ? $entity->getDomain()->getDomain() : null); $em->persist($routeAliasEntity); $em->flush($routeAliasEntity); $meta = $em->getClassMetadata(get_class($routeAliasEntity)); $uow->recomputeSingleEntityChangeSet($meta, $routeAliasEntity); } } } $this->inPreFlush = false; }
/** * @param PreFlushEventArgs $args * @throws ReadOnlyEntityCantBeFlushedException */ public function preFlush(PreFlushEventArgs $args) { $unitOfWork = $args->getEntityManager()->getUnitOfWork(); $entities = array_merge($unitOfWork->getScheduledEntityInsertions(), $unitOfWork->getScheduledEntityUpdates(), $unitOfWork->getScheduledEntityDeletions()); foreach ($entities as $entity) { if ($this->isReadOnlyEntity($entity)) { throw new ReadOnlyEntityCantBeFlushedException($entity); } } }
/** * Before the flush we check that the product categories are right. * * @param PreFlushEventArgs $args The pre flush event arguments. */ public function preFlush(PreFlushEventArgs $args) { $entityManager = $args->getEntityManager(); $scheduledInsertions = $entityManager->getUnitOfWork()->getScheduledEntityInsertions(); foreach ($scheduledInsertions as $entity) { if ($entity instanceof ProductInterface) { $this->categoryIntegrityFixer->fixProduct($entity); } } }
/** * preFlush event. * * @param PreFlushEventArgs $args */ public function preFlush(PreFlushEventArgs $args) { $em = $args->getEntityManager(); $uow = $em->getUnitOfWork(); foreach ($uow->getScheduledEntityInsertions() as $entity) { if ($entity instanceof \CmsModule\Content\Entities\BaseFileEntity) { $this->setup($entity); } } }
/** * Pre flush event listener. * * @param PreFlushEventArgs $args The pre flush event args. * * @return $this Self object */ public function preFlush(PreFlushEventArgs $args) { $scheduledInsertions = $args->getEntityManager()->getUnitOfWork()->getScheduledEntityInsertions(); foreach ($scheduledInsertions as $entity) { if ($entity instanceof CategoryInterface) { $this->removeParentCategoryForRootCategory($entity); } } return $this; }
/** * Validates entities before flush. * * @param PreFlushEventArgs $eventArgs */ public function preFlush(PreFlushEventArgs $eventArgs) { $em = $eventArgs->getEntityManager(); $uow = $em->getUnitOfWork(); foreach ($uow->getScheduledEntityInsertions() as $entity) { $this->validateEntity($entity); } foreach ($uow->getScheduledEntityUpdates() as $entity) { $this->validateEntity($entity); } }
public function preFlush(PreFlushEventArgs $eventArgs) { $identityMap = $eventArgs->getEntityManager()->getUnitOfWork()->getIdentityMap(); foreach ($identityMap as $class => $entity) { var_dump($entity); } $entity = $eventArgs->getEntity(); if ($this->service->getMetadata()->hasEntityMetadata($entity)) { $this->service->saveTaxonomies($entity); } }
public function preFlush(PreFlushEventArgs $event) { $entityManager = $event->getEntityManager(); /** @var $unitOfWork \Doctrine\ORM\UnitOfWork */ $unitOfWork = $entityManager->getUnitOfWork(); foreach ($unitOfWork->getScheduledEntityInsertions() + $unitOfWork->getScheduledEntityUpdates() as $entity) { if ($tm = $this->getTranslationMetadata(get_class($entity), $entityManager)) { $tm->stripProxies($entity); $this->proxiesStripped[] = $entity; } } }
/** * @param PreFlushEventArgs $ea */ public function preFlush(PreFlushEventArgs $ea) { $unitOfWork = $ea->getEntityManager()->getUnitOfWork(); $entityMaps = $unitOfWork->getIdentityMap(); foreach ($entityMaps as $entities) { foreach ($entities as $entity) { foreach ($this->metadataFactory->getMetadataForClass(get_class($entity))->propertyMetadata as $file) { $this->mogrify($entity, $file); } } } }
function it_applies_generator(PreFlushEventArgs $args, EntityManager $entityManager, SequenceSubjectInterface $entity, GeneratorInterface $generator, EntityRepository $sequenceRepository, Sequence $sequence, $registry, $eventDispatcher) { $this->enableEntity($entity); $args->getEntityManager()->willReturn($entityManager); $registry->get($entity)->willReturn($generator); $entity->getSequenceType()->willReturn('sequence_type'); $entityManager->getRepository('Sylius\\Component\\Sequence\\Model\\Sequence')->willReturn($sequenceRepository); $sequenceRepository->findOneBy(array('type' => 'sequence_type'))->willReturn($sequence); $eventDispatcher->dispatch(sprintf(SyliusSequenceEvents::PRE_GENERATE, 'sequence_type'), Argument::type('Symfony\\Component\\EventDispatcher\\GenericEvent'))->shouldBeCalled(); $generator->generate($entity, $sequence)->shouldBeCalled(); $eventDispatcher->dispatch(sprintf(SyliusSequenceEvents::POST_GENERATE, 'sequence_type'), Argument::type('Symfony\\Component\\EventDispatcher\\GenericEvent'))->shouldBeCalled(); $this->preFlush($args); }
public function preFlush(PreFlushEventArgs $args) { $em = $args->getEntityManager(); $uow = $em->getUnitOfWork(); foreach ($uow->getScheduledEntityInsertions() as $entity) { $reflection = Nette\Reflection\ClassType::from($entity); if ($reflection->hasProperty("priority")) { $repository = $em->getRepository($reflection->getName()); $result = $repository->createQueryBuilder("p")->select("MAX(p.priority)")->getQuery()->execute(); $entity->priority = ($result ? (int) $result[0][1] : 0) + 1; } } }
/** * @param PreFlushEventArgs $ea */ public function preFlush(PreFlushEventArgs $ea) { $entityManager = $ea->getEntityManager(); $unitOfWork = $entityManager->getUnitOfWork(); $entityMaps = $unitOfWork->getIdentityMap(); foreach ($entityMaps as $entities) { foreach ($entities as $entity) { foreach ($this->getFiles($entity, $ea->getEntityManager()) as $file) { $this->mogrify($entity, $file); } } } }
/** * Remove entities marked as deleted * * @param PreFlushEventArgs $event */ public function preFlush(PreFlushEventArgs $event) { $entityManager = $event->getEntityManager(); $uow = $entityManager->getUnitOfWork(); foreach ($uow->getIdentityMap() as $class => $entities) { foreach ($entities as $entity) { if ($entity instanceof AggregateRootInterface) { if ($entity->isDeleted()) { $entityManager->remove($entity); } } } } }
public function preFlush(PreFlushEventArgs $args) { $uploadManager = $this->container->get('hg_file_repository.upload_manager'); $entities = $uploadManager->getEntities(); if (empty($entities)) { return; } $em = $args->getEntityManager(); foreach ($entities as $entity) { if ($em->contains($entity)) { $uploadManager->processRequestsForEntity($entity); $meta = $em->getClassMetadata(get_class($entity)); $em->getUnitOfWork()->computeChangeSet($meta, $entity); } } }
public function preFlush(PreFlushEventArgs $args) { if (!$this->inRequest) { // let console commands handle flushes anyway they want return; } $em = $args->getEntityManager(); if ($em->getConnection()->isTransactionActive()) { // the transaction is managed manually and was already started // probably it won't be handled since it is the end of response // but anyways, it won't cause trouble return; } if ($this->flushed) { throw new \BadMethodCallException("The flush can be run only once and is run automatically in the end of each request to prevent data inconsistencies and bad design."); } $this->flushed = true; }
/** * Before the flush we check if we are inserting new categories and in this case we set a correct position. * * @param PreFlushEventArgs $args The pre flush event arguments. */ public function preFlush(PreFlushEventArgs $args) { $entityManager = $args->getEntityManager(); $scheduledInsertions = $entityManager->getUnitOfWork()->getScheduledEntityInsertions(); foreach ($scheduledInsertions as $entity) { if ($entity instanceof Category) { /** * @var Category $entity */ $entityRepository = $entityManager->getRepository(get_class($entity)); if ($entity->isRoot()) { $parentCategoriesNumber = count($entityRepository->getParentCategories()); $entity->setPosition($parentCategoriesNumber); } else { $categoriesOnThisParentCategory = count($entityRepository->getChildrenCategories($entity->getParent())); $entity->setPosition($categoriesOnThisParentCategory); } } } }
/** * Listen to preFlush events * * @param PreFlushEventArgs $args */ public function preFlush(PreFlushEventArgs $args) { $unitOfWork = $args->getEntityManager()->getUnitOfWork(); foreach ($unitOfWork->getIdentityMap() as $identity) { foreach ($identity as $entity) { if (!$this->isEntitySupported($entity)) { continue; } // todo: look at using this event hook for handling persist and remove as well if ($unitOfWork->isScheduledForInsert($entity) || $unitOfWork->isScheduledForDelete($entity)) { continue; } if ($entity->getUploadedFile()) { $this->storageHandler->writeUploadedFile($entity, true); $unitOfWork->propertyChanged($entity, 'fileName', $entity->getFileName(), $entity->getFileName()); $unitOfWork->scheduleForUpdate($entity); } } } }
/** * @param \Doctrine\ORM\Event\PreFlushEventArgs $ea */ public function preFlush(PreFlushEventArgs $ea) { $entityManager = $ea->getEntityManager(); // Hit fix, see http://doctrine-project.org/jira/browse/DDC-2276 // @todo: wait for real fix if (!$entityManager instanceof EntityManager) { return; } $unitOfWork = $entityManager->getUnitOfWork(); // Finally, check all entities in identity map - if they have a file object they need to be processed foreach ($unitOfWork->getIdentityMap() as $entities) { foreach ($entities as $fileEntity) { foreach ($this->getFileFields($fileEntity, $entityManager) as $fileConfig) { $propertyValue = $fileConfig['property']->getValue($fileEntity); if ($propertyValue instanceof CondemnedFile) { $this->preRemoveUpload($fileEntity, $fileConfig); } else { $this->preUpload($ea, $fileEntity, $fileConfig); } } } } }
/** * Pre Flush event callback * * Checks if the entity contains an @Tracked (or derived) * annotation. If so, it will attempt to calculate changes * made and dispatch 'Events::entityChanged' with the current * and original entity states. Note that the original entity * is not managed. * * @param PreFlushEventArgs $event */ public function preFlush(PreFlushEventArgs $event) { $em = $event->getEntityManager(); $changes = $this->meta_mutation_provider->getFullChangeSet($em); foreach ($changes as $updates) { if (empty($updates)) { continue; } if (false === $this->meta_annotation_provider->isTracked($em, current($updates))) { continue; } foreach ($updates as $entity) { if (!$this->meta_mutation_provider->isEntityManaged($em, $entity) || $entity instanceof Proxy) { continue; } $original = $this->meta_mutation_provider->createOriginalEntity($em, $entity); $mutated_fields = $this->meta_mutation_provider->getMutatedFields($em, $entity, $original); if (!empty($mutated_fields)) { $this->logger->info('Going to notify a change to {entity_class}, which has {mutated_fields}', ['entity_class' => get_class($entity), 'mutated_fields' => $mutated_fields]); $em->getEventManager()->dispatchEvent(Events::entityChanged, new EntityChangedEvent($em, $entity, $original, $mutated_fields)); } } } }
/** * {@inheritdoc} */ public function preFlush(PreFlushEventArgs $args) { $em = $args->getEntityManager(); foreach ($this->entitiesEnabled as $entity) { try { $generator = $this->registry->get($entity); } catch (NonExistingServiceException $e) { throw new NonExistingGeneratorException($entity, $e); } $sequence = $this->getSequence($entity->getSequenceType(), $em); $event = new GenericEvent($entity); $this->eventDispatcher->dispatch(sprintf(SyliusSequenceEvents::PRE_GENERATE, $entity->getSequenceType()), $event); $generator->generate($entity, $sequence); $this->eventDispatcher->dispatch(sprintf(SyliusSequenceEvents::POST_GENERATE, $entity->getSequenceType()), $event); } }
/** * @param $entity * @param ORM\Event\PreFlushEventArgs $eventArgs * * @throws Phone\Exceptions\NoValidCountryException * @throws Phone\Exceptions\NoValidPhoneException */ public function preFlush($entity, ORM\Event\PreFlushEventArgs $eventArgs) { $this->postLoadAndPreFlush($entity, $eventArgs->getEntityManager()); }
/** * @param \Doctrine\ORM\Event\PreFlushEventArgs $eventArgs * * @author Andreas Glaser */ public function preFlush(PreFlushEventArgs $eventArgs) { $this->entityManager = $eventArgs->getEntityManager(); $this->unitOfWork = $this->entityManager->getUnitOfWork(); if ($this->config['common_entity_event_handler']) { if (class_exists($this->config['common_entity_event_handler'])) { $this->commonEntityEventHandler = new $this->config['common_entity_event_handler']($this->container, $this, $this->entityManager); } else { throw new \InvalidArgumentException(strtr('":class" does not exist', [':class' => $this->config['common_entity_event_handler']])); } } $this->unitOfWork->computeChangeSets(); $max = 50; $current = 0; do { $runAgain = $this->executeEvents(); $current++; } while ($runAgain === true && $current <= $max); if ($current >= $max) { throw new \RuntimeException('Too many iterations... something must have gone wrong.'); } }
/** * Listen to preflush event * Encrypt entities that are inserted into the database * * @param PreFlushEventArgs $preFlushEventArgs */ public function preFlush(PreFlushEventArgs $preFlushEventArgs) { $unitOfWork = $preFlushEventArgs->getEntityManager()->getUnitOfWork(); foreach ($unitOfWork->getScheduledEntityInsertions() as $entity) { $this->processFields($entity); } }
/** * This event handler will update, insert or remove translation entities if main object's translatable properties change. * * @param \Doctrine\ORM\Event\PreFlushEventArgs $eventArgs * @return void */ public function preFlush(PreFlushEventArgs $eventArgs) { $entityManager = $eventArgs->getEntityManager(); /* @var $unitOfWork UnitOfWork */ $unitOfWork = $entityManager->getUnitOfWork(); foreach ($unitOfWork->getScheduledEntityInsertions() as $object) { $class = get_class($object); $translatableMeta = $this->getExtendedMetadata($entityManager, $class); if (!$translatableMeta->hasTranslatableProperties()) { continue; } $meta = $entityManager->getClassMetadata($class); $this->updateTranslations($entityManager, $meta, $translatableMeta, $object); } foreach ($unitOfWork->getIdentityMap() as $class => $entities) { $translatableMeta = $this->getExtendedMetadata($entityManager, $class); if (!$translatableMeta->hasTranslatableProperties()) { continue; } $meta = $entityManager->getClassMetadata($class); foreach ($entities as $object) { if ($object instanceof \Doctrine\ORM\Proxy\Proxy) { continue; } $this->updateTranslations($entityManager, $meta, $translatableMeta, $object); } } }
/** * @ORM\PreFlush */ public function setParentState(PreFlushEventArgs $args) { $em = $args->getEntityManager(); if (!$this->getParent() || $this->getState() != 'Finished') { return null; } $parent = $this->getParent(); while ($parent) { foreach ($parent->getChildren() as $anotherChild) { if ($anotherChild->getState() != 'Finished') { break 2; } } $parent->setState('Finished'); $em->persist($parent); if ($parent->getParent() !== null) { $parent = $parent->getParent(); } else { break; } } }
/** * Check and eventually update files keys. * * @param \Doctrine\ORM\Event\PreFlushEventArgs $eventArgs */ public function preFlush(PreFlushEventArgs $eventArgs) { $entityManager = $eventArgs->getEntityManager(); $unitOfWork = $entityManager->getUnitOfWork(); $eventAdapter = $this->getEventAdapter($eventArgs); foreach ($unitOfWork->getIdentityMap() as $class => $entities) { $uploadableMeta = $this->getExtendedMetadata($entityManager, $class); if (!$uploadableMeta->hasUploadableProperties()) { continue; } foreach ($entities as $object) { if ($object instanceof Proxy) { continue; } $this->updateFiles($entityManager, $uploadableMeta, $object, $eventAdapter); } } }
/** * This event handler will update, insert or remove translation entities if main object's translatable properties change. * * @param \Doctrine\ORM\Event\PreFlushEventArgs $eventArgs * @return void */ public function preFlush(PreFlushEventArgs $eventArgs) { $entityManager = $eventArgs->getEntityManager(); $unitOfWork = $entityManager->getUnitOfWork(); foreach ($unitOfWork->getScheduledEntityInsertions() as $object) { $this->updateObjectTranslations($entityManager, $object); } foreach ($unitOfWork->getIdentityMap() as $class => $entities) { foreach ($entities as $object) { $this->updateObjectTranslations($entityManager, $object); } } }