src/Controller/Front/BlogController.php line 67

  1. <?php
  3. namespace App\Controller\Front;
  5. use App\Entity\Animal;
  6. use App\Entity\BlogCategory;
  7. use App\Entity\BlogKeyword;
  8. use App\Entity\BlogNote;
  9. use App\Entity\Role;
  10. use App\Entity\Rotator;
  11. use App\Entity\RotatorPlace;
  12. use App\Entity\RotatorType;
  13. use App\Entity\User;
  14. use App\Repository\AnimalRepository;
  15. use App\Repository\BlogAuthorRepository;
  16. use App\Repository\BlogCategoryRepository;
  17. use App\Repository\BlogKeywordRepository;
  18. use App\Repository\BlogNoteRepository;
  19. use App\Repository\RoleRepository;
  20. use App\Repository\RotatorRepository;
  21. use App\Repository\UserRepository;
  22. use App\Service\BlogService;
  23. use Doctrine\Persistence\ManagerRegistry;
  24. use Knp\Component\Pager\PaginatorInterface;
  25. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  26. use Symfony\Component\HttpFoundation\RedirectResponse;
  27. use Symfony\Component\HttpFoundation\Request;
  28. use Symfony\Component\HttpFoundation\Response;
  29. use Symfony\Component\Routing\Annotation\Route;
  31. class BlogController extends AbstractController
  32. {
  33.     #[Route('/autorzy')]
  34.     #[Route('/front/blog')]
  35.     public function indexAction(Request $request, ManagerRegistry $doctrine)
  36.     {
  37.         $roles = $doctrine->getRepository(Role::class)->findBy(['role' => 'ROLE_AUTHOR']);
  38.         $blogAuthors = $doctrine->getRepository(User::class)->findAllqb('id', 'DESC', $roles);
  40.         return $this->render(
  41.             'front/blog/index.html.twig',
  42.             [
  43.                 'blogAuthors' => $blogAuthors->getQuery()->getResult(),
  44.             ]
  45.         );
  46.     }
  48.     #[Route('/autor/{firstName}_{lastName}/{id}', name: 'base_front_blog_authors')]
  49.     public function notesAction(Request $request, ManagerRegistry $doctrine, $id)
  50.     {
  51.         $blogNotes = $doctrine->getRepository(BlogNote::class)->findBy(['author' => $id, 'isPublished' => true]);
  52.         $author = $doctrine->getRepository(User::class)->find($id);
  53.         $anotherAuthors = $doctrine
  54.             ->getRepository(BlogNote::class)
  55.             ->findMostPostedAuthors(2, $id);
  56.         $rotator = $doctrine->getRepository(Rotator::class)->findOneByTypeAndPlace(
  57.             RotatorType::TYPE_BANNER,
  58.             RotatorPlace::TYPE_AUTHOR
  59.         );
  61.         return $this->render(
  62.             'front/blog/notes.html.twig',
  63.             [
  64.                 'author' => $author,
  65.                 'anotherAuthors' => $anotherAuthors,
  66.                 'blogNotes' => $blogNotes,
  67.                 'blogRotator' => $rotator,
  68.             ]
  69.         );
  70.     }
  72.     #[Route('/blog', name: 'base_front_blog_notes')]
  73.     #[Route('/front/blog/notesList')]
  74.     public function notesListAction(
  75.         Request $request,
  76.         ManagerRegistry $doctrine)
  77.     {
  78.         $categories = $doctrine
  79.             ->getRepository(BlogCategory::class)
  80.             ->getCategoriesForBlog();
  82.         $blogNotes = $doctrine
  83.             ->getRepository(BlogNote::class)
  84.             ->findBlogPostsForList($categories);
  86.         $bestAuthors = $doctrine
  87.             ->getRepository(BlogNote::class)
  88.             ->findMostPostedAuthors();
  90.         return $this->render(
  91.             'front/blog/notesList.html.twig',
  92.             [
  93.                 'blogNotes' => $blogNotes,
  94.                 'bestAuthors' => $bestAuthors,
  95.             ]
  96.         );
  97.     }
  99.     #[Route('/blog/popular', name: 'base_front_blog_popular')]
  100.     #[Route('/front/blog/popular')]
  101.     public function popularNotesAction(
  102.         Request $request,
  103.         ManagerRegistry $doctrine)
  104.     {
  105.         $categories = $doctrine
  106.             ->getRepository(BlogCategory::class)
  107.             ->getCategoriesForBlog();
  109.         $blogNotes = $doctrine
  110.             ->getRepository(BlogNote::class)
  111.             ->findBlogPostsPopularForList($categories);
  113.         $bestAuthors = $doctrine
  114.             ->getRepository(BlogNote::class)
  115.             ->findMostPostedAuthors();
  117.         return $this->render(
  118.             'front/blog/notesList.html.twig',
  119.             [
  120.                 'blogNotes' => $blogNotes,
  121.                 'bestAuthors' => $bestAuthors,
  122.             ]
  123.         );
  124.     }
  126.     #[Route('/blog/{id}', name: 'base_front_blog_notesingle')]
  127.     public function noteSingleAction(Request $request, ManagerRegistry $doctrine, BlogService $blogService, $id)
  128.     {
  129.         $isAdmin = $this->isGranted('ROLE_ADMIN');
  131.         if(!$isAdmin) {
  132.             $blogNote = $doctrine->getRepository(BlogNote::class)->findOneBy(['id' => $id, 'isPublished' => true]);
  133.         } else {
  134.             $blogNote = $doctrine->getRepository(BlogNote::class)->findOneBy(['id' => $id]);
  135.         }
  137.         if (!$blogNote) {
  138.             throw $this->createNotFoundException('Wpis nie istnieje');
  139.         }
  141.         $blogService->incrementPv($blogNote);
  142.         $nextNotesAuthor = [];
  144.         if (!is_null($blogNote->getAuthor())) {
  145.             $nextNotesAuthor = $doctrine->getRepository(BlogNote::class)->findNextNotesFromAuthor($blogNote);
  146.         }
  148.         $nextNotesCategory = $doctrine->getRepository(BlogNote::class)->findNextNotesFromCategory($blogNote);
  149.         $animals = $doctrine->getRepository(Animal::class)->findBy(['isPublished' => true], ['id' => 'DESC'], 5);
  151.         return $this->render(
  152.             'front/blog/noteSingle.html.twig',
  153.             [
  154.                 'blogNote' => $blogNote,
  155.                 'categories' => $doctrine->getRepository(BlogCategory::class)->getCategoriesForBlog(),
  156.                 'nextNotesCategory' => $nextNotesCategory,
  157.                 'nextNotesAuthor' => $nextNotesAuthor,
  158.                 'animals' => $animals,
  159.             ]
  160.         );
  161.     }
  163.     #[Route('blog/tag/{word}', name: 'base_front_blog_noteslistwithkeyword')]
  164.     public function notesListWithKeywordAction(ManagerRegistry $doctrine, $word)
  165.     {
  166.         $keywords = $doctrine->getRepository(BlogKeyword::class)->findBy(
  167.             ['name' => $word],
  168.             ['publishedDate' => 'DESC']
  169.         );
  172.         $blogNotes = $doctrine->getRepository(BlogNote::class)->findBlogPostsForKeyword($keywords);
  173.         $bestAuthors = $doctrine->getRepository(BlogNote::class)->findMostPostedAuthors();
  175.         return $this->render(
  176.             'front/blog/notesListWithKeyword.html.twig',
  177.             [
  178.                 'blogNotes' => $blogNotes,
  179.                 'bestAuthors' => $bestAuthors,
  180.                 'keyword' => $word,
  181.             ]
  182.         );
  183.     }
  185.     #[Route('/blog/kategoria/{id}/{slug}', name: 'base_front_blog_notesincategory')]
  186.     public function notesInCategoryAction($id, ManagerRegistry $doctrine, $slug)
  187.     {
  188.         $blogNotes = $doctrine->getRepository(BlogNote::class)
  189.             ->findByCategories($id);
  191.         $bestAuthors = $doctrine->getRepository(BlogNote::class)->findMostPostedAuthors();
  192.         $category = $doctrine->getRepository(BlogCategory::class)->find($id);
  193.     
  194.         return $this->render(
  195.             'front/blog/notesInCategory.html.twig',
  196.             [
  197.                 'blogNotes' => $blogNotes,
  198.                 'bestAuthors' => $bestAuthors,
  199.                 'category' => $category,
  200.             ]
  201.         );
  202.     }
  204.     #[Route('/jak-pomoc')]
  205.     public function howToHelpNotesList(Request $request)
  206.     {
  207.         return $this->render(
  208.             'front/blog/howToHelpNotesList.html.twig',
  209.             [
  210.                 'blogNotes' => $this->getAllPostsFromHowToHelpCategory(),
  211.             ]
  212.         );
  214.     }
  216.     #[Route('/jak-pomoc/{id}')]
  217.     public function howToHelpSingleAction(ManagerRegistry $doctrine, $id)
  218.     {
  219.         $blogNote = $doctrine->getRepository(BlogNote::class)->findOneBy(['id' => $id, 'isPublished' => true]);
  221.         if (empty($blogNote)) {
  222.             return new Response('', 404);
  223.         }
  224.         if ($blogNote->getCategory()->getType() != BlogCategory::TYPE_HOW_TO_HELP) {
  225.             return new RedirectResponse($this->generateUrl('base_front_blog_notesingle', ['id' => $id]));
  226.         } else {
  228.             return $this->render(
  229.                 'front/blog/howToHelpSingle.html.twig',
  230.                 [
  231.                     'blogNote' => $blogNote,
  232.                     'blogNotes' => $this->getAllPostsFromHowToHelpCategory(),
  233.                 ]
  234.             );
  235.         }
  236.     }
  238.     private function getAllPostsFromHowToHelpCategory(ManagerRegistry $doctrine)
  239.     {
  240.         $category = $doctrine->getRepository(BlogCategory::class)->findOneBy(['type' => BlogCategory::TYPE_HOW_TO_HELP]);
  241.         return $doctrine->getRepository(BlogNote::class)->getAllPostsInHowToHelpCategory($category);
  242.     }
  243. }