/**
  * @expectedException \RuntimeException
  * @expectedExceptionMessage Unable to find the mapping information for the class classname. Please check the 'auto_mapping' option (http://symfony.com/doc/current/reference/configuration/doctrine.html#configuration-overview) or add the bundle to the 'mappings' section in the doctrine configuration
  */
 public function testExceptionOnNonMappedEntity()
 {
     $registry = $this->getMock('Doctrine\\Common\\Persistence\\ManagerRegistry');
     $registry->expects($this->once())->method('getManagerForClass')->will($this->returnValue(null));
     $manager = new EntityManager('classname', $registry);
     $manager->getObjectManager();
 }

 /**
  * @param stdClass      $stdClass
  * @param EntityManager $manager
  *
  * @return $this
  */
 public function setFromStdClass($stdClass, $manager)
 {
     $this->id = $stdClass->id;
     $this->name = $stdClass->title;
     $this->city = $manager->find('NetworkStoreBundle:City', $stdClass->city_id);
     return $this;
 }

 /**
  * Clears old webcode
  *
  * @param EntityManager $em            Entity Manager
  * @param string        $articleNumber Article
  *
  * @return void
  */
 private function clearWebcode($em, $articleNumber, $articleLanguage)
 {
     $webcode = $em->getRepository('Newscoop\\Entity\\Webcode')->createQueryBuilder('w')->leftJoin('w.article', 'a')->where('a.number = :number')->andWhere('a.language = :language')->setParameter('number', $articleNumber)->setParameter('language', $articleLanguage)->getQuery()->getOneOrNullResult();
     if ($webcode) {
         $em->remove($webcode);
         $em->flush();
     }
 }

 /**
  * {@inheritdoc}
  */
 public function setUp()
 {
     $this->em = $this->getEntityManager();
     $this->purgeDatabase();
     $this->setUpTestData();
     $this->em->flush();
     $this->client = $this->createAuthenticatedClient();
 }

 /**
  * Counts the number of entries in each tables.
  *
  * @param EntityManager $em
  * @param int $expected
  */
 protected function assertDatabaseEntries($em, $expected)
 {
     $number = $em->getRepository(self::ENTITY_TRANS_UNIT_CLASS)->createQueryBuilder('tu')->select('COUNT(tu.id)')->getQuery()->getSingleScalarResult();
     $this->assertEquals($expected, $number);
     $number = $em->getRepository(self::ENTITY_TRANSLATION_CLASS)->createQueryBuilder('t')->select('COUNT(t.id)')->getQuery()->getSingleScalarResult();
     $this->assertEquals($expected * 2, $number);
     $number = $em->getRepository(self::ENTITY_FILE_CLASS)->createQueryBuilder('f')->select('COUNT(f.id)')->getQuery()->getSingleScalarResult();
     $this->assertEquals($expected, $number);
 }

 /**
  * Borrar todas las relaciones existentes con la entidad e
  * id de entidad origen
  * 
  * @param integer $entidadOrigen El nombre la entidad origen
  * @param integer $idOrigen El id de la entidad origen
  */
 public function eraseRelaciones($entidadOrigen, $idOrigen)
 {
     $em = new EntityManager($this->getConectionName());
     if ($em->getDbLink()) {
         $query = "delete from {$this->getDataBaseName()}.{$this->getTableName()} WHERE EntidadOrigen='{$entidadOrigen}' AND IdEntidadOrigen='{$idOrigen}'";
         $em->query($query);
         $em->desConecta();
     }
     unset($em);
 }

 /**
  * @param null $entity
  * @return EntityManager|array|object
  */
 public function getEm($entity = null)
 {
     if ($this->em === null) {
         $this->em = $this->getServiceLocator()->get('Doctrine\\ORM\\EntityManager');
     }
     if ($entity !== null) {
         return $this->em->getRepository($entity);
     }
     return $this->em;
 }

 public function setUp()
 {
     $config = new \Doctrine\ORM\Configuration();
     $config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
     $config->setQueryCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
     $config->setProxyDir(__DIR__ . '/_files');
     $config->setProxyNamespace('DoctrineExtensions\\LargeCollections\\Proxies');
     $config->setMetadataDriverImpl($config->newDefaultAnnotationDriver());
     $conn = array('driver' => 'pdo_sqlite', 'memory' => true);
     #$config->setSQLLogger(new \Doctrine\DBAL\Logging\EchoSQLLogger());
     $this->em = \Doctrine\ORM\EntityManager::create($conn, $config);
     $schemaTool = new \Doctrine\ORM\Tools\SchemaTool($this->em);
     $schemaTool->createSchema(array($this->em->getClassMetadata('DoctrineExtensions\\LargeCollections\\Article'), $this->em->getClassMetadata('DoctrineExtensions\\LargeCollections\\Tag'), $this->em->getClassMetadata('DoctrineExtensions\\LargeCollections\\Comment')));
     $article = new Article();
     $tag1 = new Tag();
     $tag2 = new Tag();
     $comment1 = new Comment();
     $comment2 = new Comment();
     $article->addComment($comment1);
     $article->addComment($comment2);
     $article->addTag($tag1);
     $article->addTag($tag2);
     $this->em->persist($article);
     $this->em->persist($tag1);
     $this->em->persist($tag2);
     $this->em->persist($comment1);
     $this->em->persist($comment2);
     $this->em->flush();
     $this->articleId = $article->id();
     $this->em->clear();
 }

 /**
  * {@inheritDoc}
  */
 public function getOrCreateUser($email, $googleId)
 {
     if ($this->isConfiguredDomain($email)) {
         $user = $this->userFinder->findUserByGoogleSignInData($email, $googleId);
         if (!$user instanceof $this->userClass) {
             //User not present in database, create new one
             $user = new $this->userClass();
             $user->setUsername($email);
             $user->setEmail($email);
             $user->setPlainPassword($googleId . $email . time());
             $user->setEnabled(true);
             $user->setLocked(false);
             $user->setAdminLocale('en');
             $user->setPasswordChanged(true);
         }
         foreach ($this->getAccessLevels($email) as $accessLevel) {
             $user->addRole($accessLevel);
         }
         $user->setGoogleId($googleId);
         // Persist
         $this->em->persist($user);
         $this->em->flush();
     }
     return isset($user) ? $user : null;
 }

 public function testconfiguration()
 {
     $config = new Configuration();
     $config->setCurrentUser($this->ZfcUserMock);
     $prefix = "prefix";
     $config->setTablePrefix($prefix);
     $suffix = "suffix";
     $config->setTableSuffix($suffix);
     $fieldName = "fieldName";
     $config->setRevisionFieldName($fieldName);
     $revisionIdFieldType = "string";
     $config->setRevisionIdFieldType($revisionIdFieldType);
     $tableName = "tableName";
     $config->setRevisionTableName($tableName);
     $revisionTypeFieldName = "string";
     $config->setRevisionTypeFieldName($revisionTypeFieldName);
     $ipaddress = $config->getIpAddress();
     $config->setAuditedEntityClasses(array('ZF2EntityAuditTest\\Entity\\Article', 'ZF2EntityAuditTest\\Entity\\Writer'));
     $config->setNote("default note");
     $this->auditManager = new Manager($config);
     $this->auditManager->registerEvents($this->em->getEventManager());
     /// creating the tables
     $this->schemaTool = $this->getSchemaTool();
     $this->schemaTool->createSchema(array($this->em->getClassMetadata('ZF2EntityAuditTest\\Entity\\Article'), $this->em->getClassMetadata('ZF2EntityAuditTest\\Entity\\Writer')));
     $this->assertInstanceOf("ZfcUser\\Entity\\User", $this->ZfcUserMock);
     $this->assertEquals($prefix, $config->getTablePrefix());
     $this->assertEquals($suffix, $config->getTableSuffix());
     $this->assertEquals($fieldName, $config->getRevisionFieldName());
     $this->assertEquals($tableName, $config->getRevisionTableName());
     $this->assertEquals($revisionIdFieldType, $config->getRevisionIdFieldType());
     $this->assertEquals($revisionTypeFieldName, $config->getRevisionIdFieldType());
     $this->assertEquals($ipaddress, "1.1.1.9");
 }

 public function savePdf()
 {
     $pnr = $this->em->getRepository('AppCoreBundle:Pnr')->find($this->id);
     if (!$pnr) {
         return \Exception('PNR not found');
     }
     //Trick to prevent cache size exceeded
     //set_time_limit(0);
     while (ob_get_level()) {
         ob_end_clean();
     }
     ob_implicit_flush(true);
     /*
      * Construct PDF with Mpdf service
      * Layout based on HTML twig template
      */
     $service = $this->tfox;
     $pdf = $service->getMpdf(array('', 'A4', 8, 'Helvetica', 10, 10, 15, 15, 9, 9, 'L'));
     $pdf->AliasNbPages('{NBPAGES}');
     $pdf->setTitle('billet-' . date('d-m-Y-H-i', time()) . '.pdf');
     $pdf->SetHeader('Billet');
     $pdf->SetFooter('{DATE j/m/Y}|{PAGENO}/{NBPAGES}');
     $html = $this->templating->renderResponse('AppCoreBundle:Pnr:billetpdf.pdf.twig', array('pnr' => $pnr));
     $pdf->WriteHTML($html);
     //$url = 'billet-'.$pnr->getNumero().'.pdf';
     //$pdf->Output($url, 'F');
     $pdf->Output();
     /*$this->get('session')->getFlashBag()->add(
     		 'success',
     				'Le billet a bien été enregistré !'
     		);*/
     //return $this->redirect($this->generateUrl('pnr_emit', array('id' => $id)));
     //return $url;
 }

 /**
  * Gather all entities in a given directory
  *
  * Assumes PSR-0/4 compliant entity class names, and an appropriate auto-loader is installed.
  *
  * @param string $dir       Directory to scan
  * @param string $namespace PSR base namespace for the directory
  * @param string $regex     Filter for file matching
  * @return string[]
  */
 public function locateEntities($dir, $namespace, $regex = '/^.+\\.php$/i')
 {
     $dir = str_replace('\\', '/', $dir);
     if (substr($dir, -1) != '/') {
         $dir .= '/';
     }
     $base_len = strlen($dir);
     $namespace = str_replace('/', '\\', $namespace);
     if (substr($namespace, -1) != '\\') {
         $namespace .= '\\';
     }
     $normaliser = $this->getNormaliser();
     $iterator = new \RegexIterator(new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($dir)), $regex, \RecursiveRegexIterator::GET_MATCH);
     $out = [];
     foreach ($iterator as $fn => $data) {
         $suffix = str_replace('/', '\\', substr($fn, $base_len));
         $class = $normaliser($namespace . $suffix);
         if (!class_exists($class)) {
             continue;
         }
         if ($this->entity_manager) {
             try {
                 $this->entity_manager->getMapper()->getEntityMetadata($class);
             } catch (\Exception $e) {
                 continue;
             }
         }
         $out[] = $class;
     }
     return $out;
 }

 /**
  * @group DDC-1439
  */
 public function testInvalidToOneJoinColumnSchema()
 {
     $class1 = $this->em->getClassMetadata(__NAMESPACE__ . '\\InvalidEntity1');
     $class2 = $this->em->getClassMetadata(__NAMESPACE__ . '\\InvalidEntity2');
     $ce = $this->validator->validateClass($class2);
     $this->assertEquals(array("The referenced column name 'id' does not have a corresponding field with this column name on the class 'Doctrine\\Tests\\ORM\\Tools\\InvalidEntity1'.", "The join columns of the association 'assoc' have to match to ALL identifier columns of the source entity 'Doctrine\\Tests\\ORM\\Tools\\InvalidEntity2', however 'key3, key4' are missing."), $ce);
 }

 public function testReverseTransform()
 {
     $transformer = $this->createTransformer();
     $tag = new Tag("name");
     $this->em->persist($tag);
     $this->em->flush();
     $this->assertSame($tag, $transformer->reverseTransform(1, null));
 }

 /**
  * Rollback changes.
  */
 public function tearDown()
 {
     $this->_em->rollback();
     @exec('php app/console syw:user:delete ' . $this->test1_username . ' >/dev/null 2>&1');
     @exec('php app/console syw:user:delete ' . $this->test2_username . ' >/dev/null 2>&1');
     parent::tearDown();
     $this->_em->close();
 }

 public function createSchema()
 {
     $metas = [];
     foreach (Deployment::instance()->models as $model) {
         $metas[] = $this->entityManager->getClassMetadata($model);
     }
     $this->schemaTool->createSchema($metas);
 }

 public function findOneById($area_id)
 {
     try {
         $area = $this->em->find(Area_tematica_dao::REPOSITORY, $area_id);
         return $area;
     } catch (Exception $ex) {
         $this->CI->log->write_log('error', $ex->getMessage() . ' - area_tematica_dao::findOneById ');
     }
 }

 public function getLastPosition($entity)
 {
     $query = $this->em->createQuery(sprintf('SELECT MAX(m.%s) FROM %s m', $positionFiles = $this->getPositionFieldByEntity($entity), $entity));
     $result = $query->getResult();
     if (array_key_exists(0, $result)) {
         return intval($result[0][1]);
     }
     return 0;
 }

 /** @test */
 public function should_add_new_group()
 {
     $this->repository->add(new Group(GroupId::generate(), 'Cribbb'));
     $this->em->clear();
     $group = $this->repository->groupOfName('Cribbb');
     $this->assertInstanceOf('Cribbb\\Domain\\Model\\Groups\\GroupId', $group->id());
     $this->assertEquals('Cribbb', $group->name());
     $this->assertEquals('cribbb', $group->slug());
 }

 public function insert(Entity\AvaliadorArea $avaliadorArea)
 {
     try {
         $this->em->persist($avaliadorArea);
         $this->em->flush();
     } catch (Exception $ex) {
         $this->CI->log->write_log('error', $ex->getMessage() . ' - avaliador_area_dao::insert ');
     }
 }