PHP EntityManagerInterface::remove方法代碼示例

 /**
  * @param Schema $schema
  */
 public function down(Schema $schema)
 {
     $rep = $this->em->getRepository('AnimeDbCatalogBundle:Genre');
     foreach (array_keys($this->genres) as $en) {
         $this->em->remove($rep->findOneBy(['name' => $en]));
     }
 }

 public function delete(BaseEntityInterface $entity)
 {
     $this->entityManager->remove($entity);
     if ($this->autoFlush) {
         $this->entityManager->flush();
     }
 }

 /**
  * @param Schema $schema
  */
 public function up(Schema $schema)
 {
     $rep = $this->em->getRepository('AnimeDbCatalogBundle:Genre');
     /* @var $genre Genre */
     foreach ($this->rename as $from => $to) {
         $genre = $rep->findOneBy(['name' => $from]);
         if (is_array($to)) {
             $genre->setName($to[1])->setTranslatableLocale('ru');
             $this->em->persist($genre);
             $this->em->flush($genre);
             $to = $to[0];
         }
         $genre->setName($to)->setTranslatableLocale('en');
         $this->em->persist($genre);
     }
     // remove
     $genre = $rep->findOneBy(['name' => 'Mystery play']);
     $this->em->remove($genre);
     // rename russian
     $genre = $rep->findOneBy(['name' => 'History']);
     $genre->setName('Исторический')->setTranslatableLocale('ru');
     $this->em->persist($genre);
     $genre = $rep->findOneBy(['name' => 'War']);
     $genre->setName('Военное')->setTranslatableLocale('ru');
     $this->em->persist($genre);
     $this->em->flush();
 }

 /**
  * @param Category $category
  * @throws \Exception
  */
 public function tryDelete(Category $category)
 {
     $this->tryValidate($category);
     $this->em->transactional(function () use($category) {
         $this->em->remove($category);
     });
 }

 public function processDelete(ProcessHook $hook)
 {
     $repository = $this->entityManager->getRepository('CmfcmfMediaModule:HookedObject\\HookedObjectEntity');
     $hookedObject = $repository->getByHookOrCreate($hook);
     $this->entityManager->remove($hookedObject);
     $this->entityManager->flush();
 }

 public function execute()
 {
     $criteria = new Criteria(['owner' => $this->user], null, null, null);
     $items = $this->basketRepository->findByCriteria($criteria);
     $order = $this->orderRepository->findActive();
     $connection = $this->entityManager->getConnection();
     $connection->beginTransaction();
     try {
         $orderItems = [];
         foreach ($items as $item) {
             /** @var Basket $item */
             $previousOrderItem = $this->orderItemRepository->findOneByCriteria(new Criteria(['owner' => $item->getOwner(), 'product' => $item->getProduct()]));
             if ($previousOrderItem) {
                 /** @var OrderItem $orderItem */
                 $orderItem = $previousOrderItem;
                 $orderItem->increaseQuantityBy($item->getQuantity());
             } else {
                 $orderItem = OrderItem::createFromBasket($item, $order);
             }
             $this->entityManager->persist($orderItem);
             $this->entityManager->remove($item);
             $orderItems[] = $orderItem;
         }
         $this->entityManager->flush();
         $connection->commit();
     } catch (\Exception $e) {
         $connection->rollBack();
         return $e->getMessage();
     }
 }

 /**
  * @param object $entity
  * @param bool $doFlush
  */
 public function remove($entity, $doFlush = true)
 {
     $this->entityManager->remove($entity);
     if ($doFlush) {
         $this->entityManager->flush();
     }
 }

 /**
  * @param ModelInterface $entity
  * @return void
  */
 public function delete(ModelInterface $entity)
 {
     if (!$entity instanceof CourseInterface) {
         throw new InvalidArgumentException('expect an CourseInterface object');
     }
     $this->em->remove($entity);
     $this->em->flush();
 }

 /**
  * @param Article $article
  * @throws \Exception
  */
 public function tryDelete(Article $article)
 {
     $this->tryValidate($article);
     $this->em->transactional(function () use($article) {
         // TODO 畫像の削除処理必要
         $this->em->remove($article);
     });
 }

 /**
  * @param ResourceEntityInterface $entity
  */
 public function delete(ResourceEntityInterface $entity)
 {
     try {
         $this->em->remove($entity);
         $this->em->flush();
     } catch (ORMException $e) {
         throw new PersistenceException(self::ERROR_COULD_NOT_DELETE);
     }
 }

 /**
  * @param Contribution $contribution
  */
 public function remove(Contribution $contribution)
 {
     if (!$contribution->getFileName()) {
         return;
     }
     unlink($this->pathGenerator->getFileAbsolutePath($contribution));
     $this->entityManager->remove($contribution);
     $this->entityManager->flush();
 }

 public function remove(User $user)
 {
     try {
         $this->entityManager->remove($user);
         $this->entityManager->flush();
     } catch (DBALException $e) {
         throw new UserException('Uživatel nebyl vymazán');
     }
 }

 public function renderDeletePost()
 {
     //	$post = $this->getPostRepository()
     //			->find(1);
     // nekomunikuje s db, vyžaduje jistotu, že záznam s id existuje
     $post = $this->entityManager->getReference(Post::class, 1);
     $this->entityManager->remove($post);
     $this->entityManager->flush();
     die;
 }

 /**
  * delete entity
  * 
  * @param int $id
  * @return bool
  */
 public function delete($id)
 {
     $entity = $this->get($id);
     if (!is_null($entity)) {
         $this->entityManager->remove($entity);
         $this->entityManager->flush();
         return true;
     }
     return false;
 }

 /**
  * @inheritdoc
  */
 public function deleteFile($id)
 {
     $file = $this->getFile($id);
     if ($file === null) {
         return false;
     }
     $this->entityManager->remove($file);
     $this->entityManager->flush();
     return true;
 }