vendor/uvdesk/support-center-bundle/Controller/Website.php line 49

Open in your IDE?
  1. <?php
  3. namespace Webkul\UVDesk\SupportCenterBundle\Controller;
  5. use Symfony\Component\HttpFoundation\Request;
  6. use Symfony\Component\HttpFoundation\Response;
  7. use Symfony\Component\HttpFoundation\ParameterBag;
  8. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  9. use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
  10. use Webkul\UVDesk\CoreFrameworkBundle\Services\UserService;
  11. use Symfony\Contracts\Translation\TranslatorInterface;
  12. use Symfony\Component\DependencyInjection\ContainerInterface;
  13. use Webkul\UVDesk\CoreFrameworkBundle\Entity as CoreEntities; 
  14. use Webkul\UVDesk\SupportCenterBundle\Entity as SupportEntities;
  16. class Website extends AbstractController
  17. {
  18.     private $visibility = ['public'];
  19.     private $limit = 5;
  20.     private $company;
  22.     private $userService;
  23.     private $translator;
  24.     private $constructContainer;
  26.     public function __construct(UserService $userService, TranslatorInterface $translator, ContainerInterface $constructContainer)
  27.     {
  28.         $this->userService = $userService;
  29.         $this->translator = $translator;
  30.         $this->constructContainer = $constructContainer;
  31.     }
  33.     private function isKnowledgebaseActive()
  34.     {
  35.         $entityManager = $this->getDoctrine()->getManager();
  36.         $website = $entityManager->getRepository(CoreEntities\Website::class)->findOneByCode('knowledgebase');
  38.         if (! empty($website)) {
  39.             $knowledgebaseWebsite = $entityManager->getRepository(SupportEntities\KnowledgebaseWebsite::class)->findOneBy(['website' => $website->getId(), 'status' => true]);
  41.             if (! empty($knowledgebaseWebsite) && true == $knowledgebaseWebsite->getIsActive()) {
  42.                 return true;
  43.             }
  44.         }
  46.         throw new NotFoundHttpException('Page Not Found');
  47.     }
  49.     public function home(Request $request)
  50.     {
  51.         $this->isKnowledgebaseActive();
  53.         $parameterBag = [
  54.             'visibility' => 'public',
  55.             'sort'       => 'id',
  56.             'direction'  => 'desc'
  57.         ];
  59.         $articleRepository = $this->getDoctrine()->getRepository(SupportEntities\Article::class);
  60.         $solutionRepository = $this->getDoctrine()->getRepository(SupportEntities\Solutions::class);
  62.         $twigResponse = [
  63.             'searchDisable' => false,
  64.             'popArticles'   => $articleRepository->getPopularTranslatedArticles($request->getLocale()),
  65.             'solutions'     => $solutionRepository->getAllSolutions(new ParameterBag($parameterBag), $this->constructContainer, 'a', [1]),
  66.         ];
  68.         $newResult = [];
  69.        
  70.         foreach ($twigResponse['solutions'] as $key => $result) {
  71.             $newResult[] = [
  72.                 'id'              => $result->getId(),
  73.                 'name'            => $result->getName(),
  74.                 'description'     => $result->getDescription(),
  75.                 'visibility'      => $result->getVisibility(),
  76.                 'solutionImage'   => ($result->getSolutionImage() == null) ? '' : $result->getSolutionImage(),
  77.                 'categoriesCount' => $solutionRepository->getCategoriesCountBySolution($result->getId()),
  78.                 'categories'      => $solutionRepository->getCategoriesWithCountBySolution($result->getId()),
  79.                 'articleCount'    => $solutionRepository->getArticlesCountBySolution($result->getId()),
  80.             ];
  81.         }
  83.         $twigResponse['solutions']['results'] = $newResult;
  84.         $twigResponse['solutions']['categories'] = array_map(function($category) use ($articleRepository) {
  85.             $parameterBag = [
  86.                 'categoryId' => $category['id'],
  87.                 'status'     => 1,
  88.                 'sort'       => 'id',
  89.                 'limit'      => 10,
  90.                 'direction'  => 'desc'
  91.             ];
  93.             $article =  $articleRepository->getAllArticles(new ParameterBag($parameterBag), $this->constructContainer, 'a.id, a.name, a.slug, a.stared');
  94.              
  95.             return [
  96.                 'id'          => $category['id'],
  97.                 'name'        => $category['name'],
  98.                 'description' => $category['description'],
  99.                 'articles'    => $article
  100.             ];
  101.         }, $solutionRepository->getAllCategories(10, 2));
  103.         return $this->render('@UVDeskSupportCenter//Knowledgebase//index.html.twig', $twigResponse);
  104.     }
  106.     public function listCategories(Request $request)
  107.     {
  108.         $this->isKnowledgebaseActive();
  110.         $solutionRepository = $this->getDoctrine()->getRepository(SupportEntities\Solutions::class);
  111.         $categoryCollection = $solutionRepository->getAllCategories(10, 4);
  112.         
  113.         return $this->render('@UVDeskSupportCenter/Knowledgebase/categoryListing.html.twig', [
  114.             'categories'    => $categoryCollection,
  115.             'categoryCount' => count($categoryCollection),
  116.         ]);
  117.     }
  119.     public function viewFolder(Request $request)
  120.     {
  121.         $this->isKnowledgebaseActive();
  122.         
  123.         if (!$request->attributes->get('solution'))
  124.             return $this->redirect($this->generateUrl('helpdesk_knowledgebase'));
  126.         $filterArray = ['id' => $request->attributes->get('solution')];
  128.         $solution = $this->getDoctrine()
  129.                     ->getRepository(SupportEntities\Solutions::class)
  130.                     ->findOneBy($filterArray);
  132.         if (! $solution)
  133.             $this->noResultFound();
  135.         if ($solution->getVisibility() == 'private') 
  136.             return $this->redirect($this->generateUrl('helpdesk_knowledgebase'));
  138.         $breadcrumbs = [
  139.             [
  140.                 'label' => $this->translator->trans('Support Center'),
  141.                 'url'   => $this->generateUrl('helpdesk_knowledgebase')
  142.             ],
  143.             [
  144.                 'label' => $solution->getName(),
  145.                 'url'   => '#'
  146.             ],
  147.         ];
  149.         $testArray = [1, 2, 3, 4];
  150.         foreach ($testArray as $test) {
  151.             $categories[] = [
  152.                 'id'           => $test,
  153.                 'name'         => $test . " name",
  154.                 'articleCount' => $test . " articleCount",
  155.             ];
  156.         }
  158.         return $this->render('@UVDeskSupportCenter//Knowledgebase//folder.html.twig', [
  159.             'folder'        => $solution,
  160.             'categoryCount' => $this->getDoctrine()
  161.                 ->getRepository(SupportEntities\Solutions::class)
  162.                 ->getCategoriesCountBySolution($solution->getId()),
  163.             'categories'    => $this->getDoctrine()
  164.                 ->getRepository(SupportEntities\Solutions::class)
  165.                 ->getCategoriesWithCountBySolution($solution->getId()),
  166.             'breadcrumbs'   => $breadcrumbs
  167.         ]);
  168.     }
  170.     public function viewFolderArticle(Request $request)
  171.     {
  172.         $this->isKnowledgebaseActive();
  174.         if (! $request->attributes->get('solution'))
  175.             return $this->redirect($this->generateUrl('helpdesk_knowledgebase'));
  177.         $filterArray = ['id' => $request->attributes->get('solution')];
  179.         $solution = $this->getDoctrine()
  180.                     ->getRepository(SupportEntities\Solutions::class)
  181.                     ->findOneBy($filterArray);
  183.         if (! $solution)
  184.             $this->noResultFound();
  185.             
  186.         if ($solution->getVisibility() == 'private')
  187.             return $this->redirect($this->generateUrl('helpdesk_knowledgebase'));
  189.         $breadcrumbs = [
  190.             [
  191.                 'label' => $this->translator->trans('Support Center'),
  192.                 'url'   => $this->generateUrl('helpdesk_knowledgebase')
  193.             ],
  194.             [
  195.                 'label' => $solution->getName(),
  196.                 'url'   => '#'
  197.             ],
  198.         ];
  200.         $parameterBag = [
  201.             'solutionId'  => $solution->getId(),
  202.             'status'      => 1,
  203.             'sort'        => 'id',
  204.             'direction'   => 'desc'
  205.         ];
  206.         $article_data = [
  207.             'folder'        => $solution,
  208.             'articlesCount' => $this->getDoctrine()
  209.                 ->getRepository(SupportEntities\Solutions::class)
  210.                 ->getArticlesCountBySolution($solution->getId(), [1]),
  211.             'articles'      => $this->getDoctrine()
  212.                 ->getRepository(SupportEntities\Article::class)
  213.                 ->getAllArticles(new ParameterBag($parameterBag), $this->constructContainer, 'a.id, a.name, a.slug, a.stared'),
  214.             'breadcrumbs'   => $breadcrumbs,
  215.         ];
  217.         return $this->render('@UVDeskSupportCenter/Knowledgebase/folderArticle.html.twig', $article_data);
  218.     }
  220.     public function viewCategory(Request $request)
  221.     {
  222.         $this->isKnowledgebaseActive();
  224.         if (!$request->attributes->get('category'))
  225.             return $this->redirect($this->generateUrl('helpdesk_knowledgebase'));
  227.         $filterArray = array(
  228.                             'id'     => $request->attributes->get('category'),
  229.                             'status' => 1,
  230.                         );
  231.        
  232.         $category = $this->getDoctrine()
  233.                     ->getRepository(SupportEntities\SolutionCategory::class)
  234.                     ->findOneBy($filterArray);
  235.     
  236.         if (! $category)
  237.             $this->noResultFound();
  239.         $breadcrumbs = [
  240.             [ 'label' => $this->translator->trans('Support Center'),'url' => $this->generateUrl('helpdesk_knowledgebase') ],
  241.             [ 'label' => $category->getName(),'url' => '#' ],
  242.         ];
  243.         
  244.         $parameterBag = [
  245.             'categoryId' => $category->getId(),
  246.             'status'     => 1,
  247.             'sort'       => 'id',
  248.             'direction'  => 'desc'
  249.         ];
  251.         $category_data=  array(
  252.             'category'      => $category,
  253.             'articlesCount' => $this->getDoctrine()
  254.                                 ->getRepository(SupportEntities\SolutionCategory::class)
  255.                                 ->getArticlesCountByCategory($category->getId(), [1]),
  256.             'articles'      => $this->getDoctrine()
  257.                                 ->getRepository(SupportEntities\Article::class)
  258.                                 ->getAllArticles(new ParameterBag($parameterBag), $this->constructContainer, 'a.id, a.name, a.slug, a.stared'),
  259.             'breadcrumbs'   => $breadcrumbs
  260.         );
  262.         return $this->render('@UVDeskSupportCenter/Knowledgebase/category.html.twig',$category_data);
  263.     }
  264.    
  265.     public function viewArticle(Request $request)
  266.     {
  267.         $this->isKnowledgebaseActive();
  268.        
  269.         if (!$request->attributes->get('article') && !$request->attributes->get('slug')) {
  270.             return $this->redirect($this->generateUrl('helpdesk_knowledgebase'));
  271.         }
  273.         $entityManager = $this->getDoctrine()->getManager();
  274.         $user = $this->userService->getCurrentUser();
  275.         $articleRepository = $entityManager->getRepository(SupportEntities\Article::class);
  277.         if ($request->attributes->get('article')) {
  278.             $article = $articleRepository->findOneBy(['status' => 1, 'id' => $request->attributes->get('article')]);
  279.         } else {
  280.             $article = $articleRepository->findOneBy(['status' => 1,'slug' => $request->attributes->get('slug')]);
  281.         }
  282.        
  283.         if (empty($article)) {
  284.             $this->noResultFound();
  285.         }
  287.         $article->setContent($article->getContent());
  288.         $article->setViewed((int) $article->getViewed() + 1);
  289.         
  290.         // Log article view
  291.         $articleViewLog = new SupportEntities\ArticleViewLog();
  292.         $articleViewLog->setUser(($user != null && $user != 'anon.') ? $user : null);
  293.         
  294.         $articleViewLog->setArticle($article);
  295.         $articleViewLog->setViewedAt(new \DateTime('now'));
  297.         $entityManager->persist($article);
  298.         $entityManager->persist($articleViewLog);
  299.         $entityManager->flush();
  300.         
  301.         // Get article feedbacks
  302.         $feedbacks = ['enabled' => false, 'submitted' => false, 'article' => $articleRepository->getArticleFeedbacks($article)];
  304.         if (! empty($user) && $user != 'anon.') {
  305.             $feedbacks['enabled'] = true;
  307.             if (! empty($feedbacks['article']['collection']) && in_array($user->getId(), array_column($feedbacks['article']['collection'], 'user'))) {
  308.                 $feedbacks['submitted'] = true;
  309.             }
  310.         }
  312.         // @TODO: App popular articles
  313.         $article_details = [
  314.             'article' => $article,
  315.             'breadcrumbs' => [
  316.                 ['label' => $this->translator->trans('Support Center'), 'url' => $this->generateUrl('helpdesk_knowledgebase')],
  317.                 ['label' => $article->getName(), 'url' => '#']
  318.             ],
  319.             'dateAdded'       => $this->userService->convertToTimezone($article->getDateAdded()),
  320.             'articleTags'     => $articleRepository->getTagsByArticle($article->getId()),
  321.             'articleAuthor'   => $articleRepository->getArticleAuthorDetails($article->getId()),
  322.             'relatedArticles' => $articleRepository->getAllRelatedByArticle(['locale' => $request->getLocale(), 'articleId' => $article->getId()], [1]),
  323.             'popArticles'     => $articleRepository->getPopularTranslatedArticles($request->getLocale())
  324.         ];
  326.         return $this->render('@UVDeskSupportCenter/Knowledgebase/article.html.twig', $article_details);
  327.     }
  329.     public function searchKnowledgebase(Request $request)
  330.     {
  331.         $this->isKnowledgebaseActive();
  333.         $searchQuery = $request->query->get('s');
  334.         if (empty($searchQuery)) {
  335.             return $this->redirect($this->generateUrl('helpdesk_knowledgebase'));
  336.         }
  338.         $articleCollection = $this->getDoctrine()->getRepository(SupportEntities\Article::class)->getArticleBySearch($request);
  340.         return $this->render('@UVDeskSupportCenter/Knowledgebase/search.html.twig', [
  341.             'search'   => $searchQuery,
  342.             'articles' => $articleCollection,
  343.         ]);
  344.     }
  346.     public function viewTaggedResources(Request $request)
  347.     {
  348.         $this->isKnowledgebaseActive();
  350.         $tagQuery = $request->attributes->get('tag');
  351.         if (empty($tagQuery)) {
  352.             return $this->redirect($this->generateUrl('helpdesk_knowledgebase'));
  353.         }
  355.         $tagLabel = $request->attributes->get('name');
  356.         $articleCollection = $this->getDoctrine()->getRepository(SupportEntities\Article::class)->getArticleByTags([$tagLabel]);
  358.         return $this->render('@UVDeskSupportCenter/Knowledgebase/search.html.twig', [
  359.             'articles' => $articleCollection,
  360.             'search' => $tagLabel,
  361.             'breadcrumbs' => [
  362.                 ['label' => $this->translator->trans('Support Center'), 'url' => $this->generateUrl('helpdesk_knowledgebase')],
  363.                 ['label' => $tagLabel, 'url' => '#'],
  364.             ],
  365.         ]);
  366.     }
  368.     public function rateArticle($articleId, Request $request)
  369.     {
  370.         $this->isKnowledgebaseActive();
  372.         // @TODO: Refactor
  373.             
  374.         // if ($request->getMethod() != 'POST') {
  375.         //     return $this->redirect($this->generateUrl('helpdesk_knowledgebase'));
  376.         // }
  378.         // $company = $this->getCompany();
  379.         // $user = $this->userService->getCurrentUser();
  380.         $response = ['code' => 404, 'content' => ['alertClass' => 'danger', 'alertMessage' => 'An unexpected error occurred. Please try again later.']];
  382.         // if (!empty($user) && $user != 'anon.') {
  383.         //     $entityManager = $this->getDoctrine()->getEntityManager();
  384.         //     $article = $entityManager->getRepository('WebkulSupportCenterBundle:Article')->findOneBy(['id' => $articleId, 'companyId' => $company->getId()]);
  386.         //     if (!empty($article)) {
  387.         //         $providedFeedback = $request->request->get('feedback');
  389.         //         if (!empty($providedFeedback) && in_array(strtolower($providedFeedback), ['positive', 'neagtive'])) {
  390.         //             $isArticleHelpful = ('positive' == strtolower($providedFeedback)) ? true : false;
  391.         //             $articleFeedback = $entityManager->getRepository('WebkulSupportCenterBundle:ArticleFeedback')->findOneBy(['article' => $article, 'ratedCustomer' => $user]);
  393.         //             $response = ['code' => 200, 'content' => ['alertClass' => 'success', 'alertMessage' => 'Feedback saved successfully.']];
  395.         //             if (empty($articleFeedback)) {
  396.         //                 $articleFeedback = new \Webkul\SupportCenterBundle\Entity\ArticleFeedback();
  398.         //                 // $articleBadge->setDescription('');
  399.         //                 $articleFeedback->setIsHelpful($isArticleHelpful);
  400.         //                 $articleFeedback->setArticle($article);
  401.         //                 $articleFeedback->setRatedCustomer($user);
  402.         //                 $articleFeedback->setCreatedAt(new \DateTime('now'));
  403.         //             } else {
  404.         //                 $articleFeedback->setIsHelpful($isArticleHelpful);
  405.         //                 $response['content']['alertMessage'] = 'Feedback updated successfully.';
  406.         //             }
  408.         //             $entityManager->persist($articleFeedback);
  409.         //             $entityManager->flush();
  410.         //         } else {
  411.         //             $response['content']['alertMessage'] = 'Invalid feedback provided.';
  412.         //         }
  413.         //     } else {
  414.         //         $response['content']['alertMessage'] = 'Article not found.';
  415.         //     }
  416.         // } else {
  417.         //     $response['content']['alertMessage'] = 'You need to login to your account before can perform this action.';
  418.         // }
  420.         return new Response(json_encode($response['content']), $response['code'], ['Content-Type: application/json']);
  421.     }
  423.     /**
  424.      * If customer is playing with url and no result is found then what will happen
  425.      * @return 
  426.      */
  427.     protected function noResultFound()
  428.     {
  429.         throw new NotFoundHttpException('Not Found!');
  430.     }
  431. }