/**
* Migrate data to plugin database from core table
*
* @param EntityManager $em
* @param OutputInterface $output
*
* @return void
*/
public function migrateData($em, $output)
{
$rsm = new ResultSetMapping();
$rsm->addEntityResult('Newscoop\\CommunityTickerBundle\\Entity\\CommunityTickerEvent', 'e');
$rsm->addFieldResult('e', 'id', 'id');
$rsm->addFieldResult('e', 'event', 'event');
$rsm->addFieldResult('e', 'params', 'params');
$rsm->addFieldResult('e', 'created', 'created');
$rsm->addJoinedEntityResult('Newscoop\\Entity\\User', 'u', 'e', 'user');
$rsm->addFieldResult('u', 'Id', 'id');
$query = $em->createNativeQuery('SELECT e.id, e.event, e.params, e.created, u.Id FROM community_ticker_event e ' . 'LEFT JOIN liveuser_users u ON u.id = e.user_id', $rsm);
$events = $query->getArrayResult();
foreach ($events as $key => $event) {
$user = $em->getRepository('Newscoop\\Entity\\User')->findOneBy(array('id' => $event['user']['id']));
$existingEvent = $em->getRepository('Newscoop\\CommunityTickerBundle\\Entity\\CommunityTickerEvent')->findOneBy(array('created' => $event['created'], 'params' => $event['params']));
if (!$existingEvent) {
$newEvent = new CommunityTickerEvent();
$newEvent->setEvent($event['event']);
$newEvent->setParams($event['params'] != '[]' ? json_decode($event['params'], true) : array());
$newEvent->setCreated($event['created']);
$newEvent->setIsActive(true);
if ($user) {
$newEvent->setUser($user);
}
$em->persist($newEvent);
}
}
$em->flush();
$output->writeln('<info>Data migrated to plugin table!</info>');
$output->writeln('<info>Removing old table...</info>');
}
/**
* The event handler function for callback function.
* Convert audion file
* @param AMQPMessage $msg
*/
public function execute(AMQPMessage $msg)
{
$session = (int) unserialize($msg->body)['session'];
$job = $this->container->getRepository('masterofcodeBundle:Job')->find($session);
if (!$job) {
throw new NotFoundHttpException("System error: cannot use given session id");
}
$this->setStatus($job, 1);
try {
$format = new Flac();
$format->setAudioChannels(2)->setAudioKiloBitrate(128);
$audio = FFMpeg::create()->open($job->getPath());
$audio->save($format, $job->getDownloadPath());
} catch (Exception $e) {
$this->setStatus($job, 3);
throw new NotFoundHttpException("System error: cannot convert file.");
}
$this->setStatus($job, 2);
echo 'File ' . $job->getPath() . ' has been converted! Session #' . $job->getId() . "\n";
}
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;
}
public function testRemoveStock()
{
$productBefore = $this->_em->getRepository('DreamStoreSellerBundle:Product')->findOneById(1);
$stockBefor = $productBefore->getStock();
$table = ['operation' => 'remove', 'stock' => 5];
$home = new HomeController();
$productAfter = $home->addNewStock($productBefore, $table);
$this->assertEquals($stockBefor - 5, $productAfter->getStock());
}
/**
* 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);
}
protected function getRoleChoices()
{
$roots = $this->em->getRepository('FpUserBundle:Role')->findAll();
$choices = array();
foreach ($roots as $role) {
$choices[$role->getId()] = $role;
}
return $choices;
}
/**
* {@inheritDoc}
*/
public function load($id = 0, $version = 1)
{
$this->subject = $this->em->getRepository('OpiferContentBundle:Template')->find($id);
$this->version = $version;
if (!$this->subject) {
throw $this->createNotFoundException('No template found for id ' . $id);
}
return $this;
}
/**
* @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;
}
/**
* @var string slug
* @throws NotFoundHttpException
*
* @Route("/author/{slug}")
* @Template()
* @return array
*/
public function showAction($slug)
{
$author = $this->em->getRepository('ModelBundle:Author')->findOneBy(array('slug' => $slug));
if ($author == null) {
throw $this->createNotFoundException('Author Not Found');
} else {
$posts = $this->em->getRepository('ModelBundle:Post')->findBy(array('author' => $author));
}
return array('author' => $author, 'posts' => $posts);
}
public function testHistorical()
{
$product = $this->_em->getRepository('DreamStoreSellerBundle:Product')->findOneById(1);
$quantity = 50;
$userName = '******';
$token = 'z49er8c4z9ec';
$status = 'en cours';
$payment = new PaymentController();
$historical = $payment->historical($product, $quantity, $userName, $token, $status);
$this->assertInstanceOf('DreamStore\\CustomerBundle\\Entity\\Historical', $historical);
}
/**
* {@inheritDoc}
*/
public function findUserByGoogleSignInData($email, $googleId)
{
//Check if already logged in before via Google auth
$user = $this->em->getRepository($this->userClass)->findOneBy(array('googleId' => $googleId));
if (!$user instanceof $this->userClass) {
//Check if Email was already present in database but not logged in via Google auth
$user = $this->em->getRepository($this->userClass)->findOneBy(array('email' => $email));
if (!$user instanceof $this->userClass) {
//Last chance try looking for email address in username field
$user = $this->em->getRepository($this->userClass)->findOneBy(array('username' => $email));
}
}
return $user;
}
/**
* 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();
}
}
public function testFindingRepositoryClasses()
{
/// its useless now , but i will work on it soon
$WriterRepository = $this->em->getRepository("ZF2EntityAuditTest\\Entity\\Writer");
$ArticleRepository = $this->em->getRepository("ZF2EntityAuditTest\\Entity\\Article");
$this->assertEquals("Doctrine\\ORM\\EntityRepository", get_class($WriterRepository));
$this->assertEquals("Doctrine\\ORM\\EntityRepository", get_class($ArticleRepository));
}
/**
* @depends testReverseTransformNewKnownEntity
*/
public function testReverseTransformNewUnknownEntity()
{
$transformer = $this->createTransformer();
$tags = $this->createTagCollection();
$tags = $transformer->reverseTransform("foo, bar, baz", $tags);
$this->assertEquals(3, count($tags));
$this->em->flush();
$this->assertSame($this->em, $transformer->getOption('em'));
$this->assertEquals(1, count($this->em->getRepository('Symfony\\Bundle\\DoctrineBundle\\Tests\\Form\\ValueTransformer\\Tag')->findAll()));
}
/**
/**
* Create comment
*
* @param Request $request
* @param string $slug
* @throws NotFoundHttpException
* @return array
*
* @Route("/{slug}/create-comment")
* @Method("POST")
* @Template("CoreBundle:Post:show.html.twig")
*/
public function createCommentAction(Request $request, $slug)
{
// exit(\Doctrine\Common\Util\Debug::dump($slug));
// var_dump($request); exit;
$post = $this->em->getRepository('ModelBundle:Post')->findOneBy(array('slug' => $slug));
if ($post === null) {
throw createNotFoundException('Post Was Not Found');
}
$comment = new Comment();
$comment->setPost($post);
$form = $this->createForm(new CommentType(), $comment);
$form->handleRequest($request);
if ($form->isValid()) {
$this->em->persist($comment);
$this->em->flush();
$this->get('session')->getFlashBag()->add('success', 'Your comment was submitted successfully');
return $this->redirect($this->generateUrl('blog_core_post_show', array('slug' => $post->getSlug())));
}
return array('post' => $post, 'form' => $form->createView());
}
public function testDisallowChoicesThatAreNotIncluded_queryBuilder_singleIdentifier()
{
$entity1 = new SingleIdentEntity(1, 'Foo');
$entity2 = new SingleIdentEntity(2, 'Bar');
$entity3 = new SingleIdentEntity(3, 'Baz');
$this->persist(array($entity1, $entity2, $entity3));
$repository = $this->em->getRepository(self::SINGLE_IDENT_CLASS);
$field = new EntityChoiceField('name', array('em' => $this->em, 'class' => self::SINGLE_IDENT_CLASS, 'query_builder' => $repository->createQueryBuilder('e')->where('e.id IN (1, 2)'), 'property' => 'name'));
$field->submit('3');
$this->assertFalse($field->isTransformationSuccessful());
$this->assertNull($field->getData());
}
/**
* Get the content by a reference
*
* If the passed reference is a numeric, it must be the content ID from a
* to-be-updated content item.
* If not, the reference must be the template name for a to-be-created
* content item.
*
* @param int|string $reference
*
* @return ContentInterface
*/
public function getContentByReference($reference)
{
if (is_numeric($reference)) {
// If the reference is numeric, it must be the content ID from an existing
// content item, which has to be updated.
$nestedContent = $this->getRepository()->find($reference);
} else {
// If not, $reference is a template name for a to-be-created content item.
$template = $this->em->getRepository($this->templateClass)->findOneByName($reference);
$nestedContent = $this->eavManager->initializeEntity($template);
$nestedContent->setNestedDefaults();
}
return $nestedContent;
}
/**
* Construct an ORM Query Builder Loader
*
* @param QueryBuilder|\Closure $queryBuilder
* @param EntityManager $manager
* @param string $class
*/
public function __construct($queryBuilder, $manager = null, $class = null)
{
// If a query builder was passed, it must be a closure or QueryBuilder
// instance
if (!($queryBuilder instanceof QueryBuilder || $queryBuilder instanceof \Closure)) {
throw new UnexpectedTypeException($queryBuilder, 'Doctrine\\ORM\\QueryBuilder or \\Closure');
}
if ($queryBuilder instanceof \Closure) {
$queryBuilder = $queryBuilder($manager->getRepository($class));
if (!$queryBuilder instanceof QueryBuilder) {
throw new UnexpectedTypeException($queryBuilder, 'Doctrine\\ORM\\QueryBuilder');
}
}
$this->queryBuilder = $queryBuilder;
}
/**
* Get a marketProduct record for an incoming product, if it does not exist, create it
*
* @param IncomingProduct $product
*
* @return MarketProduct
*
* @throws \Exception
*/
protected function getMarketProduct(IncomingProduct $product)
{
$market = $this->getMarket();
$marketProduct = $this->entityManager->getRepository('AppBundle:MarketProduct')->findOneBy(['market' => $market, 'foreignId' => $product->getMarketId()]);
if ($marketProduct) {
return $marketProduct;
}
$variant = $this->getProductVariantRecord($product);
$marketProduct = new MarketProduct();
$marketProduct->setMarket($market);
$marketProduct->setForeignId($product->getMarketId());
$marketProduct->setProductVariantSku($variant);
$this->entityManager->persist($marketProduct);
$this->entityManager->flush();
return $marketProduct;
}
/**
* Gets all relations of the query.
*
* @return array
*/
public function getRelations()
{
$relations = [];
foreach ($this->relations as $name => $constraints) {
if (strpos($name, '.') === false) {
$mapping = $this->metadata->getRelationMapping($name);
$query = $this->manager->getRepository($mapping['targetEntity'])->query();
if ($nested = $this->getNestedRelations($name)) {
$query->related($nested);
}
call_user_func($constraints, $query);
$relations[$name] = $query;
}
}
return $relations;
}
/**
* get all overviews
*
* @return array
*/
private function generateAllOverviews()
{
$configRepository = $this->em->getRepository('KunstmaanDashboardBundle:AnalyticsConfig');
$overviewRepository = $this->em->getRepository('KunstmaanDashboardBundle:AnalyticsOverview');
$segmentRepository = $this->em->getRepository('KunstmaanDashboardBundle:AnalyticsSegment');
$configs = $configRepository->findAll();
foreach ($configs as $config) {
// add overviews if none exist yet
if (!count($configRepository->findDefaultOverviews($config))) {
$overviewRepository->addOverviews($config);
}
// init all the segments for this config
$segments = $config->getSegments();
foreach ($segments as $segment) {
$segmentRepository->initSegment($segment);
}
}
}
/**
* @param integer $ownerId
* @param integer $rootVersion
*/
public function discardAll($ownerId)
{
$owner = $this->find($ownerId);
if (!$owner instanceof BlockOwnerInterface) {
throw new \Exception('Discard all changes is only possible on Block owners');
}
$this->killLoggableListener();
$this->killSoftDeletableListener();
$this->em->getRepository('OpiferContentBundle:BlockLogEntry')->discardAll($ownerId);
if ($this->em->getFilters()->isEnabled('softdeleteable')) {
$this->em->getFilters()->disable('softdeleteable');
}
$stubs = $this->getRepository()->findBy(['owner' => $owner, 'version' => 0]);
foreach ($stubs as $stub) {
$this->em->remove($stub);
}
$this->em->flush();
}
/**
* get all segments
*
* @return array
*/
private function getAllSegments()
{
// get all segments
$segmentRepository = $this->em->getRepository('KunstmaanDashboardBundle:AnalyticsSegment');
return $segmentRepository->findAll();
}
/**
* Get repository.
*
* @return \Doctrine\ORM\EntityRepository
*/
public function getRepository()
{
return $this->em->getRepository($this->getClass());
}
/**
* get all overviews
*
* @return array
*/
private function getAllOverviews()
{
// get all overviews
$overviewRepository = $this->em->getRepository('KunstmaanDashboardBundle:AnalyticsOverview');
return $overviewRepository->findAll();
}
/**
* Get all articles from Database
* Get All Articles FROM Database
*
* @param EntityManager $em EntityManager from Controller
* @param DoctrineManager $em
* @return {Collection}
*/
public function getAllArticles($em)
{
$articles = $em->getRepository('SpaSpaBundle:Articles')->findAll();
if (!$articles) {
throw $this->createNotFoundException("Erreur lors de la récupération des articles");
}
return $articles;
}
/**
* Get a list of Pages.
*
* @param int $userId The user identifier.
* @param int $limit the limit of the result
* @param int $offset starting from the offset
*
* @return array
*/
public function getUserById($userId, $limit = 5, $offset = 0)
{
$dataRepositoryUser = $this->entityManagerUsers->getRepository('AcmeBlogBundle:User');
$user = $dataRepositoryUser->findUserById($userId, $offset, $limit);
return $user;
}
public function __construct($class, EntityManager $em)
{
$this->class = $class;
$this->repository = $em->getRepository($class);
}
/**
* @param Request $request
* @param Response $response
* @param array $args
*
* @return Response
*/
public function listAction(Request $request, Response $response, array $args)
{
$entities = $this->em->getRepository($this->entityClass)->findAll();
$response->setContent($this->twig->render($this->views['list'], ['entities' => $entities]));
return $response;
}
public function getBlogUser()
{
return $this->em->getRepository('HeliosManagerBundle:Blog')->findOneByUser($this->container->get('security.context')->getToken()->getUser());
}
