src/Controller/Admin/CommentController.php line 148

Open in your IDE?
  1. <?php
  2. namespace Slivki\Controller\Admin;
  4. use Slivki\Entity\UserBalanceActivityType;
  5. use Slivki\Message\Query\Comment\GetCommentsPaginationQuery;
  6. use Slivki\Messenger\Query\QueryBusInterface;
  7. use Slivki\Paginator\Comment\CommentPaginatorInterface;
  8. use Symfony\Component\HttpKernel\KernelInterface;
  9. use Symfony\Component\Routing\Annotation\Route;
  10. use Slivki\Entity\Comment;
  11. use Slivki\Entity\MediaType;
  12. use Slivki\Entity\User;
  13. use Slivki\Entity\UserBalanceActivity;
  14. use Slivki\Services\ImageService;
  15. use Slivki\Services\Mailer;
  16. use Symfony\Component\HttpFoundation\Request;
  17. use Symfony\Component\HttpFoundation\Response;
  18. use Symfony\Component\Validator\Validator\ValidatorInterface;
  20. class CommentController extends AdminController
  21. {
  22.     /**
  23.      * @Route("/admin/comments/user/get/{userID}")
  24.      */
  25.     public function getCommentsByUserAction($userID, Request $request) {
  26.         $entityManager = $this->getEntityManager();
  27.         $user = $entityManager->find(User::class, $userID);
  28.         if (!$user) {
  29.             return new Response();
  30.         }
  31.         $dql = "select comment, media from Slivki:Comment comment
  32.             left join comment.medias media 
  33.             where comment.userID = :userID order by comment.createdOn desc";
  34.         $query = $this->getEntityManager()->createQuery($dql);
  35.         $query->setParameter('userID', $userID);
  36.         $query->setMaxResults(50);
  38.         return $this->render('Slivki/admin/users/comments_list.html.twig', [
  39.             'comments' => $query->getResult()
  40.         ]);
  41.     }
  43.     /**
  44.      * @Route("/admin/comments/send_letter_to_supplier")
  45.      */
  46.     public function sendLetterToSupplier(Request $request, Mailer $mailer) {
  47.         if (!$request->isXmlHttpRequest()) {
  48.             return $this->redirect("/admin");
  49.         }
  50.         $commentID = $request->request->getInt('commentID');
  51.         if ($commentID == 0) {
  52.             return new Response();
  53.         }
  54.         /** @var Comment $comment */
  55.         $comment = $this->getCommentRepository()->find($commentID);
  56.         if (!$comment) {
  57.             return new Response();
  58.         }
  59.         $entity = $this->getCommentRepository()->getCommentEntity($comment->getEntityID(), $comment->getTypeID());
  60.         if (!$entity) {
  61.             return new Response();
  62.         }
  63.         $directors = $entity->getDirectors();
  64.         $emailTo = [];
  65.         foreach($directors as $director) {
  66.             $emailTo[] = $director->getEmail();
  67.         }
  68.         if (empty($emailTo)) {
  69.             return new Response();
  70.         }
  71.         foreach ($emailTo as $email) {
  72.             $message = $mailer->createMessage();
  73.             $message->setSubject('Комментарий на сайте Slivki.by')
  74.                 ->setFrom("info@slivki.by", 'Slivki.by')
  75.                 ->setTo($email)
  76.                 ->setBody(
  77.                     $request->request->get('message'),
  78.                     'text/html'
  79.                 );
  80.             $mailer->send($message);
  81.         }
  83.         return new Response();
  84.     }
  86.     /**
  87.      * @Route("/admin/comments/save")
  88.      */
  89.     public function commentsSave(
  90.         Request $request,
  91.         Mailer $mailer,
  92.         ValidatorInterface $validator
  93.     ) {
  94.         if (!$request->isXmlHttpRequest()) {
  95.             return $this->redirect("/admin");
  96.         }
  97.         $entityManager = $this->getEntityManager();
  98.         $userRepository = $this->getUserRepository();
  99.         $requestComments = $request->request->get('comments');
  100.         $comments = $entityManager->getRepository(Comment::class)->findBy(['ID' => array_keys($requestComments)]);
  101.         $changedComments = [];
  102.         /** @var Comment $comment */
  103.         foreach($comments as $comment) {
  104.             if ($comment->isChecked()) {
  105.                 continue;
  106.             }
  107.             $currentCommentID = $comment->getID();
  108.             $hidden = (bool)$requestComments[$currentCommentID]['hidden'];
  109.             if ($comment->getComment() != $requestComments[$currentCommentID]['comment']
  110.                 || $comment->getAdminComment() != $requestComments[$currentCommentID]['adminComment']
  111.                 || $comment->isHidden() != $hidden || $comment->getRating() != $requestComments[$currentCommentID]['rating']) {
  112.                 $changedComments[$comment->getEntityID()] = $comment->getTypeID();
  113.             }
  114.             $comment->setComment($requestComments[$currentCommentID]['comment']);
  115.             $comment->setAdminComment($requestComments[$currentCommentID]['adminComment']);
  116.             $checked = (bool)$requestComments[$currentCommentID]['checked'];
  117.             $comment->setChecked($checked);
  118.             if ($checked) {
  119.                 $comment->setOperator($userRepository->find($this->getUser()->getID()));
  120.                 $comment->setProcessedByOperatorOn(new \DateTime());
  121.             }
  122.             if ($comment->getTypeID() == Comment::TYPE_OFFER_COMMENT) {
  123.                 $offer = $this->getOfferRepository()->find($comment->getEntityID());
  124.                 if ($checked && $userRepository->addCommentBonus($comment, $offer)) {
  125.                     $this->sendCommentBonusMessage($mailer, $validator, $comment);
  126.                 }
  127.                 if ($comment->isHidden() != $hidden) {
  128.                     if ($hidden) {
  129.                         $userRepository->removeCommentBonus($comment, $offer);
  130.                     } else {
  131.                         $userRepository->addCommentBonus($comment, $offer);
  132.                     }
  133.                 }
  134.             }
  135.             $comment->setHidden($hidden);
  136.             $comment->setRating((int)$requestComments[$currentCommentID]['rating']);
  137.         }
  138.         $entityManager->flush();
  139.         foreach ($changedComments as $entityID => $typeID) {
  140.             $this->resetCommentsCache($entityID, $typeID);
  141.         }
  142.         return new Response();
  143.     }
  144.     
  145.     /**
  146.      * @Route("/admin/comments/get_comment_images")
  147.      */
  148.     public function ajaxGetCommentImages(Request $request, ImageService $imageService){
  149.         if (!$request->isXmlHttpRequest()) {
  150.             return $this->redirect("/admin");
  151.         }
  152.         $result = [];
  153.         $commentID = $request->request->get('id');
  154.         $comment = $this->getCommentRepository()->find($commentID);
  155.         if (!$comment) {
  156.             return new Response('false');
  157.         }
  158.         foreach ($comment->getMedias() as $commentMedia) {
  159.             $result[] = $commentMedia ? $imageService->getImageURL($commentMedia, 0, 0) : '';
  160.         }
  161.         if (count($result) > 0) {
  162.             $data['commentImages'] = $result;
  163.             return new Response(json_encode($data));
  164.         } else {
  165.             return new Response('false');
  166.         }
  167.     }
  169.     /**
  170.      * @Route("/admin/comments/delete_comment_image")
  171.      */
  172.     public function ajaxDeleteCommentImage(Request $request) {
  173.         if (!$request->isXmlHttpRequest()) {
  174.             return $this->redirect("/admin");
  175.         }
  176.         $commentID = $request->request->get('id');
  177.         $media = $request->request->get('media');
  178.         $commentRepository = $this->getCommentRepository();
  179.         $comment = $commentRepository->find($commentID);
  180.         $user = $comment->getUser();
  181.         $entityManager = $this->getDoctrine()->getManager();
  182.         $mediaCount = $comment->getMedias()->count();
  183.         foreach ($comment->getMedias() as $commentMedia) {
  184.             $media = str_replace('/znijki-media/initial' . MediaType::TYPE_USER_VOTE_IMAGE_PATH, '', $media);
  185.             if($commentMedia->getName() == $media) {
  186.                 $entityManager->remove($commentMedia);
  187.                 $userBalance = $comment->getUser()->getBalance();
  188.                 if ($mediaCount == 1 && $userBalance > 0) {
  189.                     $balanceActivity = $entityManager->getRepository(UserBalanceActivity::class)->findBy([
  190.                         'entityID' => $comment->getID(),
  191.                         'type' => $entityManager->find(UserBalanceActivityType::class, UserBalanceActivity::TYPE_COMMENT_PHOTO_BONUS)
  192.                         ]);
  193.                     if (count($balanceActivity) > 0) {
  194.                         $bonusAmount = $userBalance < $balanceActivity[0]->getAmount() ? $userBalance : $balanceActivity[0]->getAmount();
  195.                         $balanceActivity = new UserBalanceActivity();
  196.                         $balanceActivity->setType($entityManager->find(UserBalanceActivityType::class, UserBalanceActivity::TYPE_COMMENT_PHOTO_BONUS_CANCEL));
  197.                         $balanceActivity->setAmount($bonusAmount * -1);
  198.                         $balanceActivity->setUser($user);
  199.                         $balanceActivity->setOperatorID($this->getUser()->getID());
  200.                         $entityManager->persist($balanceActivity);
  201.                         $comment->getUser()->setBalance($userBalance + $balanceActivity->getAmount());
  202.                     }
  203.                 }
  204.                 $entityManager->flush();
  205.             }
  206.         }
  207.         $this->resetCommentsCache($comment->getEntityID(), $comment->getTypeID());
  208.         return new Response('true');
  209.     }
  211.     /**
  212.      * @Route("/admin/comments/get_operator_answer")
  213.      */
  214.     public function ajaxGetOperatorAnswer(Request $request) {
  215.         if (!$request->isXmlHttpRequest()) {
  216.             return $this->redirect("/admin");
  217.         }
  218.         $operatorID = (int)$request->request->get('operatorID');
  219.         $requestDateFrom = $request->request->get('stat-since');
  220.         $requestDateTo = $request->request->get('stat-till');
  221.         $dateFrom = $requestDateFrom ? date('Y-m-d 00:00', strtotime($requestDateFrom)) : date('Y-m-d 00:00');
  222.         $dateTo = $requestDateTo ? date('Y-m-d 00:00', strtotime($requestDateTo)) : date('Y-m-d 00:00', strtotime('+1 days'));
  224.         $entityManager = $this->getDoctrine()->getManager('admin');
  225.         $operator = $this->getUserRepository()->find($operatorID);
  226.         if (!$operator) {
  227.             return new Response('Ошибка. Опертатор не найден!');
  228.         }
  229.         $dql = "select comment from Slivki:Comment comment
  230.             where comment.operator = :operator and comment.adminComment != ''
  231.               and comment.processedByOperatorOn >= :dateFrom and comment.processedByOperatorOn < :dateTo
  232.             order by comment.processedByOperatorOn desc";
  233.         $query = $entityManager->createQuery($dql)
  234.             ->setParameter('operator', $operator)
  235.             ->setParameter('dateFrom', $dateFrom)
  236.             ->setParameter('dateTo', $dateTo)
  237.             ->setMaxResults(100);
  238.         $data['commentList'] = $query->getResult();
  239.         return $this->render('Slivki/admin/comments/operator_answer_list.html.twig', $data);
  240.     }
  242.     /**
  243.      * @Route("/admin/comments/restore/{commentID}")
  244.      */
  245.     public function ajaxRestoreComment($commentID){
  246.         $entityManager = $this->getDoctrine()->getManager('admin');
  247.         $commentRepository = $entityManager->getRepository(Comment::class);
  248.         $comment = $commentRepository->find($commentID);
  249.         if (!$comment) {
  250.             return new Response();
  251.         }
  252.         $comment->setDeleted(false);
  253.         $entityManager->flush();
  254.         $this->resetCommentsCache($comment->getEntityID(), $comment->getTypeID());
  255.         return new Response();
  256.     }
  257. }