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);
}
}
}
