Closes the EntityManager. All entities that are currently managed
by this EntityManager become detached. The EntityManager may no longer
be used after it is closed.
public close ( ) |
/** * {@inheritDoc} */ protected function tearDown() { parent::tearDown(); if ($this->em instanceof \Doctrine\ORM\EntityManager) { $this->em->close(); } }
/** * {@inheritDoc} */ protected function tearDown() { parent::tearDown(); if (!is_null($this->em)) { $this->em->close(); } }
/** * {@inheritDoc} */ protected function tearDown() { parent::tearDown(); $this->em->close(); $this->em = null; // avoid memory leaks }
public function allBooks() { try { $book = $this->em->getRepository('BooksApiBookBundle:BooksEntity')->findAll(); } catch (\Exception $ex) { $this->em->close(); throw new QueryException('003', 502); } return $book; }
/** * {@inheritDoc} */ protected function tearDown() { parent::tearDown(); $this->em->close(); //cerrar emMod /*$this->emMod = static::$kernel->getContainer() ->get('doctrine') ->getManager(); $this->emMod->close();*/ }
/** * @after */ protected function tearDownDoctrine() { $this->doctrine = null; if ($this->em) { $this->em->close(); $this->em = null; } $this->loader = null; $this->container = null; }
/** * close Doctrine Dbal and ORM connection and reset everything to default. */ public function close() { $this->Conn->close(); if (is_object($this->EntityManager) && method_exists($this->EntityManager, 'close')) { $this->EntityManager->close(); } if (function_exists('gc_collect_cycles')) { gc_collect_cycles(); } $this->Conn = ''; $this->EntityManager = ''; $this->table_prefix = ''; $this->table_siteid_prefix = ''; }
/** * @param $title * @param $price * @param $description * @throws QueryException */ public function createBook($title, $price, $description) { $book = new BooksEntity(); $book->setTitle($title); $book->setPrice($price); $book->setDescription($description); try { $this->em->persist($book); $this->em->flush(); return true; } catch (\Exception $ex) { $this->em->close(); throw new QueryException('003', 502); } }
public function restartDoctrine() { $enabled_filters = array(); if (isset($this->entity_manager)) { $filters = $this->entity_manager->getFilters(); foreach ($filters->getEnabledFilters() as $filter_name => $filter) { $filter_class = get_class($filter); $enabled_filters[$filter_name] = array($filter_class => $filter->__toString()); } @$this->entity_manager->close(); unset($this->entity_manager); } $em = $this->getDoctrine(); foreach ($enabled_filters as $filter_name => $filter) { foreach ($filter as $filter_class => $filter_params_string) { $em->getConfiguration()->addFilter($filter_name, $filter_class); $this_filter = $em->getFilters()->enable($filter_name); $filter_params = @unserialize($filter_params_string); if ($filter_params) { foreach ($filter_params as $filter_param => $filter_value) { if (isset($filter_value['value'])) { $this_filter->setParameter($filter_param, $filter_value['value']); } } } } } }
/** * {@inheritDoc} */ protected function tearDown() { parent::tearDown(); $this->em->remove($this->user); $this->em->close(); //unset($this->user); // }
/** * @param \Venne\Module\IModule $module */ public function uninstall(IModule $module) { if (!$this->context->hasService('doctrine') || !$this->context->doctrine->createCheckConnection()) { throw new \Exception('Database connection not found!'); } $classes = $this->getClasses($module); $metadata = array(); foreach ($classes as $class) { $metadata[] = $this->entityManager->getClassMetadata($class); } $tool = new \Doctrine\ORM\Tools\SchemaTool($this->entityManager); $this->entityManager->getConnection()->beginTransaction(); try { foreach ($classes as $class) { $repository = $this->entityManager->getRepository($class); foreach ($repository->findAll() as $entity) { $repository->delete($entity); } } $tool->dropSchema($metadata); $this->entityManager->getConnection()->commit(); } catch (Exception $e) { $this->entityManager->getConnection()->rollback(); $this->entityManager->close(); throw $e; } $this->cleanCache(); }
/** * {@inheritdoc} */ public function close() { $evm = $this->getEventManager(); if ($evm->hasListeners(Events::preClose)) { $evm->dispatchEvent(Events::preClose, new PreCloseEventArgs($this)); } parent::close(); }
/** * {@inheritDoc} * * @see PHPUnit_Framework_TestCase::tearDownAfterClass() * * @uses KernelTestCase::ensureKernelShutdown() */ public static function tearDownAfterClass() { parent::ensureKernelShutdown(); static::$em->close(); static::$em = null; // avoid memory leaks static::$repository->clear(); static::$repository = null; }
/** * Drop the entity manager * @return void */ public function dropEntityManager() { if ($this->entityManager != null) { $this->entityManager->getConnection()->close(); $this->entityManager->close(); } unset($this->entityManager); unset($this->fixtureReferenceRepo); }
/** * вывести деньги * * @ApiDoc( * section="Billing API", * input="Vifeed\PaymentBundle\Form\WithdrawalType", * output={ * "class"="Vifeed\PaymentBundle\Entity\Withdrawal", * "groups"={"default"} * }, * resource=true, * statusCodes={ * 201="Returned when successful", * 400="Returned when something is wrong", * 403="Returned when the user is not authorized to use this method" * } * ) * * @return Response */ public function putWithdrawalAction() { $form = $this->createForm(new WithdrawalType()); $form->submit($this->get('request')); if ($form->isValid()) { /** @var Withdrawal $withdrawal */ $withdrawal = $form->getData(); if ($withdrawal->getWallet()->getUser() != $this->getUser()) { throw new AccessDeniedHttpException('Можно вывести только на свой кошелёк'); } if ($withdrawal->getAmount() > $this->getUser()->getBalance()) { $form->get('amount')->addError(new FormError('Недостаточно денег на балансе')); } else { $userRepo = $this->em->getRepository('VifeedUserBundle:User'); $this->em->beginTransaction(); $this->em->lock($this->getUser(), LockMode::PESSIMISTIC_WRITE); try { $withdrawal->setUser($this->getUser())->setStatus(Withdrawal::STATUS_CREATED); $this->em->persist($withdrawal); $userRepo->updateBalance($this->getUser(), -$withdrawal->getAmount()); $this->em->flush(); $this->em->commit(); } catch (\Exception $e) { $this->em->rollback(); $this->em->close(); throw $e; } $mailer = $this->get('vifeed.mailer'); $message = $mailer->renderMessage('VifeedPaymentBundle:Email:withdrawal.html.twig', ['withdrawal' => $withdrawal]); $mailer->sendMessage('Запрос на вывод средств', $message, $this->container->getParameter('withdrawal.notification.email')); $context = new SerializationContext(); $context->setGroups(array('default')); $view = new View($withdrawal, 201); $view->setSerializationContext($context); } } if (!$form->isValid()) { $view = new View($form, 400); } return $this->handleView($view); }
/** * {@inheritdoc} */ public function close() { return $this->wrapped->close(); }
/** * {@inheritDoc} */ public static function tearDownAfterClass() { self::$em->close(); parent::tearDownAfterClass(); }
/** * @inheritdoc */ public function stop() { parent::stop(); $this->entityManager->flush(); $this->entityManager->close(); }
/** * Cleans up the environment after running a test. */ protected function tearDown() { parent::tearDown(); $this->em->close(); $this->registryRepository = null; }
protected function tearDown() { $this->em->close(); unset($this->client, $this->em); }
/** * {@inheritdoc} */ protected function tearDown() { parent::tearDown(); $this->em->close(); unset($this->em, $this->container, $this->client, $this->encoder); }
/** * tear down */ public function tearDown() { parent::tearDown(); $this->em->close(); }
public function onDestroy(Event $event) { if ($this->_entityManager) { $this->_entityManager->close(); } }
public static function tearDownAfterClass() { self::$tool->dropSchema(self::$userClasses); self::$em->close(); }
/** * {@inheritDoc} * * @static */ public static function close() { return \Doctrine\ORM\EntityManager::close(); }
/** * {@inheritDoc} */ protected function tearDown() { $this->em->rollback(); parent::tearDown(); $this->em->close(); }
/** * Commits the UnitOfWork, executing all operations that have been postponed * up to this point. The state of all managed entities will be synchronized with * the database. * * The operations are executed in the following order: * * 1) All entity insertions * 2) All entity updates * 3) All collection deletions * 4) All collection updates * 5) All entity deletions * * @param null|object|array $entity * * @return void * * @throws \Exception */ public function commit($entity = null) { // Raise preFlush if ($this->evm->hasListeners(Events::preFlush)) { $this->evm->dispatchEvent(Events::preFlush, new PreFlushEventArgs($this->em)); } // Compute changes done since last commit. if ($entity === null) { $this->computeChangeSets(); } elseif (is_object($entity)) { $this->computeSingleEntityChangeSet($entity); } elseif (is_array($entity)) { foreach ($entity as $object) { $this->computeSingleEntityChangeSet($object); } } if (!($this->entityInsertions || $this->entityDeletions || $this->entityUpdates || $this->collectionUpdates || $this->collectionDeletions || $this->orphanRemovals)) { $this->dispatchOnFlushEvent(); $this->dispatchPostFlushEvent(); return; // Nothing to do. } if ($this->orphanRemovals) { foreach ($this->orphanRemovals as $orphan) { $this->remove($orphan); } } $this->dispatchOnFlushEvent(); // Now we need a commit order to maintain referential integrity $commitOrder = $this->getCommitOrder(); $conn = $this->em->getConnection(); $conn->beginTransaction(); try { if ($this->entityInsertions) { foreach ($commitOrder as $class) { $this->executeInserts($class); } } if ($this->entityUpdates) { foreach ($commitOrder as $class) { $this->executeUpdates($class); } } // Extra updates that were requested by persisters. if ($this->extraUpdates) { $this->executeExtraUpdates(); } // Collection deletions (deletions of complete collections) foreach ($this->collectionDeletions as $collectionToDelete) { $this->getCollectionPersister($collectionToDelete->getMapping())->delete($collectionToDelete); } // Collection updates (deleteRows, updateRows, insertRows) foreach ($this->collectionUpdates as $collectionToUpdate) { $this->getCollectionPersister($collectionToUpdate->getMapping())->update($collectionToUpdate); } // Entity deletions come last and need to be in reverse commit order if ($this->entityDeletions) { for ($count = count($commitOrder), $i = $count - 1; $i >= 0 && $this->entityDeletions; --$i) { $this->executeDeletions($commitOrder[$i]); } } $conn->commit(); } catch (Exception $e) { $this->em->close(); $conn->rollback(); $this->afterTransactionRolledBack(); throw $e; } $this->afterTransactionComplete(); // Take new snapshots from visited collections foreach ($this->visitedCollections as $coll) { $coll->takeSnapshot(); } $this->dispatchPostFlushEvent(); // Clear up $this->entityInsertions = $this->entityUpdates = $this->entityDeletions = $this->extraUpdates = $this->entityChangeSets = $this->collectionUpdates = $this->collectionDeletions = $this->visitedCollections = $this->scheduledForDirtyCheck = $this->orphanRemovals = array(); }
public function close() { if ($this->panel) { $this->panel->snapshotUnitOfWork($this); } parent::close(); }
/** * {@inheritDoc} */ protected function tearDown() { parent::tearDown(); $this->em->close(); }
/** * Destroy */ public function tearDown() { $tool = new SchemaTool($this->entityManager); $this->dropSchema($tool); $this->entityManager->close(); }