private function createActivityType(EntityManagerInterface $em)
 {
     $activityType = new ResourceType();
     $activityType->setName('activity');
     $em->persist($activityType);
     $em->flush();
 }

 /**
  * @param EntityManager $em
  * @param Cache $cache
  * @param CacheHitsContainer $hitsContainer
  */
 public function __construct(EntityManagerInterface $em, Cache $cache, CacheHitsContainer $hitsContainer)
 {
     $this->em = $em;
     $this->connection = $em->getConnection();
     $this->cache = $cache;
     $this->hitsContainer = $hitsContainer;
 }

 /**
  * @param $fileName
  * @return bool
  */
 protected function uniqueNameExists($fileName, EntityManagerInterface $em)
 {
     $dql = "SELECT COUNT(image) FROM EDVFileBundle:EdImage AS image WHERE image.hashString = :name";
     $query = $em->createQuery($dql)->setParameters(array('name' => $fileName));
     $result = $query->getSingleScalarResult();
     return $result > 0;
 }

 public function it_performs_a_fulltext_query(EntityManagerInterface $entityManager, AbstractQuery $query, $result = [])
 {
     $entityManager->createQuery(Argument::any())->shouldBeCalled()->willReturn($query);
     $query->setParameter(Argument::any(), Argument::any())->shouldBeCalled()->willReturn($query);
     $query->getResult()->shouldBeCalled()->willReturn($result);
     $this->query('black', $entityManager)->shouldBeArray();
 }

 /**
  * Returns the global entity manager.
  *
  * @return \Doctrine\ORM\EntityManagerInterface
  */
 public function getEntityManager()
 {
     if ($this->entityManager === null || !$this->entityManager->isOpen()) {
         $this->entityManager = $this->createEntityManager();
     }
     return $this->entityManager;
 }

 function it_handles_a_delete_command(Entity $entity, Delete $command, EntityManagerInterface $em)
 {
     $command->getEntity()->willReturn($entity);
     $em->remove($entity)->shouldBeCalled();
     $em->flush()->shouldBeCalled();
     $this->handle($command);
 }

 function it_handles_a_find_all_query(FindAll $query, EntityRepository $repository, EntityManagerInterface $em)
 {
     $query->getEntityClass()->willReturn('Indigo\\Crud\\Stub\\Entity');
     $repository->findAll()->shouldBeCalled();
     $em->getRepository('Indigo\\Crud\\Stub\\Entity')->willReturn($repository);
     $this->handle($query);
 }

 /**
  * Create a new repository instance for an entity class.
  *
  * @param \Doctrine\ORM\EntityManagerInterface $entityManager The EntityManager instance.
  * @param string                               $entityName    The name of the entity.
  *
  * @return \Doctrine\Common\Persistence\ObjectRepository
  */
 private function createRepository(EntityManagerInterface $entityManager, $entityName)
 {
     /* @var $metadata \Doctrine\ORM\Mapping\ClassMetadata */
     $metadata = $entityManager->getClassMetadata($entityName);
     $repositoryClassName = $metadata->customRepositoryClassName ?: $entityManager->getConfiguration()->getDefaultRepositoryClassName();
     return new $repositoryClassName($entityManager, $metadata);
 }

 /**
  * @param EntityManagerInterface $em
  */
 public function __construct(EntityManagerInterface $em)
 {
     $params = $em->getConnection()->getParams();
     $dsn = "mysql:host={$params['host']};dbname={$params['dbname']}";
     $this->pdo = new PDO($dsn, $params['user'], $params['password']);
     $this->pdo->setAttribute(PDO::ATTR_ORACLE_NULLS, PDO::NULL_NATURAL);
 }

 /**
  * @param EntityManagerInterface $entityManager
  * @param UserManagerInterface $userManager
  * @param ValidatorInterface $validator
  */
 public function __construct(EntityManagerInterface $entityManager, UserManagerInterface $userManager, ValidatorInterface $validator)
 {
     $this->entityManager = $entityManager;
     $this->userRepository = $entityManager->getRepository('AppBundle:User');
     $this->userManager = $userManager;
     $this->validator = $validator;
 }

 /**
  * @param string $token
  *
  * @return Boolean
  */
 protected function isUsedCode($token)
 {
     $this->manager->getFilters()->disable('softdeleteable');
     $isUsed = null !== $this->repository->findOneBy(array('confirmationToken' => $token));
     $this->manager->getFilters()->enable('softdeleteable');
     return $isUsed;
 }

 /**
  * {@inheritdoc}
  */
 public function convert($value)
 {
     if ($value) {
         return $this->em->getReference($this->entityClass, $value);
     }
     return null;
 }

 /**
  * Creates schema for doctrine entities
  *
  * @throws \Doctrine\ORM\Tools\ToolsException
  */
 protected function createDoctrineSchema()
 {
     $metadata = $this->entityManager->getMetadataFactory()->getAllMetadata();
     $tool = new SchemaTool($this->entityManager);
     $tool->dropSchema($metadata);
     $tool->createSchema($metadata);
 }

 /**
  * @inheritdoc
  */
 public function delete(UserModel $user) : UserModel
 {
     $user->delete();
     $this->em->persist($user);
     $this->em->flush();
     return $user;
 }

 /**
  * @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 onRender(RendererEvent $event)
 {
     $renderer = $event->getRenderer();
     $content = $renderer->getObject();
     $links = $content->getParamValue('link');
     $link = ['url' => '', 'title' => 'Visit', 'target' => '_self'];
     if (!empty($links)) {
         $links = reset($links);
         if (isset($links['pageUid']) && !empty($links['pageUid'])) {
             $page = $this->entityManager->getRepository('BackBee\\CoreDomain\\NestedNode\\Page')->find($links['pageUid']);
             if ($page !== null) {
                 $link['url'] = $page->getUrl();
             }
         }
         if (empty($link['url']) && isset($links['url'])) {
             $link['url'] = $links['url'];
         }
         if (isset($links['title'])) {
             $link['title'] = $links['title'];
         }
         if (isset($links['target'])) {
             $link['target'] = $links['target'];
         }
     }
     $renderer->assign('link', $link);
 }

 /**
  * Renueva el alquiler.
  *
  * @param Rental $rental
  *
  * @return Rental
  */
 public function renewRental(Rental $rental)
 {
     if ($rental->getReturnAt()) {
         throw new FinishedRentalException();
     }
     if ($rental->getUser()->getIsPenalized()) {
         throw new PenalizedUserException();
     }
     if ($rental->getUser()->getFaculty()->getIsEnabled() === false) {
         throw new PenalizedFacultyException();
     }
     if (!$rental->getIsRenewable()) {
         throw new NotRenewableRentalException();
     }
     if ($rental->getIsExpired()) {
         throw new ExpiredRentalException();
     }
     if ($rental->getDaysLeft() > $this->days_before_renovation) {
         throw new TooEarlyRenovationException();
     }
     $left = $rental->getDaysLeft() + $this->days_length_rental;
     $rental->setEndAt(new \DateTime($left . ' days midnight'));
     $this->manager->persist($rental);
     $this->manager->flush();
     $event = new RentalEvent($rental);
     $this->dispatcher->dispatch(RentalEvents::LOCKER_RENEWED, $event);
     return $rental;
 }

 /**
  * Activates new user by activation code
  *
  * @param string $code
  *
  * @throws IOException
  */
 public function activate($code)
 {
     $user = $this->userRepository->findOneBy(['code' => $code, 'frozen' => true]);
     $user->activate();
     $this->entityManager->persist($user);
     $this->entityManager->flush();
 }

 public function getFreeWorkTimes(User $user, \DateTime $date = null)
 {
     $allTimes = [];
     //if($date)
     //{
     $startTime = new \DateTime($date->format('Y-m-d H:i'));
     $endTime = new \DateTime($date->format('Y-m-d H:i'));
     $startTime->setTime($user->getStartTime()->format('H'), $user->getStartTime()->format('i'));
     $endTime->setTime($user->getEndTime()->format('H'), $user->getEndTime()->format('i'));
     //}else
     //{
     //    $startTime = new \DateTime($user->getStartTime()->format('H:i'));
     //    $endTime = new \DateTime($user->getEndTime()->format('H:i'));
     //}
     $busyTimes = $this->em->getRepository('WorkerBundle:WorkTime')->getUserBusyTimes($user->getId());
     while ($startTime < $endTime) {
         if ($startTime > new \DateTime()) {
             //    if ($date) {
             $allTimes[] = $startTime->format('Y-m-d H:i');
             //    } else {
             //          $allTimes[] = date('Y-m-d') . ' ' . $startTime->format('H:i');
             //   }
         }
         $startTime->modify('+1hour');
     }
     return $this->removeBlockedTimes($allTimes, $busyTimes);
 }

 public function createMessage($text, $username, $email = null)
 {
     $message = new GuestBookMessage();
     $message->setText($text)->setUsername($username)->setEmail($email);
     $this->manager->persist($message);
     $this->manager->flush();
 }