/**
  * @Route("/create", name="create_objects")
  *
  * @Rest\View()
  *
  * @return Response
  */
 public function createAction()
 {
     // We need an entity manager here
     $em = $this->getDoctrine()->getManager();
     // First, we try to create a post
     $post = new Post();
     $post->setTitle('Hello World');
     $post->setContent('This is a hello world post');
     $post->setCreated(new \DateTime());
     $em->persist($post);
     // Create new post log object
     $postLog = new PostLog();
     $postLog->setMessage('A new post was created');
     $postLog->setCreated(new \DateTime());
     $postLog->setParent($post);
     $em->persist($postLog);
     // Try to create a category
     $category = new Category();
     $category->setTitle('A Category');
     $category->setDescription('A category to created');
     $em->persist($category);
     // Create new category log object
     $categoryLog = new CategoryLog();
     $categoryLog->setMessage('A new category was created');
     $categoryLog->setCreated(new \DateTime());
     $categoryLog->setParent($category);
     $em->persist($categoryLog);
     // Actually store all the entities to the database
     // to get id of the post and the category
     $em->flush();
     return ['Done'];
 }

 /**
  * @Route("/post/add/{id}", name="addPost")
  */
 public function addAction($id, Request $request)
 {
     $em = $this->getDoctrine()->getManager();
     $topic = $em->getRepository('AppBundle:Topic')->find($id);
     if (!$topic) {
         throw $this->createNotFoundException('No Topic found for id ' . $id);
     }
     $post = new Post();
     $post->setDate(new \DateTime('now'));
     $loggedIn = false;
     $securityContext = $this->container->get('security.authorization_checker');
     if ($securityContext->isGranted('IS_AUTHENTICATED_FULLY')) {
         $token = $this->get('security.token_storage')->getToken();
         /* @var $user User */
         $user = $token->getUser();
         $post->setAuthor($user);
         $post->setTopic($topic);
         $loggedIn = true;
     }
     $form = $this->createFormBuilder($post)->add('content', TextareaType::class)->add('save', SubmitType::class, array('label' => 'Reply'))->getForm();
     $form->handleRequest($request);
     if ($form->isSubmitted() && $form->isValid()) {
         $em->persist($post);
         $em->flush();
         return $this->render('Topic/watch.html.twig', array('topic' => $topic, 'form' => $form->createView(), 'loggedIn' => $loggedIn));
     }
     return $this->render('Post/add.html.twig', array('topic' => $topic, 'form' => $form->createView(), 'loggedIn' => $loggedIn));
 }

 private function loadPosts(ObjectManager $manager)
 {
     $passwordEncoder = $this->container->get('security.password_encoder');
     $user = new User();
     $user->setUsername('vvasia');
     $user->setDisplayName('Vasia Vasin');
     $user->setEmail('[email protected]');
     $user->setUuid('uuid');
     $encodedPassword = $passwordEncoder->encodePassword($user, 'password');
     $user->setPassword($encodedPassword);
     $user->setRoles(['ROLE_USER']);
     $manager->persist($user);
     $manager->flush();
     /** @var User $author */
     $author = $manager->getRepository('AppBundle:User')->findOneBy(['email' => '[email protected]']);
     foreach (range(1, 10) as $i) {
         $post = new Post();
         $post->setTitle($this->getRandomPostTitle() . ' ' . uniqid())->setSummary($this->getRandomPostSummary())->setSlug($this->container->get('slugger')->slugify($post->getTitle()))->setContent($this->getPostContent())->setAuthor($author)->setPublishedAt(new \DateTime('now - ' . $i . 'days'))->setState($this->getRandomState())->setCategory($category);
         foreach (range(1, 5) as $j) {
             $comment = new Comment();
             $comment->setUser($user)->setPublishedAt(new \DateTime('now + ' . ($i + $j) . 'seconds'))->setContent($this->getRandomCommentContent())->setPost($post);
             $manager->persist($comment);
             $post->addComment($comment);
         }
         if (rand(0, 1)) {
             $vote = new Vote();
             $vote->setAuthorEmail(rand(0, 1) ? '[email protected]' : '[email protected]');
             $vote->setPost($post);
             $vote->setVote(rand(0, 1));
         }
         $manager->persist($post);
         $category->addPost($post);
     }
     $manager->flush();
 }

 /**
  * @Route("/create", name="create_post")
  */
 public function createAction(Request $request)
 {
     // just setup a fresh $post object (remove the dummy data)
     $post = new Post();
     $post->setAuthorEmail('[email protected]');
     $form = $this->createForm(new PostType(), $post);
     $finder = new Finder();
     $data = $finder->files()->in($_SERVER['DOCUMENT_ROOT'] . 'Benedictux/web/upload');
     //$data = $this->get('app.scanner')->scanDir($_SERVER['DOCUMENT_ROOT'].'Benedictux/web/uploads');
     //$data = $this->get('app.scanner')->scanDirectory($this->get('request')->getBasePath());
     //$scanned_directory = array_diff(scandir('./web'), array('..', '.'));
     $form->handleRequest($request);
     if ($form->isSubmitted() && $form->isValid()) {
         $em = $this->getDoctrine()->getManager();
         $slug = $this->get('app.slugger')->slugify($post->getTitle());
         $post->setSlug($slug);
         if (get_magic_quotes_gpc()) {
             $content = stripslashes($post->getContent());
             $content = $this->get('app.parser')->parserTexarea($content);
             $post->setContent($content);
         } else {
             $content = $this->get('app.parser')->parserTexarea($post->getContent());
             $post->setContent($content);
         }
         $em->persist($post);
         $em->flush();
         return $this->redirectToRoute('accueil');
     }
     return $this->render('app/postCreate.html.twig', array('form' => $form->createView(), 'data' => $data));
 }

 /**
  * Displays a form to create a new Post entity.
  *
  * @Route("/new", name="admin_post_new")
  * @Method("GET")
  * @Template()
  */
 public function newAction()
 {
     $entity = new Post();
     $entity->setCreatedAt();
     $form = $this->createCreateForm($entity);
     return array('entity' => $entity, 'form' => $form->createView());
 }

 /**
  * @Route("{page}/temat/{temat}")
  */
 public function addPostAction(Request $request, $temat, $page)
 {
     if ($this->getUser() == true) {
         $task = new Post();
         $task->setAutor($this->getUser()->getUsername());
         $task->setIdTematu($temat);
         $task->setCzasAdd(new \DateTime("now"));
         $form = $this->createFormBuilder($task)->add('Tresc', TextareaType::class)->add('Zapisz', SubmitType::class, array('label' => 'Dodaj'))->getForm();
         $form->handleRequest($request);
         if ($form->isSubmitted() && $form->isValid()) {
             $this->savePost($task);
             $this->upgradePost($page);
         }
         $em = $this->getDoctrine()->getManager();
         $query = $em->createQuery("SELECT u FROM AppBundle:Post u WHERE u.idTematu = :id ");
         $query->setParameter('id', $temat);
         $tematy = $query->getResult();
         $size = sizeof($tematy);
         return $this->render('Posts/post_page.html.twig', array('form' => $form->createView(), 'size' => $size, 'tematy' => $tematy, "page" => $page));
     } else {
         $em = $this->getDoctrine()->getManager();
         $query = $em->createQuery("SELECT u FROM AppBundle:Post u WHERE u.idTematu = :id ");
         $query->setParameter('id', $temat);
         $tematy = $query->getResult();
         $size = sizeof($tematy);
         return $this->render('Posts/post_page.html.twig', array('size' => $size, 'tematy' => $tematy, "page" => $page));
     }
 }

 /**
  * @Route("/channel/{uniqID}/blog", name="oktothek_series_blog_post")
  * @Method({"GET", "POST"})
  * @Template()
  */
 public function blogAction(Request $request, Series $series)
 {
     $this->denyAccessUnlessGranted('edit_channel', $series);
     $post = new Post();
     $post->setIsActive(true);
     $form = $this->createForm(PostType::class, $post, ['action' => $this->generateUrl('oktothek_series_blog_post', ['uniqID' => $series->getUniqID()])]);
     $form->add('submit', SubmitType::class, ['label' => 'oktothek.post_create_button', 'attr' => ['class' => 'btn btn-primary']]);
     if ($request->getMethod() == "POST") {
         //sends form
         $form->handleRequest($request);
         if ($form->isValid()) {
             $em = $this->getDoctrine()->getManager();
             $series->addPost($post);
             foreach ($post->getAssets() as $asset) {
                 $asset->setSeries($series);
                 $em->persist($asset);
             }
             $em->persist($post);
             $em->persist($series);
             $em->flush();
             $this->get('session')->getFlashBag()->add('success', 'oktothek.success_create_post');
             $this->get('oktothek_notification_service')->createNewPostNotifications($post);
             return $this->redirect($this->generateUrl('oktothek_channel_blogposts', ['uniqID' => $series->getUniqID()]));
         } else {
             $this->get('session')->getFlashBag()->add('error', 'oktothek.error_create_post');
         }
     }
     return ['form' => $form->createView(), 'series' => $series];
 }

 private function canEdit(Post $post, UserInterface $user, TokenInterface $token)
 {
     if ($this->decisionManager->decide($token, ['ROLE_MANAGER']) && $post->getOwner() == $user) {
         return true;
     }
     return false;
 }

 public function addPost(Post $post, User $user)
 {
     $post->setAuthor($user);
     $this->em->persist($post);
     $user->setLastPost($post);
     $user->increasePostsCount();
     $this->em->flush();
 }

 public function save(Post $entity)
 {
     $entity->setUpdated(date_create());
     $entityManager = $this->getEntityManager();
     $entityManager->persist($entity);
     $entityManager->flush();
     return $entity;
 }

 /**
  * @return int
  */
 public function delete(User $user, Post $post)
 {
     $conn = $this->_em->getConnection();
     $statement = $conn->prepare('DELETE FROM post_vote WHERE user_id = :user_id AND post_id = :post_id');
     $statement->bindValue('user_id', $user->getId());
     $statement->bindValue('post_id', $post->getId());
     return $statement->execute();
 }

 /**
  * @Route("/create-blog", name="create-blog")
  */
 public function createBlogAction(Request $request)
 {
     $post = new Post();
     $post->setDescription('Nuevo post');
     $em = $this->getDoctrine()->getManager();
     $em->persist($post);
     $em->flush();
     return new Response('Created post id ' . $post->getId());
 }

 private function canEdit(Post $post, User $user)
 {
     // this assumes that the data object has a getOwner() method
     // to get the entity of the user who owns this data object
     //if ($post->getAuthor()->getIsAdmin() and !$user->getIsAdmin()) {
     //    return false;
     //}
     return $user === $post->getAuthor() or $user->getIsAdmin();
 }

 /**
  * Creates a new Post entity.
  *
  * @Route("/", name="post_create")
  * @Method("POST")
  */
 public function createAction(Request $request)
 {
     $em = $this->getDoctrine()->getManager();
     $post = new Post();
     $post->setContent($request->getContent());
     $em->persist($post);
     $em->flush();
     return new JsonResponse();
 }

 public function load(ObjectManager $manager)
 {
     $repo = new Post();
     $repo->setTitle('Post title 1');
     $manager->persist($repo);
     $repo = new Post();
     $repo->setTitle('Post title 2');
     $manager->persist($repo);
     $manager->flush();
 }

 /**
  * @param Post $post
  * @param User $user
  *
  * @return bool
  */
 private function isEditGranted(Post $post, User $user)
 {
     switch ($post->getState()) {
         case Post::STATUS_DRAFT:
             return $post->isAuthor($user);
         case Post::STATUS_REVIEW:
             return $user->isAdmin();
     }
     return false;
 }

 /**
  * @Route("/new")
  * @Method({"GET"})
  */
 public function newAction()
 {
     $post = new Post();
     $categories = $this->getDoctrine()->getRepository('AppBundle:Category')->findAll();
     foreach ($categories as $category) {
         $post->addCategory($category);
     }
     $form = $this->createForm(new PostType(), $post);
     return $this->render('Admin/new.html.twig', ['form' => $form->createView()]);
 }

 public function load(ObjectManager $manager)
 {
     foreach ($this->getData() as $payload) {
         $post = new Entity\Post();
         $post->setTitle($payload[0]);
         $post->setContent($payload[1]);
         $post->setCreated($payload[2]);
         $manager->persist($post);
     }
     $manager->flush();
 }

 public function testSetUser()
 {
     // new entity
     $post = new Post();
     // dummy entity
     $user = new User();
     $user->setFirstName("Ole");
     // Use the setUser method
     $post->setUser($user);
     // Assert the result
     $this->assertEquals($user, $post->getUser());
 }

 /**
  * Send email to author and all people from comments when vote is Approved or Rejected
  *
  * @param Post   $post
  * @param string $translation
  * @param string $template
  */
 private function sendPostVoteClosedEmail(Post $post, $translation, $template)
 {
     $recipients[] = $post->getAuthor()->getEmail();
     /** @var Comment $comment */
     $comments = $post->getComments();
     foreach ($comments as $comment) {
         $recipients[] = $comment->getUser()->getEmail();
     }
     $subject = $this->translator->trans($translation);
     $body = $this->renderView($template, array('post' => $post));
     $this->mailer->send($recipients, $subject, $body);
 }