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

Open in your IDE?
  1. <?php
  3. namespace Webkul\UVDesk\SupportCenterBundle\Controller;
  5. use Doctrine\Common\Collections\Criteria;
  6. use Webkul\UVDesk\SupportCenterBundle\Form;
  7. use Symfony\Component\HttpFoundation\Request;
  8. use Symfony\Component\HttpFoundation\Response;
  9. use Symfony\Component\HttpFoundation\ParameterBag;
  10. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  11. use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
  12. use Symfony\Component\Security\Core\Exception\AccessDeniedException;
  13. use Webkul\UVDesk\CoreFrameworkBundle\Services\UserService;
  14. use Symfony\Contracts\Translation\TranslatorInterface;
  15. use Symfony\Component\DependencyInjection\ContainerInterface;
  16. use Webkul\UVDesk\CoreFrameworkBundle\Entity as CoreEntites; 
  17. use Webkul\UVDesk\SupportCenterBundle\Entity as SupportEntites;
  19. class Website extends AbstractController   
  20. {
  21.     private $visibility = ['public'];
  22.     private $limit = 5;
  23.     private $company;
  25.     private $userService;
  26.     private $translator;
  27.     private $constructContainer;
  29.     public function __construct(UserService $userService, TranslatorInterface $translator, ContainerInterface $constructContainer)
  30.     {
  31.         $this->userService = $userService;
  32.         $this->translator = $translator;
  33.         $this->constructContainer = $constructContainer;
  34.     }
  36. public function login(Request $request)
  37. {
  38. if ($request->getSession()->get('is_authenticated')) {
  39.         return $this->redirectToRoute('helpdesk_knowledgebase');
  40.     }
  41.     // check if user has submitted the login form
  42.     if ($request->isMethod('POST')) {
  43.         // retrieve the username and password from POST data
  44.         $username = $request->request->get('username');
  45.         $password = $request->request->get('password');
  47.     $em = $this->getDoctrine()->getManager();
  48.         $conn = $em->getConnection();
  49.         $stmt = $conn->prepare('SELECT initial_check(:param1, :param2)');
  50.         $stmt->bindParam(':param1', $username);
  51.         $stmt->bindParam(':param2', $password);
  52.         $stmt->execute();
  53.         $result = $stmt->fetchAll();
  54. $jsonString = json_encode($result[0]);
  55. $data = json_decode($jsonString, true);
  56. $value = reset($data);
  58.         // check if the username and password are correct
  59.     if ($value === 1) {
  60.         $request->getSession()->set('is_authenticated', true);
  61.         $request->getSession()->set('user', $username);
  62.         return $this->redirectToRoute('helpdesk_knowledgebase');        
  63.     } else {
  64.         $request->getSession()->set('is_authenticated', false);
  65.         $this->addFlash('error', 'Invalid username or password');
  66.         return $this->redirectToRoute('login_route');
  67.         }
  68.     }
  69.     // if the user has not submitted the login form, display the login page
  70.     return $this->render('login.html.twig');
  71. }
  73.     private function isKnowledgebaseActive()
  74.     {
  75.         $entityManager = $this->getDoctrine()->getManager();
  76.         $website = $entityManager->getRepository(CoreEntites\Website::class)->findOneByCode('knowledgebase');
  78.         if (!empty($website)) {
  79.             $knowledgebaseWebsite = $entityManager->getRepository(SupportEntites\KnowledgebaseWebsite::class)->findOneBy(['website' => $website->getId(), 'status' => true]);
  81.             if (!empty($knowledgebaseWebsite) && true == $knowledgebaseWebsite->getIsActive()) {
  82.                 return true;
  83.             }
  84.         }
  86.         throw new NotFoundHttpException('Page Not Found');
  87.     }
  89.     public function home(Request $request)
  90.     {
  91.         $this->isKnowledgebaseActive();
  93.     $is_authenticated = $request->getSession()->get('is_authenticated', false);
  95.     if (!$is_authenticated) {
  96.             // redirect to login page
  97.             return $this->redirectToRoute('login_route');
  98.         }
  99.         $parameterBag = [
  100.             'visibility' => 'public',
  101.             'sort' => 'id',
  102.             'direction' => 'desc'
  103.         ];
  105.         $articleRepository = $this->getDoctrine()->getRepository(SupportEntites\Article::class);
  106.         $solutionRepository = $this->getDoctrine()->getRepository(SupportEntites\Solutions::class);
  108.         $twigResponse = [
  109.         'searchDisable' => false,
  110.             'popArticles' => $articleRepository->getPopularTranslatedArticles($request->getLocale()),
  111.             'solutions' => $solutionRepository->getAllSolutions(new ParameterBag($parameterBag), $this->constructContainer, 'a', [1]),
  112.         ];
  114.         $newResult = [];
  115.        
  116.         foreach ($twigResponse['solutions'] as $key => $result) {
  117.             $newResult[] = [
  118.                 'id' => $result->getId(),
  119.                 'name' => $result->getName(),
  120.                 'description' => $result->getDescription(),
  121.                 'visibility' => $result->getVisibility(),
  122.                 'solutionImage' => ($result->getSolutionImage() == null) ? '' : $result->getSolutionImage(),
  123.                 'categoriesCount' => $solutionRepository->getCategoriesCountBySolution($result->getId()),
  124.                 'categories' => $solutionRepository->getCategoriesWithCountBySolution($result->getId()),
  125.                 'articleCount' => $solutionRepository->getArticlesCountBySolution($result->getId()),
  126.             ];
  127.         }
  129.         $twigResponse['solutions']['results'] = $newResult;
  130.         $twigResponse['solutions']['categories'] = array_map(function($category) use ($articleRepository) {
  131.             $parameterBag = [
  132.                 'categoryId' => $category['id'],
  133.                 'status' => 1,
  134.                 'sort' => 'id',
  135.                 'limit'=>10,
  136.                 'direction' => 'desc'
  137.             ];
  139.             $article =  $articleRepository->getAllArticles(new ParameterBag($parameterBag), $this->constructContainer, 'a.id, a.name, a.slug, a.stared');
  140.              
  141.             return [
  142.                 'id' => $category['id'],
  143.                 'name' => $category['name'],
  144.                 'description' => $category['description'],
  145.                 'articles' => $article
  146.             ];
  147.         }, $solutionRepository->getAllCategories(10, 2));
  149.             return $this->render('@UVDeskSupportCenter//Knowledgebase//index.html.twig', $twigResponse);
  150.     }
  152.     public function listCategories(Request $request)
  153.     {
  154.         $this->isKnowledgebaseActive();
  156.     $is_authenticated = $request->getSession()->get('is_authenticated', false);
  158.     if (!$is_authenticated) {
  159.             // redirect to login page
  160.             return $this->redirectToRoute('login_route');
  161.         }
  163.         $solutionRepository = $this->getDoctrine()->getRepository(SupportEntites\Solutions::class);
  164.         $categoryCollection = $solutionRepository->getAllCategories(10, 4);
  165.         
  166.         return $this->render('@UVDeskSupportCenter/Knowledgebase/categoryListing.html.twig', [
  167.             'categories' => $categoryCollection,
  168.             'categoryCount' => count($categoryCollection),
  169.         ]);
  170.     }
  172.     public function viewFolder(Request $request)
  173.     {
  174.         $this->isKnowledgebaseActive();
  176.     $is_authenticated = $request->getSession()->get('is_authenticated', false);
  178.     if (!$is_authenticated) {
  179.             // redirect to login page
  180.             return $this->redirectToRoute('login_route');
  181.         }
  182.         
  183.         if(!$request->attributes->get('solution'))
  184.             return $this->redirect($this->generateUrl('helpdesk_knowledgebase'));
  186.         $filterArray = ['id' => $request->attributes->get('solution')];
  188.         $solution = $this->getDoctrine()
  189.                     ->getRepository(SupportEntites\Solutions::class)
  190.                     ->findOneBy($filterArray);
  192.         if(!$solution)
  193.             $this->noResultFound();
  195.         $breadcrumbs = [
  196.             [
  197.                 'label' => $this->translator->trans('Support Center'),
  198.                 'url' => $this->generateUrl('helpdesk_knowledgebase')
  199.             ],
  200.             [
  201.                 'label' => $solution->getName(),
  202.                 'url' => '#'
  203.             ],
  204.         ];
  206.         $testArray = [1, 2, 3, 4];
  207.         foreach ($testArray as $test) {
  208.             $categories[] = [
  209.                 'id' => $test,
  210.                 'name' => $test . " name",
  211.                 'articleCount' => $test . " articleCount",
  212.             ];
  213.         }
  215.         return $this->render('@UVDeskSupportCenter//Knowledgebase//folder.html.twig', [
  216.             'folder' => $solution,
  217.             'categoryCount' => $this->getDoctrine()
  218.                 ->getRepository(SupportEntites\Solutions::class)
  219.                 ->getCategoriesCountBySolution($solution->getId()),
  220.             'categories' => $this->getDoctrine()
  221.                 ->getRepository(SupportEntites\Solutions::class)
  222.                 ->getCategoriesWithCountBySolution($solution->getId()),
  223.             'breadcrumbs' => $breadcrumbs
  224.         ]);
  225.     }
  227.     public function viewFolderArticle(Request $request)
  228.     {
  229.         $this->isKnowledgebaseActive();
  231.     $is_authenticated = $request->getSession()->get('is_authenticated', false);
  233.     if (!$is_authenticated) {
  234.             // redirect to login page
  235.             return $this->redirectToRoute('login_route');
  236.         }
  238.         if(!$request->attributes->get('solution'))
  239.             return $this->redirect($this->generateUrl('helpdesk_knowledgebase'));
  241.         $filterArray = ['id' => $request->attributes->get('solution')];
  243.         $solution = $this->getDoctrine()
  244.                     ->getRepository(SupportEntites\Solutions::class)
  245.                     ->findOneBy($filterArray);
  247.         if(!$solution)
  248.             $this->noResultFound();
  250.         $breadcrumbs = [
  251.             [
  252.                 'label' => $this->translator->trans('Support Center'),
  253.                 'url' => $this->generateUrl('helpdesk_knowledgebase')
  254.             ],
  255.             [
  256.                 'label' => $solution->getName(),
  257.                 'url' => '#'
  258.             ],
  259.         ];
  261.         $parameterBag = [
  262.             'solutionId' => $solution->getId(),
  263.             'status' => 1,
  264.             'sort' => 'id',
  265.             'direction' => 'desc'
  266.         ];
  267.         $article_data = [
  268.             'folder' => $solution,
  269.             'articlesCount' => $this->getDoctrine()
  270.                 ->getRepository(SupportEntites\Solutions::class)
  271.                 ->getArticlesCountBySolution($solution->getId(), [1]),
  272.             'articles' => $this->getDoctrine()
  273.                 ->getRepository(SupportEntites\Article::class)
  274.                 ->getAllArticles(new ParameterBag($parameterBag), $this->constructContainer, 'a.id, a.name, a.slug, a.stared'),
  275.             'breadcrumbs' => $breadcrumbs,
  276.         ];
  278.         return $this->render('@UVDeskSupportCenter/Knowledgebase/folderArticle.html.twig', $article_data);
  279.     }
  281.     public function viewCategory(Request $request)
  282.     {
  283.         $this->isKnowledgebaseActive();
  285.     $is_authenticated = $request->getSession()->get('is_authenticated', false);
  287.     if (!$is_authenticated) {
  288.             // redirect to login page
  289.             return $this->redirectToRoute('login_route');
  290.         }
  292.         if(!$request->attributes->get('category'))
  293.             return $this->redirect($this->generateUrl('helpdesk_knowledgebase'));
  295.         $filterArray = array(
  296.                             'id' => $request->attributes->get('category'),
  297.                             'status' => 1,
  298.                         );
  299.        
  300.         $category = $this->getDoctrine()
  301.                     ->getRepository(SupportEntites\SolutionCategory::class)
  302.                     ->findOneBy($filterArray);
  303.     
  304.         if(!$category)
  305.             $this->noResultFound();
  307.         $breadcrumbs = [
  308.             [ 'label' => $this->translator->trans('Support Center'),'url' => $this->generateUrl('helpdesk_knowledgebase') ],
  309.             [ 'label' => $category->getName(),'url' => '#' ],
  310.         ];
  311.         
  312.         $parameterBag = [
  313.             'categoryId' => $category->getId(),
  314.             'status' => 1,
  315.             'sort' => 'id',
  316.             'direction' => 'desc'
  317.         ];
  319.         $category_data=  array(
  320.             'category' => $category,
  321.             'articlesCount' => $this->getDoctrine()
  322.                             ->getRepository(SupportEntites\SolutionCategory::class)
  323.                             ->getArticlesCountByCategory($category->getId(), [1]),
  324.             'articles' => $this->getDoctrine()
  325.                         ->getRepository(SupportEntites\Article::class)
  326.                         ->getAllArticles(new ParameterBag($parameterBag), $this->constructContainer, 'a.id, a.name, a.slug, a.stared'),
  327.             'breadcrumbs' => $breadcrumbs
  328.         );
  330.         return $this->render('@UVDeskSupportCenter/Knowledgebase/category.html.twig',$category_data);
  331.     }
  332.    
  333.     public function viewArticle(Request $request)
  334.     {
  335.         $this->isKnowledgebaseActive();
  337.     $is_authenticated = $request->getSession()->get('is_authenticated', false);
  339.     if (!$is_authenticated) {
  340.             // redirect to login page
  341.             return $this->redirectToRoute('login_route');
  342.         }
  343.        
  344.         if (!$request->attributes->get('article') && !$request->attributes->get('slug')) {
  345.             return $this->redirect($this->generateUrl('helpdesk_knowledgebase'));
  346.         }
  348.         $entityManager = $this->getDoctrine()->getManager();
  349.         $user = $this->userService->getCurrentUser();
  350.         $articleRepository = $entityManager->getRepository(SupportEntites\Article::class);
  352.         if ($request->attributes->get('article')) {
  353.             $article = $articleRepository->findOneBy(['status' => 1, 'id' => $request->attributes->get('article')]);
  354.         } else {
  355.             $article = $articleRepository->findOneBy(['status' => 1,'slug' => $request->attributes->get('slug')]);
  356.         }
  357.        
  358.         if (empty($article)) {
  359.             $this->noResultFound();
  360.         }
  361.         $stringReplace = str_replace("<ol>","<ul>",$article->getContent());
  362.         $stringReplace = str_replace("</ol>","</ul>",$stringReplace);
  364.         $article->setContent($stringReplace);
  365.         $article->setViewed((int) $article->getViewed() + 1);
  366.         
  367.         // Log article view
  368.         $articleViewLog = new SupportEntites\ArticleViewLog();
  369.         $articleViewLog->setUser(($user != null && $user != 'anon.') ? $user : null);
  370.         
  371.         $articleViewLog->setArticle($article);
  372.         $articleViewLog->setViewedAt(new \DateTime('now'));
  374.         $entityManager->persist($article);
  375.         $entityManager->persist($articleViewLog);
  376.         $entityManager->flush();
  377.         
  378.         // Get article feedbacks
  379.         $feedbacks = ['enabled' => false, 'submitted' => false, 'article' => $articleRepository->getArticleFeedbacks($article)];
  381.         if (!empty($user) && $user != 'anon.') {
  382.             $feedbacks['enabled'] = true;
  384.             if (!empty($feedbacks['article']['collection']) && in_array($user->getId(), array_column($feedbacks['article']['collection'], 'user'))) {
  385.                 $feedbacks['submitted'] = true;
  386.             }
  387.         }
  389.         // @TODO: App popular articles
  390.         $article_details = [
  391.             'article' => $article,
  392.             'breadcrumbs' => [
  393.                 ['label' => $this->translator->trans('Support Center'), 'url' => $this->generateUrl('helpdesk_knowledgebase')],
  394.                 ['label' => $article->getName(), 'url' => '#']
  395.             ],
  396.             'dateAdded' => $this->userService->convertToTimezone($article->getDateAdded()),
  397.             'articleTags' => $articleRepository->getTagsByArticle($article->getId()),
  398.             'articleAuthor' => $articleRepository->getArticleAuthorDetails($article->getId()),
  399.             'relatedArticles' => $articleRepository->getAllRelatedyByArticle(['locale' => $request->getLocale(), 'articleId' => $article->getId()], [1]),
  400.             'popArticles'  => $articleRepository->getPopularTranslatedArticles($request->getLocale())
  401.         ];
  403.         return $this->render('@UVDeskSupportCenter/Knowledgebase/article.html.twig',$article_details);
  404.     }
  406.     public function searchKnowledgebase(Request $request)
  407.     {
  408.         $this->isKnowledgebaseActive();
  410.     $is_authenticated = $request->getSession()->get('is_authenticated', false);
  412.     if (!$is_authenticated) {
  413.             // redirect to login page
  414.             return $this->redirectToRoute('login_route');
  415.         }
  417.         $searchQuery = $request->query->get('s');
  418.         if (empty($searchQuery)) {
  419.             return $this->redirect($this->generateUrl('helpdesk_knowledgebase'));
  420.         }
  422.     $user = $request->getSession()->get('user');
  423.     $em = $this->getDoctrine()->getManager();
  424.         $conn = $em->getConnection();
  425.         $stmt = $conn->prepare('CALL sp_custom_searchKeywords(:param1, :param2)');
  426.         $stmt->bindParam(':param1', $searchQuery);
  427.         $stmt->bindParam(':param2', $user);
  428.         $stmt->execute();
  430.         $articleCollection = $this->getDoctrine()->getRepository(SupportEntites\Article::class)->getArticleBySearch($request);
  432.         return $this->render('@UVDeskSupportCenter/Knowledgebase/search.html.twig', [
  433.             'search' => $searchQuery,
  434.             'articles' => $articleCollection,
  435.         ]);
  436.     }
  438.     public function viewTaggedResources(Request $request)
  439.     {
  440.         $this->isKnowledgebaseActive();
  442.     $is_authenticated = $request->getSession()->get('is_authenticated', false);
  444.     if (!$is_authenticated) {
  445.             // redirect to login page
  446.             return $this->redirectToRoute('login_route');
  447.         }
  449.         $tagQuery = $request->attributes->get('tag');
  450.         if (empty($tagQuery)) {
  451.             return $this->redirect($this->generateUrl('helpdesk_knowledgebase'));
  452.         }
  454.         $tagLabel = $request->attributes->get('name');
  455.         $articleCollection = $this->getDoctrine()->getRepository(SupportEntites\Article::class)->getArticleByTags([$tagLabel]);
  457.         return $this->render('@UVDeskSupportCenter/Knowledgebase/search.html.twig', [
  458.             'articles' => $articleCollection,
  459.             'search' => $tagLabel,
  460.             'breadcrumbs' => [
  461.                 ['label' => $this->translator->trans('Support Center'), 'url' => $this->generateUrl('helpdesk_knowledgebase')],
  462.                 ['label' => $tagLabel, 'url' => '#'],
  463.             ],
  464.         ]);
  465.     }
  467.     public function rateArticle($articleId, Request $request)
  468.     {
  469.         $this->isKnowledgebaseActive();
  471.     $is_authenticated = $request->getSession()->get('is_authenticated', false);
  473.     if (!$is_authenticated) {
  474.             // redirect to login page
  475.             return $this->redirectToRoute('login_route');
  476.         }
  478.         // @TODO: Refactor
  479.             
  480.         // if ($request->getMethod() != 'POST') {
  481.         //     return $this->redirect($this->generateUrl('helpdesk_knowledgebase'));
  482.         // }
  484.         // $company = $this->getCompany();
  485.         // $user = $this->userService->getCurrentUser();
  486.         $response = ['code' => 404, 'content' => ['alertClass' => 'danger', 'alertMessage' => 'An unexpected error occurred. Please try again later.']];
  488.         // if (!empty($user) && $user != 'anon.') {
  489.         //     $entityManager = $this->getDoctrine()->getEntityManager();
  490.         //     $article = $entityManager->getRepository('WebkulSupportCenterBundle:Article')->findOneBy(['id' => $articleId, 'companyId' => $company->getId()]);
  492.         //     if (!empty($article)) {
  493.         //         $providedFeedback = $request->request->get('feedback');
  495.         //         if (!empty($providedFeedback) && in_array(strtolower($providedFeedback), ['positive', 'neagtive'])) {
  496.         //             $isArticleHelpful = ('positive' == strtolower($providedFeedback)) ? true : false;
  497.         //             $articleFeedback = $entityManager->getRepository('WebkulSupportCenterBundle:ArticleFeedback')->findOneBy(['article' => $article, 'ratedCustomer' => $user]);
  499.         //             $response = ['code' => 200, 'content' => ['alertClass' => 'success', 'alertMessage' => 'Feedback saved successfully.']];
  501.         //             if (empty($articleFeedback)) {
  502.         //                 $articleFeedback = new \Webkul\SupportCenterBundle\Entity\ArticleFeedback();
  504.         //                 // $articleBadge->setDescription('');
  505.         //                 $articleFeedback->setIsHelpful($isArticleHelpful);
  506.         //                 $articleFeedback->setArticle($article);
  507.         //                 $articleFeedback->setRatedCustomer($user);
  508.         //                 $articleFeedback->setCreatedAt(new \DateTime('now'));
  509.         //             } else {
  510.         //                 $articleFeedback->setIsHelpful($isArticleHelpful);
  511.         //                 $response['content']['alertMessage'] = 'Feedback updated successfully.';
  512.         //             }
  514.         //             $entityManager->persist($articleFeedback);
  515.         //             $entityManager->flush();
  516.         //         } else {
  517.         //             $response['content']['alertMessage'] = 'Invalid feedback provided.';
  518.         //         }
  519.         //     } else {
  520.         //         $response['content']['alertMessage'] = 'Article not found.';
  521.         //     }
  522.         // } else {
  523.         //     $response['content']['alertMessage'] = 'You need to login to your account before can perform this action.';
  524.         // }
  526.         return new Response(json_encode($response['content']), $response['code'], ['Content-Type: application/json']);
  527.     }
  529.     /**
  530.      * If customer is playing with url and no result is found then what will happen
  531.      * @return 
  532.      */
  533.     protected function noResultFound()
  534.     {
  535.         throw new NotFoundHttpException('Not Found!');
  536.     }
  537. }