vendor/uvdesk/core-framework/Services/TicketService.php line 59

Open in your IDE?
  1. <?php
  3. namespace Webkul\UVDesk\CoreFrameworkBundle\Services;
  5. use Doctrine\ORM\EntityManagerInterface;
  6. use Doctrine\ORM\Query;
  7. use PDO;
  8. use Doctrine\DBAL\Driver\PDO\Connection as PDOConnection;
  9. use Symfony\Component\DependencyInjection\ContainerInterface;
  10. use Symfony\Component\EventDispatcher\GenericEvent;
  11. use Symfony\Component\Filesystem\Filesystem;
  12. use Symfony\Component\HttpFoundation\Request;
  13. use Symfony\Component\HttpFoundation\Response;
  14. use Symfony\Component\HttpFoundation\RequestStack;
  15. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  16. use Symfony\Component\Yaml\Yaml;
  17. use UVDesk\CommunityPackages\UVDesk\CustomFields\Entity;
  18. use UVDesk\CommunityPackages\UVDesk\CustomFields\Entity as CommunityPackageEntities;
  19. use Webkul\UVDesk\AutomationBundle\Entity\PreparedResponses;
  20. use Webkul\UVDesk\CoreFrameworkBundle\Entity\User;
  21. use Webkul\UVDesk\CoreFrameworkBundle\Entity\AgentActivity;
  22. use Webkul\UVDesk\CoreFrameworkBundle\Entity\Ticket;
  23. use Webkul\UVDesk\CoreFrameworkBundle\Entity\Thread;
  24. use Webkul\UVDesk\CoreFrameworkBundle\Entity\Tag;
  25. use Webkul\UVDesk\CoreFrameworkBundle\Entity\TicketType;
  26. use Webkul\UVDesk\CoreFrameworkBundle\Entity\TicketStatus;
  27. use Webkul\UVDesk\CoreFrameworkBundle\Entity\TicketPriority;
  28. use Webkul\UVDesk\CoreFrameworkBundle\Entity\SupportRole;
  29. use Webkul\UVDesk\CoreFrameworkBundle\Entity\Website;
  30. use Webkul\UVDesk\CoreFrameworkBundle\Entity\SupportGroup;
  31. use Webkul\UVDesk\CoreFrameworkBundle\Entity\SupportTeam;
  32. use Webkul\UVDesk\CoreFrameworkBundle\Entity\SupportLabel;
  33. use Webkul\UVDesk\CoreFrameworkBundle\Entity\SavedReplies;
  34. use Webkul\UVDesk\CoreFrameworkBundle\Entity\Attachment;
  35. use Webkul\UVDesk\CoreFrameworkBundle\Utils\TokenGenerator;
  36. use Webkul\UVDesk\CoreFrameworkBundle\Workflow\Events as CoreWorkflowEvents;
  37. use Webkul\UVDesk\CoreFrameworkBundle\Services\FileUploadService;
  38. use UVDesk\CommunityPackages\UVDesk\CustomFields\Entity\TicketCustomFieldsValues;
  39. use Webkul\UVDesk\CoreFrameworkBundle\Services\UserService;
  40. use Webkul\UVDesk\MailboxBundle\Utils\Mailbox\Mailbox;
  41. use Webkul\UVDesk\MailboxBundle\Utils\MailboxConfiguration;
  42. use Webkul\UVDesk\MailboxBundle\Utils\IMAP\Configuration as ImapConfiguration;
  43. use Webkul\UVDesk\SupportCenterBundle\Entity\Article;
  44. use Webkul\UVDesk\SupportCenterBundle\Entity\KnowledgebaseWebsite;
  45. use Webkul\UVDesk\MailboxBundle\Services\MailboxService;
  46. use Doctrine\DBAL\Connection;
  47. use Symfony\Component\HttpFoundation\JsonResponse;
  49. class TicketService
  50. {
  51.     const PATH_TO_CONFIG = '/config/packages/uvdesk_mailbox.yaml';
  53.     protected $container;
  54.     protected $requestStack;
  55.     protected $entityManager;
  56.     protected $fileUploadService;
  57.     protected $userService;
  58.     
  59.     public function __construct(
  60.         ContainerInterface $container, 
  61.         RequestStack $requestStack, 
  62.         EntityManagerInterface $entityManager, 
  63.         FileUploadService $fileUploadService,
  64.         UserService $userService, 
  65.         MailboxService $mailboxService
  66.     ) {
  67.         $this->container = $container;
  68.         $this->requestStack = $requestStack;
  69.         $this->entityManager = $entityManager;
  70.         $this->fileUploadService = $fileUploadService;
  71.         $this->userService = $userService;
  72.         $this->mailboxService = $mailboxService;
  73.     }
  75.     public function getPathToConfigurationFile()
  76.     {
  77.         return $this->container->get('kernel')->getProjectDir() . self::PATH_TO_CONFIG;
  78.     }
  80.     public function generateRandomEmailReferenceId()
  81.     {
  82.         $emailDomain = null;
  83.         $mailbox = $this->mailboxService->parseMailboxConfigurations()->getDefaultMailbox();
  85.         if (!empty($mailbox)) {
  86.             $smtpConfiguration = $mailbox->getSmtpConfiguration();
  88.             if (!empty($smtpConfiguration)) {
  89.                 $emailDomain = substr($smtpConfiguration->getUsername(), strpos($smtpConfiguration->getUsername(), '@'));
  90.             }
  91.         }
  93.         if (!empty($emailDomain)) {
  94.             return sprintf("<%s%s>", TokenGenerator::generateToken(20, '0123456789abcdefghijklmnopqrstuvwxyz'), $emailDomain);
  95.         }
  97.         return null;
  98.     }
  100.     // @TODO: Refactor this out of this service. Use UserService::getSessionUser() instead.
  101.     public function getUser()
  102.     {
  103.         return $this->container->get('user.service')->getCurrentUser();
  104.     }
  106.     public function getDefaultType()
  107.     {
  108.         $typeCode = $this->container->getParameter('uvdesk.default.ticket.type');
  109.         $ticketType = $this->entityManager->getRepository(TicketType::class)->findOneByCode($typeCode);
  111.         return !empty($ticketType) ? $ticketType : null;
  112.     }
  114.     public function getDefaultStatus()
  115.     {
  116.         $statusCode = $this->container->getParameter('uvdesk.default.ticket.status');
  117.         $ticketStatus = $this->entityManager->getRepository(TicketStatus::class)->findOneByCode($statusCode);
  119.         return !empty($ticketStatus) ? $ticketStatus : null;
  120.     }
  122.     public function getDefaultPriority()
  123.     {
  124.         $priorityCode = $this->container->getParameter('uvdesk.default.ticket.priority');
  125.         $ticketPriority = $this->entityManager->getRepository(TicketPriority::class)->findOneByCode($priorityCode);
  127.         return !empty($ticketPriority) ? $ticketPriority : null;
  128.     }
  130.     public function appendTwigSnippet($snippet = '')
  131.     {
  132.         switch ($snippet) {
  133.             case 'createMemberTicket':
  134.                 return $this->getMemberCreateTicketSnippet();
  135.                 break;
  136.             default:
  137.                 break;
  138.         }
  140.         return '';
  141.     }
  143.     public function getMemberCreateTicketSnippet()
  144.     {   
  145.         $twigTemplatingEngine = $this->container->get('twig');
  146.         $ticketTypeCollection = $this->entityManager->getRepository(TicketType::class)->findByIsActive(true);
  147.         
  148.         try {
  149.             if ($this->userService->isfileExists('apps/uvdesk/custom-fields')) {
  150.                 $headerCustomFields = $this->container->get('uvdesk_package_custom_fields.service')->getCustomFieldsArray('user');
  151.             } else if ($this->userService->isfileExists('apps/uvdesk/form-component')) {
  152.                 $headerCustomFields = $this->container->get('uvdesk_package_form_component.service')->getCustomFieldsArray('user');
  153.             }
  154.         } catch (\Exception $e) {
  155.             // @TODO: Log execption message
  156.         }
  158.         return $twigTemplatingEngine->render('@UVDeskCoreFramework/Snippets/createMemberTicket.html.twig', [
  159.             'ticketTypeCollection' => $ticketTypeCollection,
  160.             'headerCustomFields' => $headerCustomFields ?? null,
  161.         ]);
  162.     }
  164.     public function getCustomerCreateTicketCustomFieldSnippet()
  165.     {
  166.         try {
  167.             if ($this->userService->isfileExists('apps/uvdesk/custom-fields')) {
  168.                 $customFields = $this->container->get('uvdesk_package_custom_fields.service')->getCustomFieldsArray('customer');
  169.             } else if ($this->userService->isfileExists('apps/uvdesk/form-component')) {
  170.                 $customFields = $this->container->get('uvdesk_package_form_component.service')->getCustomFieldsArray('customer');
  171.             }
  172.         } catch (\Exception $e) {
  173.             // @TODO: Log execption message
  174.         }
  176.         return $customFields ?? null;
  177.     }
  179.     public function createTicket(array $params = [])
  180.     {
  181.         $thread = $this->entityManager->getRepository(Thread::class)->findOneByMessageId($params['messageId']);
  183.         if (empty($thread)) {
  184.             $user = $this->entityManager->getRepository(User::class)->findOneByEmail($params['from']);
  186.             if (empty($user) || null == $user->getCustomerInstance()) {
  187.                 $role = $this->entityManager->getRepository(SupportRole::class)->findOneByCode($params['role']);
  188.                 if (empty($role)) {
  189.                     throw new \Exception("The requested role '" . $params['role'] . "' does not exist.");
  190.                 }
  191.                 
  192.                 // Create User Instance
  193.                 $user = $this->container->get('user.service')->createUserInstance($params['from'], $params['name'], $role, [
  194.                     'source' => strtolower($params['source']),
  195.                     'active' => true,
  196.                 ]);
  197.             }
  199.             $params['role'] = 4;
  200.             $params['mailboxEmail'] = current($params['replyTo']); 
  201.             $params['customer'] = $params['user'] = $user;
  203.             return $this->createTicketBase($params);
  204.         }
  206.         return;
  207.     }
  209.     public function createTicketBase(array $ticketData = [])
  210.     {
  211.         if ('email' == $ticketData['source']) {
  212.             try {
  213.                 if (array_key_exists('UVDeskMailboxBundle', $this->container->getParameter('kernel.bundles'))) {
  214.                     $mailbox = $this->mailboxService->getMailboxByEmail($ticketData['mailboxEmail']);
  215.                 }
  216.             } catch (\Exception $e) {
  217.                 // No mailbox found for this email. Skip ticket creation.
  218.                 return;
  219.             }
  220.         }
  222.         // Set Defaults
  223.         $ticketType = !empty($ticketData['type']) ? $ticketData['type'] : $this->getDefaultType();
  224.         $ticketStatus = !empty($ticketData['status']) ? $ticketData['status'] : $this->getDefaultStatus();
  225.         $ticketPriority = !empty($ticketData['priority']) ? $ticketData['priority'] : $this->getDefaultPriority();
  227.         if ('email' == $ticketData['source']) {
  228.             $ticketMessageId = !empty($ticketData['messageId']) ? $ticketData['messageId'] : null;
  229.         } else {
  230.             $ticketMessageId = $this->generateRandomEmailReferenceId();
  231.         }
  233.         $ticketData['type'] = $ticketType;
  234.         $ticketData['status'] = $ticketStatus;
  235.         $ticketData['priority'] = $ticketPriority;
  236.         $ticketData['messageId'] = $ticketMessageId;
  237.         $ticketData['isTrashed'] = false;
  239.         $ticket = new Ticket();
  241.         foreach ($ticketData as $property => $value) {
  242.             $callable = 'set' . ucwords($property);
  244.             if (method_exists($ticket, $callable)) {
  245.                 $ticket->$callable($value);
  246.             }
  247.         }
  249.         $this->entityManager->persist($ticket);
  250.         $this->entityManager->flush();
  252.         return $this->createThread($ticket, $ticketData);
  253.     }
  254.     
  255.     public function createThread(Ticket $ticket, array $threadData)
  256.     {
  257.         $threadData['isLocked'] = 0;
  258.       
  259.         if ('forward' === $threadData['threadType']) {
  260.             $threadData['replyTo'] = $threadData['to'];
  261.         }
  263.         $collaboratorEmails = array_merge(!empty($threadData['cccol']) ? $threadData['cccol'] : [], !empty($threadData['cc']) ? $threadData['cc'] : []);
  264.         
  265.         if (!empty($collaboratorEmails)) {
  266.             $threadData['cc'] = $collaboratorEmails;
  267.         }
  268.    
  269.         $thread = new Thread();
  270.         $thread->setTicket($ticket);
  271.         $thread = new Thread();
  272.         $thread->setTicket($ticket);
  273.         // Determine which typeId to use
  274.         if (isset($threadData['typeId'])) {
  275.             // Use the provided typeId from $threadData if it's defined
  276.             $typeId = $threadData['typeId'];
  277.         } else {
  278.             // Otherwise, get the type id from the ticket
  279.             $type = $ticket->getType();
  280.             if ($type) {
  281.                 $typeId = $type->getId();  // Get the id from the ticket's type object
  282.             } else {
  283.                 $typeId = null;  // Handle the case where the ticket has no type
  284.             }
  285.         }
  286.         $thread->setTypeId($typeId);
  287.         $thread->setCreatedAt(new \DateTime());
  288.         $thread->setUpdatedAt(new \DateTime());
  289.         
  290.         if (isset($threadData['timeSpent']) && !empty($threadData['timeSpent'])) {
  291.         $thread->setTimeSpent($threadData['timeSpent']);
  292.             }
  294.         if ($threadData['threadType'] != "note") {
  295.             foreach ($threadData as $property => $value) {
  296.                 if (!empty($value)) {
  297.                     $callable = 'set' . ucwords($property);
  298.                     if (method_exists($thread, $callable)) {
  299.                         $thread->$callable($value);
  300.                     }
  301.                 }
  302.             }
  303.         } else {
  304.             $this->setTicketNotePlaceholderValue($thread, $threadData, $ticket);
  305.         }
  307.         // Update ticket reference ids is thread message id is defined
  308.         if (null != $thread->getMessageId() && false === strpos($ticket->getReferenceIds(), $thread->getMessageId())) {
  309.             $updatedReferenceIds = $ticket->getReferenceIds() . ' ' . $thread->getMessageId();            
  310.             $ticket->setReferenceIds($updatedReferenceIds);
  312.             $this->entityManager->persist($ticket);
  313.         }
  315.         if ('reply' === $threadData['threadType']) {
  316.             if ('agent' === $threadData['createdBy']) {
  317.                 // Ticket has been updated by support agents, mark as agent replied | customer view pending
  318.                 $ticket->setIsCustomerViewed(false);
  319.                 $ticket->setIsReplied(true);
  321.                 $customerName = $ticket->getCustomer()->getFirstName().' '.$ticket->getCustomer()->getLastName();
  323.                 $agentActivity = new AgentActivity();
  324.                 $agentActivity->setThreadType('reply');
  325.                 $agentActivity->setTicket($ticket);
  326.                 $agentActivity->setAgent($thread->getUser());
  327.                 $agentActivity->setCustomerName($customerName);
  328.                 $agentActivity->setAgentName('agent');
  329.                 $agentActivity->setCreatedAt(new \DateTime());
  331.                 $this->entityManager->persist($agentActivity);
  332.             } else {
  333.                 // Ticket has been updated by customer, mark as agent view | reply pending
  334.                 $ticket->setIsAgentViewed(false);
  335.                 $ticket->setIsReplied(false);
  336.             }
  338.             $this->entityManager->persist($ticket);
  339.         } else if ('create' === $threadData['threadType']) {
  340.             $ticket->setIsReplied(false);
  341.             $this->entityManager->persist($ticket);
  343.             $customerName = $ticket->getCustomer()->getFirstName().' '.$ticket->getCustomer()->getLastName();
  345.             $agentActivity = new AgentActivity();
  346.             $agentActivity->setThreadType('create');
  347.             $agentActivity->setTicket($ticket);
  348.             $agentActivity->setAgent($thread->getUser());
  349.             $agentActivity->setCustomerName($customerName );
  350.             $agentActivity->setAgentName('agent');
  351.             $agentActivity->setCreatedAt(new \DateTime());
  353.             $this->entityManager->persist($agentActivity);
  354.         }
  355.         
  356.         $ticket->currentThread = $this->entityManager->getRepository(Thread::class)->getTicketCurrentThread($ticket);
  357.         
  358.         $this->entityManager->persist($thread);
  359.         $this->entityManager->flush();
  360.         
  361.         $ticket->createdThread = $thread;
  363.         // Uploading Attachments
  364.         if (!empty($threadData['attachments'])) {
  365.             if ('email' == $threadData['source']) {
  366.                 $this->saveThreadEmailAttachments($thread, $threadData['attachments']);
  367.             } else if (!empty($threadData['attachments'])) {
  368.                 $this->saveThreadAttachment($thread, $threadData['attachments']);
  369.             }
  370.         }
  372.         return $thread;
  373.     }
  375.     public function setTicketNotePlaceholderValue($thread, $threadData, $ticket)
  376.     {
  377.         if (!empty($threadData)) {
  378.             foreach ($threadData as $property => $value) {
  379.                 if (!empty($value)) {
  380.                     $callable = 'set' . ucwords($property);
  381.                     if (method_exists($thread, $callable)) {
  382.                         if($callable != "setMessage") {
  383.                             $thread->$callable($value);
  384.                         } else {
  385.                             $notesPlaceholders = $this->getNotePlaceholderValues($ticket, 'customer');
  386.                             $content = $value;
  387.                             foreach ($notesPlaceholders as $key => $val) {
  388.                                 if(strpos($value, "{%$key%}") !== false){
  389.                                     $content = strtr($value, ["{%$key%}" => $val, "{% $key %}" => $val]);
  390.                                 }
  391.                             }
  392.                             
  393.                             $content = stripslashes($content);
  394.                             $thread->$callable($content);
  395.                         }
  396.                     }
  397.                 }
  398.             }
  399.         }
  400.     }
  402.     public function saveThreadAttachment($thread, array $attachments)
  403.     {
  404.         $prefix = 'threads/' . $thread->getId();
  405.         $uploadManager = $this->container->get('uvdesk.core.file_system.service')->getUploadManager();
  407.         foreach ($attachments as $attachment) {
  408.             $uploadedFileAttributes = $uploadManager->uploadFile($attachment, $prefix);
  410.             if (!empty($uploadedFileAttributes['path'])) {
  411.                 ($threadAttachment = new Attachment())
  412.                     ->setThread($thread)
  413.                     ->setName($uploadedFileAttributes['name'])
  414.                     ->setPath($uploadedFileAttributes['path'])
  415.                     ->setSize($uploadedFileAttributes['size'])
  416.                     ->setContentType($uploadedFileAttributes['content-type']);
  417.                 
  418.                 $this->entityManager->persist($threadAttachment);
  419.             }
  420.         }
  422.         $this->entityManager->flush();
  423.     }
  425.     public function saveThreadEmailAttachments($thread, array $attachments)
  426.     {
  427.         $prefix = 'threads/' . $thread->getId();
  428.         $uploadManager = $this->container->get('uvdesk.core.file_system.service')->getUploadManager();
  429.         
  430.         // Upload thread attachments
  431.         foreach ($attachments as $attachment) {
  432.             $uploadedFileAttributes = $uploadManager->uploadEmailAttachment($attachment, $prefix);
  433.             
  434.             if (!empty($uploadedFileAttributes['path'])) {
  435.                 ($threadAttachment = new Attachment())
  436.                     ->setThread($thread)
  437.                     ->setName($uploadedFileAttributes['name'])
  438.                     ->setPath($uploadedFileAttributes['path'])
  439.                     ->setSize($uploadedFileAttributes['size'])
  440.                     ->setContentType($uploadedFileAttributes['content-type']);
  441.                 
  442.                 $this->entityManager->persist($threadAttachment);
  443.             }
  444.         }
  446.         $this->entityManager->flush();
  447.     }
  449.     public function getTypes($visibilityFilter = [])
  450.     {
  451.         static $types;
  452.         if (null !== $types)
  453.             return $types;
  454.     
  455.         $qb = $this->entityManager->createQueryBuilder();
  456.         $qb->select('tp.id', 'tp.code AS name')
  457.             ->from(TicketType::class, 'tp')
  458.             ->where('tp.isActive = 1') // Ensure only active types are fetched
  459.             ->orderBy('tp.code', 'ASC');
  460.     
  461.         // Apply visibility filter (0 = Customer, 2 = Both)
  462.         if (!empty($visibilityFilter)) {
  463.             $qb->andWhere('tp.visibility IN (:visibility)')
  464.             ->setParameter('visibility', $visibilityFilter);
  465.         }
  466.     
  467.         return $types = $qb->getQuery()->getArrayResult();
  468.     }
  470.     public function getStatus()
  471.     {
  472.         static $statuses;
  473.         if (null !== $statuses)
  474.             return $statuses;
  476.         $qb = $this->entityManager->createQueryBuilder();
  477.         $qb->select('ts')->from(TicketStatus::class, 'ts');
  478.         // $qb->orderBy('ts.sortOrder', Criteria::ASC);
  480.         return $statuses = $qb->getQuery()->getArrayResult();
  481.     }
  483.     public function getTicketTotalThreads($ticketId)
  484.     {
  485.         $qb = $this->entityManager->createQueryBuilder();
  486.         $qb->select('COUNT(th.id) as threadCount')->from(Ticket::class, 't')
  487.             ->leftJoin('t.threads', 'th')
  488.             ->andWhere('t.id = :ticketId')
  489.             ->andWhere('th.threadType = :threadType')
  490.             ->setParameter('threadType','reply')
  491.             ->setParameter('ticketId', $ticketId);
  493.         $qb = $this->entityManager->createQueryBuilder();
  494.         $qb->select('COUNT(t.id) as threadCount')->from(Thread::class, 't')
  495.             ->andWhere('t.ticket = :ticketId')
  496.             ->andWhere('t.threadType = :threadType')
  497.             ->setParameter('threadType','reply')
  498.             ->setParameter('ticketId', $ticketId);
  500.         return $qb->getQuery()->getSingleScalarResult();
  501.     }
  503.     public function getTicketTags($request = null)
  504.     {
  505.         $qb = $this->entityManager->createQueryBuilder();
  506.         $qb->select('tg')->from(Tag::class, 'tg');
  508.         if($request) {
  509.             $qb->andwhere("tg.name LIKE :tagName");
  510.             $qb->setParameter('tagName', '%'.urldecode($request->query->get('query')).'%');
  511.             $qb->andwhere("tg.id NOT IN (:ids)");
  512.             $qb->setParameter('ids', explode(',',urldecode($request->query->get('not'))));
  513.         }
  515.         return $qb->getQuery()->getArrayResult();
  516.     }
  517.     
  518.     public function getAllMembersTicketCollection(Request $request)
  519.     {
  520.        
  521.         $params = $request->query->all();
  522.         $activeUser = $this->container->get('user.service')->getSessionUser();
  523.         $activeUserTimeZone = $this->entityManager->getRepository(Website::class)->findOneBy(['code' => 'Knowledgebase']);
  524.         $agentTimeZone = !empty($activeUser->getTimezone()) ? $activeUser->getTimezone() : $activeUserTimeZone->getTimezone();
  525.         $agentTimeFormat = !empty($activeUser->getTimeformat()) ? $activeUser->getTimeformat() : $activeUserTimeZone->getTimeformat();
  527.         $ticketRepository = $this->entityManager->getRepository(Ticket::class);
  529.         $website = $this->entityManager->getRepository(Website::class)->findOneBy(['code' => 'helpdesk']);
  530.         $timeZone = $website->getTimezone();
  531.         $timeFormat = $website->getTimeformat();
  533.         $supportGroupReference = $this->entityManager->getRepository(User::class)->getUserSupportGroupReferences($activeUser);
  534.         $supportTeamReference  = $this->entityManager->getRepository(User::class)->getUserSupportTeamReferences($activeUser);
  536.         // Get base query
  537.         $baseQuery = $ticketRepository->prepareBaseTicketQuery($activeUser, $supportGroupReference, $supportTeamReference, $params);
  538.         $ticketTabs = $ticketRepository->getTicketTabDetails($activeUser, $supportGroupReference, $supportTeamReference, $params);
  540.         // Apply Pagination
  541.         $pageNumber = !empty($params['page']) ? (int) $params['page'] : 1;
  542.         $itemsLimit = 100000;
  544.         if (isset($params['repliesLess']) || isset($params['repliesMore'])) {
  545.             $paginationOptions = ['wrap-queries' => true];
  546.             $paginationQuery = $baseQuery->getQuery()
  547.                 ->setHydrationMode(Query::HYDRATE_ARRAY);
  548.         } else {
  549.             $paginationOptions = ['distinct' => true];
  550.             $paginationQuery = $baseQuery->getQuery()
  551.                 ->setHydrationMode(Query::HYDRATE_ARRAY)
  552.                 ->setHint('knp_paginator.count', isset($params['status']) ? $ticketTabs[$params['status']] : $ticketTabs[1]);
  553.         }
  555.         $pagination = $this->container->get('knp_paginator')->paginate($paginationQuery, $pageNumber, $itemsLimit, $paginationOptions);
  556.         // Process Pagination Response
  557.         $ticketCollection = [];
  558.         $paginationParams = $pagination->getParams();
  559.         $paginationData = $pagination->getPaginationData();
  561.         $paginationParams['page'] = 'replacePage';
  562.         $paginationData['url'] = '#' . $this->container->get('uvdesk.service')->buildPaginationQuery($paginationParams);
  563.         // $container->get('default.service')->buildSessionUrl('ticket',$queryParameters);
  566.         $ticketThreadCountQueryTemplate = $this->entityManager->createQueryBuilder()
  567.             ->select('COUNT(thread.id) as threadCount')
  568.             ->from(Ticket::class, 'ticket')
  569.             ->leftJoin('ticket.threads', 'thread')
  570.             ->where('ticket.id = :ticketId')
  571.             ->andWhere('thread.threadType = :threadType')->setParameter('threadType', 'reply');
  572.         
  573.         foreach ($pagination->getItems() as $ticketDetails) {
  574.             $ticket = array_shift($ticketDetails);
  576.             $ticketThreadCountQuery = clone $ticketThreadCountQueryTemplate;
  577.             $ticketThreadCountQuery->setParameter('ticketId', $ticket['id']);
  579.             $totalTicketReplies = (int) $ticketThreadCountQuery->getQuery()->getSingleScalarResult();
  580.             $ticketHasAttachments = false;
  581.             $dbTime = $ticket['createdAt'];
  582.             
  583.             $formattedTime= $this->fomatTimeByPreference($dbTime,$timeZone,$timeFormat,$agentTimeZone,$agentTimeFormat);
  585.             $currentDateTime  = new \DateTime('now');
  586.             if($this->getLastReply($ticket['id'])) {
  587.                 $lastRepliedTime = 
  588.                 $this->time2string($currentDateTime->getTimeStamp() - $this->getLastReply($ticket['id'])['createdAt']->getTimeStamp());
  589.             } else {
  590.                 $lastRepliedTime = 
  591.                 $this->time2string($currentDateTime->getTimeStamp() - $ticket['createdAt']->getTimeStamp());
  592.             }
  594.             $ticketResponse = [
  595.                 'id' => $ticket['id'],
  596.                 'subject' => $ticket['subject'],
  597.                 'isStarred' => $ticket['isStarred'],
  598.                 'isAgentView' => $ticket['isAgentViewed'],
  599.                 'isTrashed' => $ticket['isTrashed'],
  600.                 'source' => $ticket['source'],
  601.                 'group' => $ticketDetails['groupName'],
  602.                 'team' => $ticketDetails['teamName'],
  603.                 'priority' => $ticket['priority'],
  604.                 'type' => $ticketDetails['typeName'],
  605.                 'timestamp' => $formattedTime['dateTimeZone'],
  606.                 'formatedCreatedAt' => $formattedTime['dateTimeZone']->format($formattedTime['timeFormatString']),
  607.                 'totalThreads' => $totalTicketReplies,
  608.                 'agent' => null,
  609.                 'customer' => null,
  610.                 'hasAttachments' => $ticketHasAttachments,
  611.                 'lastReplyTime' => $lastRepliedTime
  612.             ];
  613.            
  614.             if (!empty($ticketDetails['agentId'])) {
  615.                 $ticketResponse['agent'] = [
  616.                     'id' => $ticketDetails['agentId'],
  617.                     'name' => $ticketDetails['agentName'],
  618.                     'smallThumbnail' => $ticketDetails['smallThumbnail'],
  619.                 ];
  620.             }
  622.             if (!empty($ticketDetails['customerId'])) {
  623.                 $ticketResponse['customer'] = [
  624.                     'id' => $ticketDetails['customerId'],
  625.                     'name' => $ticketDetails['customerName'],
  626.                     'email' => $ticketDetails['customerEmail'],
  627.                     'smallThumbnail' => $ticketDetails['customersmallThumbnail'],
  628.                 ];
  629.             }
  631.             array_push($ticketCollection, $ticketResponse);
  632.         }
  633.          
  634.         return [
  635.             'tickets' => $ticketCollection,
  636.             'pagination' => $paginationData,
  637.             'tabs' => $ticketTabs,
  638.             'labels' => [
  639.                 'predefind' => $this->getPredefindLabelDetails($activeUser, $supportGroupReference, $supportTeamReference, $params),
  640.                 'custom' => $this->getCustomLabelDetails($this->container),
  641.             ],
  642.           
  643.         ];
  644.     }
  645.     
  646.     public function paginateMembersTicketCollection(Request $request)
  647.     {
  648.         $params = $request->query->all();
  649.         $activeUser = $this->container->get('user.service')->getSessionUser();
  650.         $activeUserTimeZone = $this->entityManager->getRepository(Website::class)->findOneBy(['code' => 'Knowledgebase']);
  651.         $agentTimeZone = !empty($activeUser->getTimezone()) ? $activeUser->getTimezone() : $activeUserTimeZone->getTimezone();
  652.         $agentTimeFormat = !empty($activeUser->getTimeformat()) ? $activeUser->getTimeformat() : $activeUserTimeZone->getTimeformat();
  654.         $ticketRepository = $this->entityManager->getRepository(Ticket::class);
  656.         $website = $this->entityManager->getRepository(Website::class)->findOneBy(['code' => 'helpdesk']);
  657.         $timeZone = $website->getTimezone();
  658.         $timeFormat = $website->getTimeformat();
  660.         $supportGroupReference = $this->entityManager->getRepository(User::class)->getUserSupportGroupReferences($activeUser);
  661.         $supportTeamReference  = $this->entityManager->getRepository(User::class)->getUserSupportTeamReferences($activeUser);
  663.         // Get base query
  664.         $baseQuery = $ticketRepository->prepareBaseTicketQuery($activeUser, $supportGroupReference, $supportTeamReference, $params);
  665.         $ticketTabs = $ticketRepository->getTicketTabDetails($activeUser, $supportGroupReference, $supportTeamReference, $params);
  667.         // Apply Pagination
  668.         $pageNumber = !empty($params['page']) ? (int) $params['page'] : 1;
  669.         $itemsLimit = !empty($params['limit']) ? (int) $params['limit'] : $ticketRepository::DEFAULT_PAGINATION_LIMIT;
  671.         if (isset($params['repliesLess']) || isset($params['repliesMore'])) {
  672.             $paginationOptions = ['wrap-queries' => true];
  673.             $paginationQuery = $baseQuery->getQuery()
  674.                 ->setHydrationMode(Query::HYDRATE_ARRAY);
  675.         } else {
  676.             $paginationOptions = ['distinct' => true];
  677.             $paginationQuery = $baseQuery->getQuery()
  678.                 ->setHydrationMode(Query::HYDRATE_ARRAY)
  679.                 ->setHint('knp_paginator.count', isset($params['status']) ? $ticketTabs[$params['status']] : $ticketTabs[1]);
  680.         }
  682.         $pagination = $this->container->get('knp_paginator')->paginate($paginationQuery, $pageNumber, $itemsLimit, $paginationOptions);
  683.         // Process Pagination Response
  684.         $ticketCollection = [];
  685.         $paginationParams = $pagination->getParams();
  686.         $paginationData = $pagination->getPaginationData();
  688.         $paginationParams['page'] = 'replacePage';
  689.         $paginationData['url'] = '#' . $this->container->get('uvdesk.service')->buildPaginationQuery($paginationParams);
  690.         // $container->get('default.service')->buildSessionUrl('ticket',$queryParameters);
  693.         $ticketThreadCountQueryTemplate = $this->entityManager->createQueryBuilder()
  694.             ->select('COUNT(thread.id) as threadCount')
  695.             ->from(Ticket::class, 'ticket')
  696.             ->leftJoin('ticket.threads', 'thread')
  697.             ->where('ticket.id = :ticketId')
  698.             ->andWhere('thread.threadType = :threadType')->setParameter('threadType', 'reply');
  699.         
  700.         foreach ($pagination->getItems() as $ticketDetails) {
  701.             $ticket = array_shift($ticketDetails);
  703.             $ticketThreadCountQuery = clone $ticketThreadCountQueryTemplate;
  704.             $ticketThreadCountQuery->setParameter('ticketId', $ticket['id']);
  706.             $totalTicketReplies = (int) $ticketThreadCountQuery->getQuery()->getSingleScalarResult();
  707.             $ticketHasAttachments = false;
  708.             $dbTime = $ticket['createdAt'];
  709.             
  710.             $formattedTime= $this->fomatTimeByPreference($dbTime,$timeZone,$timeFormat,$agentTimeZone,$agentTimeFormat);
  712.             $currentDateTime  = new \DateTime('now');
  713.             if($this->getLastReply($ticket['id'])) {
  714.                 $lastRepliedTime = 
  715.                 $this->time2string($currentDateTime->getTimeStamp() - $this->getLastReply($ticket['id'])['createdAt']->getTimeStamp());
  716.             } else {
  717.                 $lastRepliedTime = 
  718.                 $this->time2string($currentDateTime->getTimeStamp() - $ticket['createdAt']->getTimeStamp());
  719.             }
  721.             $ticketResponse = [
  722.                 'id' => $ticket['id'],
  723.                 'subject' => $ticket['subject'],
  724.                 'isStarred' => $ticket['isStarred'],
  725.                 'isAgentView' => $ticket['isAgentViewed'],
  726.                 'isTrashed' => $ticket['isTrashed'],
  727.                 'source' => $ticket['source'],
  728.                 'group' => $ticketDetails['groupName'],
  729.                 'team' => $ticketDetails['teamName'],
  730.                 'priority' => $ticket['priority'],
  731.                 'type' => $ticketDetails['typeName'],
  732.                 'timestamp' => $formattedTime['dateTimeZone'],
  733.                 'formatedCreatedAt' => $formattedTime['dateTimeZone']->format($formattedTime['timeFormatString']),
  734.                 'totalThreads' => $totalTicketReplies,
  735.                 'agent' => null,
  736.                 'customer' => null,
  737.                 'hasAttachments' => $ticketHasAttachments,
  738.                 'lastReplyTime' => $lastRepliedTime
  739.             ];
  740.            
  741.             if (!empty($ticketDetails['agentId'])) {
  742.                 $ticketResponse['agent'] = [
  743.                     'id' => $ticketDetails['agentId'],
  744.                     'name' => $ticketDetails['agentName'],
  745.                     'smallThumbnail' => $ticketDetails['smallThumbnail'],
  746.                 ];
  747.             }
  749.             if (!empty($ticketDetails['customerId'])) {
  750.                 $ticketResponse['customer'] = [
  751.                     'id' => $ticketDetails['customerId'],
  752.                     'name' => $ticketDetails['customerName'],
  753.                     'email' => $ticketDetails['customerEmail'],
  754.                     'contactNumber' => $ticketDetails['contactNumber'],
  755.                     'smallThumbnail' => $ticketDetails['customersmallThumbnail'],
  756.                 ];
  757.             }
  759.             array_push($ticketCollection, $ticketResponse);
  760.         }
  761.          
  762.         return [
  763.             'tickets' => $ticketCollection,
  764.             'pagination' => $paginationData,
  765.             'tabs' => $ticketTabs,
  766.             'labels' => [
  767.                 'predefind' => $this->getPredefindLabelDetails($activeUser, $supportGroupReference, $supportTeamReference, $params),
  768.                 'custom' => $this->getCustomLabelDetails($this->container),
  769.             ],
  770.           
  771.         ];
  772.     }
  774.     // Convert Timestamp to day/hour/min
  775.     Public function time2string($time) {
  776.         $d = floor($time/86400);
  777.         $_d = ($d < 10 ? '0' : '').$d;
  779.         $h = floor(($time-$d*86400)/3600);
  780.         $_h = ($h < 10 ? '0' : '').$h;
  782.         $m = floor(($time-($d*86400+$h*3600))/60);
  783.         $_m = ($m < 10 ? '0' : '').$m;
  785.         $s = $time-($d*86400+$h*3600+$m*60);
  786.         $_s = ($s < 10 ? '0' : '').$s;
  788.         $time_str = "0 minutes";
  789.         if($_d != 00)
  790.             $time_str = $_d." ".'days';
  791.         elseif($_h != 00)
  792.             $time_str = $_h." ".'hours';
  793.         elseif($_m != 00)
  794.             $time_str = $_m." ".'minutes';
  796.         return $time_str." "."ago";
  797.     }
  799.     public function getPredefindLabelDetails(User $currentUser, array $supportGroupIds = [], array $supportTeamIds = [], array $params = [])
  800.     {
  801.         $data = array();
  802.         $queryBuilder = $this->entityManager->createQueryBuilder();
  803.         $ticketRepository = $this->entityManager->getRepository(Ticket::class);
  804.         $queryBuilder->select('COUNT(DISTINCT ticket.id) as ticketCount')->from(Ticket::class, 'ticket');
  805.             
  806.         // // applyFilter according to permission
  807.         $queryBuilder->where('ticket.isTrashed != 1');
  808.         $userInstance = $currentUser->getAgentInstance();
  810.         if (!empty($userInstance) &&  'ROLE_AGENT' == $userInstance->getSupportRole()->getCode() 
  811.         && $userInstance->getTicketAccesslevel() != 1) {
  812.             $supportGroupIds = implode(',', $supportGroupIds);
  813.             $supportTeamIds = implode(',', $supportTeamIds);
  815.             if ($userInstance->getTicketAccesslevel() == 4) {
  816.                 $queryBuilder->andwhere('ticket.agent = ' . $currentUser->getId());
  817.             } elseif ($userInstance->getTicketAccesslevel() == 2) {
  818.                 $query = '';
  819.                 if ($supportGroupIds){
  820.                     $query .= ' OR supportGroup.id IN('.$supportGroupIds.') ';
  821.                 }
  822.                 if ($supportTeamIds) {
  823.                     $query .= ' OR supportTeam.id IN('.$supportTeamIds.') ';
  824.                 }
  825.                 $queryBuilder->leftJoin('ticket.supportGroup', 'supportGroup')
  826.                             ->leftJoin('ticket.supportTeam', 'supportTeam')
  827.                             ->andwhere('( ticket.agent = ' . $currentUser->getId().$query.')');
  828.                     
  829.             } elseif ($userInstance->getTicketAccesslevel() == 3) {
  830.                 $query = '';
  831.                 if ($supportTeamIds) {
  832.                     $query .= ' OR supportTeam.id IN('.$supportTeamIds.') ';
  833.                 }
  834.                 $queryBuilder->leftJoin('ticket.supportGroup', 'supportGroup')
  835.                             ->leftJoin('ticket.supportTeam', 'supportTeam')
  836.                             ->andwhere('( ticket.agent = ' . $currentUser->getId().$query. ')');
  837.             }
  838.         }
  840.         // for all tickets count
  841.         $data['all'] = $queryBuilder->getQuery()->getSingleScalarResult();
  843.         // for new tickets count
  844.         $newQb = clone $queryBuilder;
  845.         $newQb->andwhere('ticket.isNew = 1');
  846.         $data['new'] = $newQb->getQuery()->getSingleScalarResult();
  848.         // for unassigned tickets count
  849.         $unassignedQb = clone $queryBuilder;
  850.         $unassignedQb->andwhere("ticket.agent is NULL");
  851.         $data['unassigned'] = $unassignedQb->getQuery()->getSingleScalarResult();
  853.         // for unanswered ticket count
  854.         $unansweredQb = clone $queryBuilder;
  855.         $unansweredQb->andwhere('ticket.isReplied = 0');
  856.         $data['notreplied'] = $unansweredQb->getQuery()->getSingleScalarResult();
  858.         // for my tickets count
  859.         $mineQb = clone $queryBuilder;
  860.         $mineQb->andWhere("ticket.agent = :agentId")
  861.                 ->setParameter('agentId', $currentUser->getId());
  862.         $data['mine'] = $mineQb->getQuery()->getSingleScalarResult();
  864.         // for starred tickets count
  865.         $starredQb = clone $queryBuilder;
  866.         $starredQb->andwhere('ticket.isStarred = 1');
  867.         $data['starred'] = $starredQb->getQuery()->getSingleScalarResult();
  869.         // for trashed tickets count
  870.         $trashedQb = clone $queryBuilder;
  871.         $trashedQb->where('ticket.isTrashed = 1');
  872.         if ($currentUser->getRoles()[0] != 'ROLE_SUPER_ADMIN' && $userInstance->getTicketAccesslevel() != 1) {
  873.             $trashedQb->andwhere('ticket.agent = ' . $currentUser->getId());
  874.         }
  875.         $data['trashed'] = $trashedQb->getQuery()->getSingleScalarResult();
  877.         return $data;
  878.     }
  879.     
  880.     public function paginateMembersTicketThreadCollection(Ticket $ticket, Request $request)
  881.     {
  882.         $params = $request->query->all();
  883.         $entityManager = $this->entityManager;
  884.         $activeUser = $this->container->get('user.service')->getSessionUser();
  885.         $ticketTypeRepo = $entityManager->getRepository(TicketType::class);
  887.         $activeUserTimeZone = $this->entityManager->getRepository(Website::class)->findOneBy(['code' => 'Knowledgebase']);
  888.         $agentTimeZone = !empty($activeUser->getTimezone()) ? $activeUser->getTimezone() : $activeUserTimeZone->getTimezone();
  889.         $agentTimeFormat = !empty($activeUser->getTimeformat()) ? $activeUser->getTimeformat() : $activeUserTimeZone->getTimeformat();
  890.         
  891.         $threadRepository = $entityManager->getRepository(Thread::class);
  892.         $uvdeskFileSystemService = $this->container->get('uvdesk.core.file_system.service');
  894.         // Get base query
  895.         $enableLockedThreads = $this->container->get('user.service')->isAccessAuthorized('ROLE_AGENT_MANAGE_LOCK_AND_UNLOCK_THREAD');
  896.         $baseQuery = $threadRepository->prepareBasePaginationRecentThreadsQuery($ticket, $params, $enableLockedThreads);
  897.         
  898.         // Apply Pagination
  899.         $paginationItemsQuery = clone $baseQuery;
  900.         $totalPaginationItems = $paginationItemsQuery->select('COUNT(DISTINCT thread.id)')->getQuery()->getSingleScalarResult();
  901.         
  902.         $pageNumber = !empty($params['page']) ? (int) $params['page'] : 1;
  903.         $itemsLimit = !empty($params['limit']) ? (int) $params['limit'] : $threadRepository::DEFAULT_PAGINATION_LIMIT;
  904.         
  905.         $paginationOptions = ['distinct' => true];
  906.         $paginationQuery = $baseQuery->getQuery()->setHydrationMode(Query::HYDRATE_ARRAY)->setHint('knp_paginator.count', (int) $totalPaginationItems);
  908.         $pagination = $this->container->get('knp_paginator')->paginate($paginationQuery, $pageNumber, $itemsLimit, $paginationOptions);
  910.         // Process Pagination Response
  911.         $threadCollection = [];
  912.         $paginationParams = $pagination->getParams();
  913.         $paginationData = $pagination->getPaginationData();
  915.         $website = $this->entityManager->getRepository(Website::class)->findOneBy(['code' => 'helpdesk']);
  916.         $timeZone = $website->getTimezone();
  917.         $timeFormat = $website->getTimeformat();
  919.         if (!empty($params['threadRequestedId'])) {
  920.             $requestedThreadCollection = $baseQuery
  921.                 ->andWhere('thread.id >= :threadRequestedId')->setParameter('threadRequestedId', (int) $params['threadRequestedId'])
  922.                 ->getQuery()->getArrayResult();
  923.             
  924.             $totalRequestedThreads = count($requestedThreadCollection);
  925.             $paginationData['current'] = ceil($totalRequestedThreads / $threadRepository::DEFAULT_PAGINATION_LIMIT);
  927.             if ($paginationData['current'] > 1) {
  928.                 $paginationData['firstItemNumber'] = 1;
  929.                 $paginationData['lastItemNumber'] = $totalRequestedThreads;
  930.                 $paginationData['next'] = ceil(($totalRequestedThreads + 1) / $threadRepository::DEFAULT_PAGINATION_LIMIT);
  931.             }
  932.         }
  934.         $paginationParams['page'] = 'replacePage';
  935.         $paginationData['url'] = '#' . $this->container->get('uvdesk.service')->buildPaginationQuery($paginationParams);
  936.         foreach ($pagination->getItems() as $threadDetails) {
  937.             $dbTime = $threadDetails['createdAt'];
  938.             $formattedTime = $this->fomatTimeByPreference($dbTime,$timeZone,$timeFormat,$agentTimeZone,$agentTimeFormat);
  939.             
  940.             // Fetch custom fields and their values for the provided thread_id
  941.             $customFields = $entityManager->getRepository(TicketCustomFieldsValues::class)->findBy([
  942.                 'ThreadId' => $threadDetails['id']
  943.             ]);
  945.             $responseArray = [];
  946.             if (!empty($customFields)) {
  947.                 foreach ($customFields as $field) {
  948.                     $responseArray[] = [
  949.                         'custom_field_id' => $field->getTicketCustomFieldsValues()->getId(),
  950.                         'value' => $field->getValue(),
  951.                     ];
  952.                 }
  953.             }
  954.             
  955.             $typeId = $threadDetails['typeId'] ?? null;
  956.             $typeCode = "";
  957.             $typeDescription = "";
  959.             if ($typeId) {
  960.                 $ticketType = $ticketTypeRepo->find($typeId);
  961.                 if ($ticketType) {
  962.                     $typeCode = $ticketType->getCode();
  963.                     $typeDescription = $ticketType->getDescription();
  964.                 } else {
  965.                     $typeCode = null;
  966.                     $typeDescription = null;
  967.                 }
  968.             } else {
  969.                 $typeCode = null;
  970.                 $typeDescription = null;
  971.             }
  973.             $threadResponse = [
  974.                 'id' => $threadDetails['id'],
  975.                 'user' => null,
  976.                 'fullname' => null,
  977.                 'typeid' => $threadDetails['typeId'],
  978.                 'typeCode' => $typeCode,
  979.                 'typeDescription' => $typeDescription,
  980.                 'reply' => html_entity_decode($threadDetails['message']),
  981.                 'source' => $threadDetails['source'],
  982.                 'threadType' => $threadDetails['threadType'],
  983.                 'userType' => $threadDetails['createdBy'],
  984.                 'timestamp' => $formattedTime['dateTimeZone'],
  985.                 'formatedCreatedAt' => $formattedTime['dateTimeZone']->format($formattedTime['timeFormatString']),
  986.                 'bookmark' => $threadDetails['isBookmarked'],
  987.                 'isLocked' => $threadDetails['isLocked'],
  988.                 'replyTo' => $threadDetails['replyTo'],
  989.                 'cc' => $threadDetails['cc'],
  990.                 'bcc' => $threadDetails['bcc'],
  991.                 'attachments' => $threadDetails['attachments'],
  992.                 'timeSpent' => $threadDetails['timeSpent'],
  993.                 'customfields' => $responseArray
  994.             ];
  995.   
  996.             if (!empty($threadDetails['user'])) {
  997.                 $threadResponse['fullname'] = trim($threadDetails['user']['firstName'] . ' ' . $threadDetails['user']['lastName']);
  998.                 $threadResponse['user'] = [
  999.                     'id' => $threadDetails['user']['id'],
  1000.                     'smallThumbnail' => $threadDetails['user']['userInstance'][0]['profileImagePath'],
  1001.                     'name' => $threadResponse['fullname'],
  1002.                 ];
  1003.             }
  1005.             if (!empty($threadResponse['attachments'])) {
  1006.                 $threadResponse['attachments'] = array_map(function ($attachment) use ($entityManager, $uvdeskFileSystemService) {
  1007.                     $attachmentReferenceObject = $entityManager->getReference(Attachment::class, $attachment['id']);
  1008.                     return $uvdeskFileSystemService->getFileTypeAssociations($attachmentReferenceObject);
  1009.                 }, $threadResponse['attachments']);
  1010.             }
  1012.             array_push($threadCollection, $threadResponse);
  1013.         }
  1015.         return [
  1016.             'threads' => $threadCollection,
  1017.             'pagination' => $paginationData,
  1018.         ];
  1019.     }
  1021.     public function massXhrUpdate(Request $request)
  1022.     {
  1023.         $params = $request->request->get('data');
  1025.         foreach ($params['ids'] as $ticketId) {
  1026.             $ticket = $this->entityManager->getRepository(Ticket::class)->find($ticketId);
  1028.             if (false == $this->isTicketAccessGranted($ticket)) {
  1029.                 throw new \Exception('Access Denied', 403);
  1030.             }
  1031.             
  1032.             if (empty($ticket)) {
  1033.                 continue;
  1034.             }
  1037.             switch ($params['actionType']) {
  1038.                 case 'trashed':
  1039.                     if (false == $ticket->getIsTrashed()) {
  1040.                         $ticket->setIsTrashed(true);
  1041.                         
  1042.                         $this->entityManager->persist($ticket);
  1043.                     }
  1045.                     // Trigger ticket delete event
  1046.                     $event = new GenericEvent(CoreWorkflowEvents\Ticket\Delete::getId(), [
  1047.                         'entity' => $ticket,
  1048.                     ]);
  1050.                     $this->container->get('event_dispatcher')->dispatch($event, 'uvdesk.automation.workflow.execute');
  1052.                     break;
  1053.                 case 'delete':
  1055.                     $threads = $ticket->getThreads();
  1056.                     $fileService = new Filesystem();
  1057.                     if (count($threads) > 0) {
  1058.                         foreach($threads as $thread) {
  1059.                             if (!empty($thread)) {
  1060.                                 $fileService->remove($this->container->getParameter('kernel.project_dir').'/public/assets/threads/'.$thread->getId());
  1061.                             }
  1062.                         }
  1063.                     }
  1065.                     $this->entityManager->remove($ticket);
  1066.                     
  1068.                     break;
  1069.                 case 'restored':
  1070.                     if (true == $ticket->getIsTrashed()) {
  1071.                         $ticket->setIsTrashed(false);
  1073.                         $this->entityManager->persist($ticket);
  1074.                     }
  1075.                     break;
  1076.                 case 'agent':
  1077.                     if ($ticket->getAgent() == null || $ticket->getAgent() && $ticket->getAgent()->getId() != $params['targetId']) {
  1079.                         $agent = $this->entityManager->getRepository(User::class)->find($params['targetId']);
  1080.                         $ticket->setAgent($agent);
  1081.     
  1082.                         $this->entityManager->persist($ticket);
  1083.     
  1084.                         // Trigger Agent Assign event
  1085.                         $event = new GenericEvent(CoreWorkflowEvents\Ticket\Agent::getId(), [
  1086.                             'entity' => $ticket,
  1087.                             'customfields' => "",
  1088.                         ]);
  1089.     
  1090.                         $this->container->get('event_dispatcher')->dispatch($event, 'uvdesk.automation.workflow.execute');
  1091.                     }
  1092.                     break;
  1093.                 case 'status':
  1094.                     if ($ticket->getStatus() == null || $ticket->getStatus() && $ticket->getStatus()->getId() != $params['targetId']) {
  1096.                         $status = $this->entityManager->getRepository(TicketStatus::class)->findOneById($params['targetId']);
  1097.                         $ticket->setStatus($status);
  1099.                         $this->entityManager->persist($ticket);
  1101.                         // Trigger ticket status event
  1102.                         $event = new GenericEvent(CoreWorkflowEvents\Ticket\Status::getId(), [
  1103.                             'entity' => $ticket,
  1104.                         ]);
  1105.                         
  1106.                         $this->container->get('event_dispatcher')->dispatch($event, 'uvdesk.automation.workflow.execute');
  1107.                     }
  1108.                     
  1109.                     break;
  1110.                 case 'type':
  1111.                     if ($ticket->getType() == null || $ticket->getType() && $ticket->getType()->getId() != $params['targetId']) {
  1113.                         $type = $this->entityManager->getRepository(TicketType::class)->findOneById($params['targetId']);
  1114.                         $ticket->setType($type);
  1115.     
  1116.                         $this->entityManager->persist($ticket);
  1117.     
  1118.                         // Trigger ticket type event
  1119.                         $event = new GenericEvent(CoreWorkflowEvents\Ticket\Type::getId(), [
  1120.                             'entity' => $ticket,
  1121.                         ]);
  1122.     
  1123.                         $this->container->get('event_dispatcher')->dispatch($event, 'uvdesk.automation.workflow.execute');
  1124.                     }
  1126.                     break;
  1127.                 case 'group':
  1128.                     if ($ticket->getSupportGroup() == null || $ticket->getSupportGroup() && $ticket->getSupportGroup()->getId() != $params['targetId']) {
  1130.                         $group = $this->entityManager->getRepository(SupportGroup::class)->find($params['targetId']);
  1131.                         $ticket->setSupportGroup($group);
  1132.     
  1133.                         $this->entityManager->persist($ticket);
  1134.     
  1135.                         // Trigger Support group event
  1136.                         $event = new GenericEvent(CoreWorkflowEvents\Ticket\Group::getId(), [
  1137.                             'entity' => $ticket,
  1138.                         ]);
  1139.     
  1140.                         $this->container->get('event_dispatcher')->dispatch($event, 'uvdesk.automation.workflow.execute');
  1141.                     }
  1143.                     break;
  1144.                 case 'team':
  1145.                     if ($ticket->getSupportTeam() == null || $ticket->getSupportTeam() && $ticket->getSupportTeam()->getId() != $params['targetId']){
  1147.                         $team = $this->entityManager->getRepository(SupportTeam::class)->find($params['targetId']);
  1148.                         $ticket->setSupportTeam($team);
  1149.                         
  1150.                         $this->entityManager->persist($ticket);
  1151.         
  1152.                         // Trigger team event
  1153.                         $event = new GenericEvent(CoreWorkflowEvents\Ticket\Team::getId(), [
  1154.                             'entity' => $ticket,
  1155.                         ]);
  1156.         
  1157.                         $this->container->get('event_dispatcher')->dispatch($event, 'uvdesk.automation.workflow.execute');
  1158.                     }
  1160.                     break;
  1161.                 case 'priority':
  1162.                     if ($ticket->getPriority() == null || $ticket->getPriority() && $ticket->getPriority()->getId() != $params['targetId']) {
  1163.                         
  1164.                         $priority = $this->entityManager->getRepository(TicketPriority::class)->find($params['targetId']);
  1165.                         $ticket->setPriority($priority);
  1166.     
  1167.                         $this->entityManager->persist($ticket);
  1168.     
  1169.                         // Trigger ticket Priority event
  1170.                         $event = new GenericEvent(CoreWorkflowEvents\Ticket\Priority::getId(), [
  1171.                             'entity' => $ticket,
  1172.                         ]);
  1173.     
  1174.                         $this->container->get('event_dispatcher')->dispatch($event, 'uvdesk.automation.workflow.execute');
  1175.                     }
  1177.                     break;
  1178.                 case 'label':
  1179.                     $label = $this->entityManager->getRepository(SupportLabel::class)->find($params['targetId']);
  1180.                     
  1181.                     if ($label && !$this->entityManager->getRepository(Ticket::class)->isLabelAlreadyAdded($ticket, $label)) {
  1182.                         $ticket->addSupportLabel($label);
  1183.                     }
  1184.                     
  1185.                     $this->entityManager->persist($ticket);
  1187.                     break;
  1188.                 default:
  1189.                     break;
  1190.             }
  1191.         } 
  1193.         $this->entityManager->flush();
  1195.         return [
  1196.             'alertClass' => 'success',
  1197.             'alertMessage' => $this->trans('Tickets have been updated successfully'),
  1198.         ];
  1199.     }
  1200.     
  1201.     public function getNotePlaceholderValues($ticket, $type = "customer")
  1202.     {
  1203.         $variables = array();
  1204.         $variables['ticket.id'] = $ticket->getId();
  1205.         $variables['ticket.subject'] = $ticket->getSubject();
  1207.         $variables['ticket.status'] = $ticket->getStatus()->getCode();
  1208.         $variables['ticket.priority'] = $ticket->getPriority()->getCode();
  1209.         if($ticket->getSupportGroup())
  1210.             $variables['ticket.group'] = $ticket->getSupportGroup()->getName();
  1211.         else
  1212.             $variables['ticket.group'] = '';
  1214.         $variables['ticket.team'] = ($ticket->getSupportTeam() ? $ticket->getSupportTeam()->getName() : '');
  1216.         $customer = $this->container->get('user.service')->getCustomerPartialDetailById($ticket->getCustomer()->getId());
  1217.         $variables['ticket.customerName'] = $customer['name'];
  1218.         $userService = $this->container->get('user.service');
  1219.       
  1220.         $variables['ticket.agentName'] = '';
  1221.         $variables['ticket.agentEmail'] = '';
  1222.         if ($ticket->getAgent()) {
  1223.             $agent = $this->container->get('user.service')->getAgentDetailById($ticket->getAgent()->getId());
  1224.             if($agent) {
  1225.                 $variables['ticket.agentName'] = $agent['name'];
  1226.                 $variables['ticket.agentEmail'] = $agent['email'];
  1227.             }
  1228.         }
  1230.         $router = $this->container->get('router');
  1232.         if ($type == 'customer') {
  1233.             $ticketListURL = $router->generate('helpdesk_member_ticket_collection', [
  1234.                 'id' => $ticket->getId(),
  1235.             ], UrlGeneratorInterface::ABSOLUTE_URL);
  1236.         } else {
  1237.             $ticketListURL = $router->generate('helpdesk_customer_ticket_collection', [
  1238.                 'id' => $ticket->getId(),
  1239.             ], UrlGeneratorInterface::ABSOLUTE_URL);
  1240.         }
  1242.         $variables['ticket.link'] = sprintf("<a href='%s'>#%s</a>", $ticketListURL, $ticket->getId());
  1244.         return $variables;
  1245.     }
  1247.     public function paginateMembersTicketTypeCollection(Request $request)
  1248.     {
  1249.         // Get base query
  1250.         $params = $request->query->all();
  1251.         $ticketRepository = $this->entityManager->getRepository(Ticket::class);
  1252.         $paginationQuery = $ticketRepository->prepareBasePaginationTicketTypesQuery($params);
  1254.         // Apply Pagination
  1255.         $paginationOptions = ['distinct' => true];
  1256.         $pageNumber = !empty($params['page']) ? (int) $params['page'] : 1;
  1257.         $itemsLimit = !empty($params['limit']) ? (int) $params['limit'] : $ticketRepository::DEFAULT_PAGINATION_LIMIT;
  1259.         $pagination = $this->container->get('knp_paginator')->paginate($paginationQuery, $pageNumber, $itemsLimit, $paginationOptions);
  1261.         // Process Pagination Response
  1262.         $paginationParams = $pagination->getParams();
  1263.         $paginationData = $pagination->getPaginationData();
  1265.         $paginationParams['page'] = 'replacePage';
  1266.         $paginationData['url'] = '#' . $this->container->get('uvdesk.service')->buildPaginationQuery($paginationParams);
  1268.         return [
  1269.             'types' => array_map(function ($ticketType) {
  1270.                 return [
  1271.                     'id' => $ticketType->getId(),
  1272.                     'code' => strtoupper($ticketType->getCode()),
  1273.                     'description' => $ticketType->getDescription(),
  1274.                     'isActive' => $ticketType->getIsActive(),
  1275.                 ];
  1276.             }, $pagination->getItems()),
  1277.             'pagination_data' => $paginationData,
  1278.         ];
  1279.     }
  1281.     public function paginateMembersTagCollection(Request $request)
  1282.     {
  1283.         // Get base query
  1284.         $params = $request->query->all();
  1285.         $ticketRepository = $this->entityManager->getRepository(Ticket::class);
  1286.         $baseQuery = $ticketRepository->prepareBasePaginationTagsQuery($params);
  1288.         // Apply Pagination
  1289.         $paginationResultsQuery = clone $baseQuery;
  1290.         $paginationResultsQuery->select('COUNT(supportTag.id)');
  1291.         $paginationQuery = $baseQuery->getQuery()->setHydrationMode(Query::HYDRATE_ARRAY)->setHint('knp_paginator.count', count($paginationResultsQuery->getQuery()->getResult()));
  1293.         $paginationOptions = ['distinct' => true];
  1294.         $pageNumber = !empty($params['page']) ? (int) $params['page'] : 1;
  1295.         $itemsLimit = !empty($params['limit']) ? (int) $params['limit'] : $ticketRepository::DEFAULT_PAGINATION_LIMIT;
  1297.         $pagination = $this->container->get('knp_paginator')->paginate($paginationQuery, $pageNumber, $itemsLimit, $paginationOptions);
  1299.         // Process Pagination Response
  1300.         $paginationParams = $pagination->getParams();
  1301.         $paginationData = $pagination->getPaginationData();
  1303.         $paginationParams['page'] = 'replacePage';
  1304.         $paginationData['url'] = '#' . $this->container->get('uvdesk.service')->buildPaginationQuery($paginationParams);
  1306.         if (in_array('UVDeskSupportCenterBundle', array_keys($this->container->getParameter('kernel.bundles')))) {
  1307.             $articleRepository = $this->entityManager->getRepository(Article::class);
  1309.             return [
  1310.                 'tags' => array_map(function ($supportTag) use ($articleRepository) {
  1311.                     return [
  1312.                         'id' => $supportTag['id'],
  1313.                         'name' => $supportTag['name'],
  1314.                         'ticketCount' => $supportTag['totalTickets'],
  1315.                         'articleCount' => $articleRepository->getTotalArticlesBySupportTag($supportTag['id']),
  1316.                     ];
  1317.                 }, $pagination->getItems()),
  1318.                 'pagination_data' => $paginationData,
  1319.             ];
  1320.         } else {
  1321.             return [
  1322.                 'tags' => array_map(function ($supportTag) {
  1323.                     return [
  1324.                         'id' => $supportTag['id'],
  1325.                         'name' => $supportTag['name'],
  1326.                         'ticketCount' => $supportTag['totalTickets'],
  1327.                     ];
  1328.                 }, $pagination->getItems()),
  1329.                 'pagination_data' => $paginationData,
  1330.             ];
  1331.         }
  1332.     }
  1334.     public function getTicketInitialThreadDetails(Ticket $ticket)
  1335.     {
  1336.         $initialThread = $this->entityManager->getRepository(Thread::class)->findOneBy([
  1337.             'ticket' => $ticket,
  1338.             'threadType' => 'create',
  1339.         ]);
  1341.         $ticketId = $initialThread->getTicket()->getId();
  1342.         $databaseUrl = $_ENV['DATABASE_URL'] ?? getenv('DATABASE_URL');
  1343.         $parsedUrl = parse_url($databaseUrl);
  1344.     
  1345.         $host = $parsedUrl['host'];
  1346.         $db   = ltrim($parsedUrl['path'], '/');
  1347.         $user = $parsedUrl['user'];;
  1348.         $pass = $parsedUrl['pass'];
  1349.         $charset = 'utf8mb4';
  1351.         $dsn = "mysql:host=$host;dbname=$db;charset=$charset";
  1353.         // 2. Options for PDO
  1354.         $options = [
  1355.             PDO::ATTR_ERRMODE            => PDO::ERRMODE_EXCEPTION,  // throw exceptions on errors
  1356.             PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,        // fetch as associative array
  1357.             PDO::ATTR_EMULATE_PREPARES   => false,                   // use native prepared statements
  1358.         ];
  1360.         try {
  1361.             // 3. Create the PDO connection
  1362.             $connection = new PDO($dsn, $user, $pass, $options);
  1363.         } catch (\PDOException $e) {
  1364.             // 4. Handle connection error
  1365.             throw new \PDOException($e->getMessage(), (int)$e->getCode());
  1366.         }
  1368.         // 1. Define the SQL with a parameter placeholder :ticketId
  1369.         $sql = "
  1370.         SELECT custom_field_id, value
  1371.         FROM uv_pkg_uvdesk_form_component_ticket_custom_fields_values
  1372.         WHERE ticket_id = :ticketId
  1373.         AND thread_id IS NULL
  1374.         ";
  1376.         $stmt = $connection->prepare($sql);
  1377.         $stmt->bindParam(':ticketId', $ticketId, PDO::PARAM_INT);
  1378.         $stmt->execute();
  1379.         $rows = $stmt->fetchAll();
  1381.         // Optional: Transform into an array keyed by custom_field_id
  1382.         $customFieldValues = [];
  1383.         foreach ($rows as $row) {
  1384.             $customFieldValues[] = [
  1385.                 'custom_field_id' => $row['custom_field_id'],
  1386.                 'value'           => $row['value']
  1387.             ];
  1388.         }
  1391.         if (!empty($initialThread)) {
  1392.             $author = $initialThread->getUser();
  1393.             $authorInstance = 'agent' == $initialThread->getCreatedBy() ? $author->getAgentInstance() : $author->getCustomerInstance();
  1394.         
  1395.             $threadDetails = [
  1396.                 'id' => $initialThread->getId(),
  1397.                 'source' => $initialThread->getSource(),
  1398.                 'messageId' => $initialThread->getMessageId(),
  1399.                 'threadType' => $initialThread->getThreadType(),
  1400.                 'createdBy' => $initialThread->getCreatedBy(),
  1401.                 'message' => html_entity_decode($initialThread->getMessage()),
  1402.                 'attachments' => $initialThread->getAttachments(),
  1403.                 'timestamp' => $initialThread->getCreatedAt()->getTimestamp(),
  1404.                 'createdAt' => $initialThread->getCreatedAt()->format('d-m-Y h:ia'),
  1405.                 'user' => $authorInstance->getPartialDetails(),
  1406.                 'cc' => is_array($initialThread->getCc()) ? implode(', ', $initialThread->getCc()) : '',
  1407.                 'customfieldsvalue' => $customFieldValues,
  1408.             ];
  1410.             $attachments = $threadDetails['attachments']->getValues();
  1412.             if (!empty($attachments)) {
  1413.                 $uvdeskFileSystemService = $this->container->get('uvdesk.core.file_system.service');
  1415.                 $threadDetails['attachments'] = array_map(function ($attachment) use ($uvdeskFileSystemService) {
  1416.                     return $uvdeskFileSystemService->getFileTypeAssociations($attachment);
  1417.                 }, $attachments);
  1418.             }
  1419.         }
  1421.         return $threadDetails ?? null;
  1422.     }
  1424.     public function getCreateReply($ticketId, $firewall = 'member')
  1425.     {
  1426.         $qb = $this->entityManager->createQueryBuilder();
  1427.         $qb->select("th,a,u.id as userId")->from(Thread::class, 'th')
  1428.                 ->leftJoin('th.ticket','t')
  1429.                 ->leftJoin('th.attachments', 'a')
  1430.                 ->leftJoin('th.user','u')
  1431.                 ->andWhere('t.id = :ticketId')
  1432.                 ->andWhere('th.threadType = :threadType')
  1433.                 ->setParameter('threadType','create')
  1434.                 ->setParameter('ticketId',$ticketId)
  1435.                 ->orderBy('th.id', 'DESC')
  1436.                 ->getMaxResults(1);
  1438.         $threadResponse = $qb->getQuery()->getArrayResult();
  1440.         if((!empty($threadResponse[0][0]))) {
  1441.             $threadDetails = $threadResponse[0][0];
  1442.             $userService = $this->container->get('user.service');
  1443.             
  1444.             if ($threadDetails['createdBy'] == 'agent') {
  1445.                 $threadDetails['user'] = $userService->getAgentDetailById($threadResponse[0]['userId']);
  1446.             } else {
  1447.                 $threadDetails['user'] = $userService->getCustomerPartialDetailById($threadResponse[0]['userId']);
  1448.             }
  1449.             
  1450.             $threadDetails['reply'] = html_entity_decode($threadDetails['message']);
  1451.             $threadDetails['formatedCreatedAt'] = $this->timeZoneConverter($threadDetails['createdAt']);    
  1452.             $threadDetails['timestamp'] = $userService->convertToDatetimeTimezoneTimestamp($threadDetails['createdAt']);
  1453.         
  1454.             if (!empty($threadDetails['attachments'])) {
  1455.                 $entityManager = $this->entityManager;
  1456.                 $uvdeskFileSystemService = $this->container->get('uvdesk.core.file_system.service');
  1458.                 $threadDetails['attachments'] = array_map(function ($attachment) use ($entityManager, $uvdeskFileSystemService, $firewall) {
  1459.                     $attachmentReferenceObject = $entityManager->getReference(Attachment::class, $attachment['id']);
  1460.                     return $uvdeskFileSystemService->getFileTypeAssociations($attachmentReferenceObject, $firewall);
  1461.                 }, $threadDetails['attachments']);
  1462.             }
  1463.         }
  1464.         
  1465.         return $threadDetails ?? null;
  1466.     }
  1468.     public function hasAttachments($ticketId) {
  1469.         $qb = $this->entityManager->createQueryBuilder();
  1470.         $qb->select("DISTINCT COUNT(a.id) as attachmentCount")->from(Thread::class, 'th')
  1471.                 ->leftJoin('th.ticket','t')
  1472.                 ->leftJoin('th.attachments','a')
  1473.                 ->andWhere('t.id = :ticketId')
  1474.                 ->setParameter('ticketId',$ticketId);
  1476.         return intval($qb->getQuery()->getSingleScalarResult());
  1477.     }
  1479.     public function getAgentDraftReply()
  1480.     {
  1481.         $signature = $this->getUser()->getAgentInstance()->getSignature();
  1482.         
  1483.         return str_replace( "\n", '<br/>', $signature);
  1484.     }
  1486.     public function trans($text)
  1487.     {
  1488.         return $this->container->get('translator')->trans($text);
  1489.     }
  1491.     public function getAllSources()
  1492.     {
  1493.         $sources = ['email' => 'Email', 'website' => 'Website'];
  1494.         return $sources;
  1495.     }
  1497.     public function getCustomLabelDetails($container)
  1498.     {
  1499.         $currentUser = $container->get('user.service')->getCurrentUser();
  1501.         $qb = $this->entityManager->createQueryBuilder();
  1502.         $qb->select('COUNT(DISTINCT t) as ticketCount,sl.id')->from(Ticket::class, 't')
  1503.                 ->leftJoin('t.supportLabels','sl')
  1504.                 ->andwhere('sl.user = :userId')
  1505.                 ->setParameter('userId', $currentUser->getId())
  1506.                 ->groupBy('sl.id');
  1508.         $ticketCountResult = $qb->getQuery()->getResult();
  1510.         $data = array();
  1511.         $qb = $this->entityManager->createQueryBuilder();
  1512.         $qb->select('sl.id,sl.name,sl.colorCode')->from(SupportLabel::class, 'sl')
  1513.                 ->andwhere('sl.user = :userId')
  1514.                 ->setParameter('userId', $currentUser->getId());
  1516.         $labels = $qb->getQuery()->getResult();
  1518.         foreach ($labels as $key => $label) {
  1519.             $labels[$key]['count'] = 0;
  1520.             foreach ($ticketCountResult as $ticketCount) {
  1521.                 if(($label['id'] == $ticketCount['id']))
  1522.                     $labels[$key]['count'] = $ticketCount['ticketCount'] ?: 0;
  1523.             }
  1524.         }
  1526.         return $labels;
  1527.     }
  1529.     public function getLabels($request = null)
  1530.     {
  1531.         static $labels;
  1532.         if (null !== $labels)
  1533.             return $labels;
  1535.         $qb = $this->entityManager->createQueryBuilder();
  1536.         $qb->select('sl')->from(SupportLabel::class, 'sl')
  1537.             ->andwhere('sl.user = :userId')
  1538.             ->setParameter('userId', $this->getUser()->getId());
  1540.         if($request) {
  1541.             $qb->andwhere("sl.name LIKE :labelName");
  1542.             $qb->setParameter('labelName', '%'.urldecode($request->query->get('query')).'%');
  1543.         }
  1545.         return $labels = $qb->getQuery()->getArrayResult();
  1546.     }
  1548.     public function getTicketCollaborators($ticketId)
  1549.     {
  1550.         $qb = $this->entityManager->createQueryBuilder();
  1551.         $qb->select("DISTINCT c.id, c.email, CONCAT(c.firstName,' ', c.lastName) AS name, userInstance.profileImagePath, userInstance.profileImagePath as smallThumbnail")->from(Ticket::class, 't')
  1552.                 ->leftJoin('t.collaborators', 'c')
  1553.                 ->leftJoin('c.userInstance', 'userInstance')
  1554.                 ->andwhere('t.id = :ticketId')
  1555.                 ->andwhere('userInstance.supportRole = :roles')
  1556.                 ->setParameter('ticketId', $ticketId)
  1557.                 ->setParameter('roles', 4)
  1558.                 ->orderBy('name','ASC');
  1560.         return $qb->getQuery()->getArrayResult();
  1561.     }
  1563.     public function getTicketTagsById($ticketId)
  1564.     {
  1565.         $qb = $this->entityManager->createQueryBuilder();
  1566.         $qb->select('tg')->from(Tag::class, 'tg')
  1567.                 ->leftJoin('tg.tickets' ,'t')
  1568.                 ->andwhere('t.id = :ticketId')
  1569.                 ->setParameter('ticketId', $ticketId);
  1571.         return $qb->getQuery()->getArrayResult();
  1572.     }
  1574.     public function getTicketLabels($ticketId)
  1575.     {
  1576.         $qb = $this->entityManager->createQueryBuilder();
  1577.         $qb->select('DISTINCT sl.id,sl.name,sl.colorCode')->from(Ticket::class, 't')
  1578.                 ->leftJoin('t.supportLabels','sl')
  1579.                 ->leftJoin('sl.user','slu')
  1580.                 ->andWhere('slu.id = :userId')
  1581.                 ->andWhere('t.id = :ticketId')
  1582.                 ->setParameter('userId', $this->getUser()->getId())
  1583.                 ->setParameter('ticketId', $ticketId);
  1585.         $result = $qb->getQuery()->getResult();
  1586.         
  1587.         return $result ? $result : [];
  1588.     }
  1590.     public function getUserLabels()
  1591.     {
  1592.         $qb = $this->entityManager->createQueryBuilder();
  1593.         $qb->select('sl')->from(SupportLabel::class, 'sl')
  1594.                 ->leftJoin('sl.user','slu')
  1595.                 ->andWhere('slu.id = :userId')
  1596.                 ->setParameter('userId', $this->getUser()->getId());
  1598.         $result = $qb->getQuery()->getResult();
  1599.         
  1600.         return $result ? $result : [];
  1601.     }
  1603.     public function getTicketLabelsAll($ticketId)
  1604.     {
  1605.         $qb = $this->entityManager->createQueryBuilder();
  1606.         $qb->select('DISTINCT sl.id,sl.name,sl.colorCode')->from(Ticket::class, 't')
  1607.                 ->leftJoin('t.supportLabels','sl')
  1608.                 ->andWhere('t.id = :ticketId')
  1609.                 ->setParameter('ticketId', $ticketId);
  1611.         $result = $qb->getQuery()->getResult();
  1612.         
  1613.         return $result ? $result : [];
  1614.     }
  1616.     public function getManualWorkflow()
  1617.     {
  1619.         $preparedResponseIds = [];
  1620.         $groupIds = [];
  1621.         $teamIds = []; 
  1622.         $userId = $this->container->get('user.service')->getCurrentUser()->getAgentInstance()->getId();
  1624.         $preparedResponseRepo = $this->entityManager->getRepository(PreparedResponses::class)->findAll();
  1626.         foreach ($preparedResponseRepo as $pr) {
  1627.             if ($userId == $pr->getUser()->getId()) {
  1628.                 //Save the ids of the saved reply.
  1629.                 array_push($preparedResponseIds, (int)$pr->getId());
  1630.             }
  1631.         }
  1633.         // Get the ids of the Group(s) the current user is associated with.
  1634.         $query = "select * from uv_user_support_groups where userInstanceId =".$userId;
  1635.         $connection = $this->entityManager->getConnection();
  1636.         $stmt = $connection->prepare($query);
  1637.         $stmt->execute();
  1638.         $result = $stmt->fetchAll();
  1640.         foreach ($result as $row) {
  1641.             array_push($groupIds, $row['supportGroupId']);
  1642.         }
  1644.         // Get all the saved reply's ids that is associated with the user's group(s).
  1645.         $query = "select * from uv_prepared_response_support_groups";
  1646.         $stmt = $connection->prepare($query);
  1647.         $stmt->execute();
  1648.         $result = $stmt->fetchAll();
  1650.         foreach ($result as $row) {
  1651.             if (in_array($row['group_id'], $groupIds)) {
  1652.                 array_push($preparedResponseIds, (int) $row['savedReply_id']);
  1653.             }
  1654.         }
  1656.         // Get the ids of the Team(s) the current user is associated with.
  1657.         $query = "select * from uv_user_support_teams";
  1658.         $connection = $this->entityManager->getConnection();
  1659.         $stmt = $connection->prepare($query);
  1660.         $stmt->execute();
  1661.         $result = $stmt->fetchAll();
  1663.         foreach($result as $row) {
  1664.             if ($row['userInstanceId'] == $userId) {
  1665.                 array_push($teamIds, $row['supportTeamId']);
  1666.             }
  1667.         }
  1669.         $query = "select * from uv_prepared_response_support_teams";
  1670.         $stmt = $connection->prepare($query);
  1671.         $stmt->execute();
  1672.         $result = $stmt->fetchAll();
  1674.         foreach ($result as $row) {
  1675.             if (in_array($row['subgroup_id'], $teamIds)) {
  1676.                 array_push($preparedResponseIds, (int)$row['savedReply_id']);
  1677.             }
  1678.         }
  1680.         $qb = $this->entityManager->createQueryBuilder();
  1681.         $qb->select('DISTINCT mw')
  1682.             ->from(PreparedResponses::class, 'mw')
  1683.             ->where('mw.status = 1')
  1684.             ->andWhere('mw.id IN (:ids)')
  1685.             ->setParameter('ids', $preparedResponseIds);
  1686.         
  1687.         return $qb->getQuery()->getResult();
  1688.     }
  1690.     public function getSavedReplies()
  1691.     {   
  1692.         $savedReplyIds = [];
  1693.         $groupIds = [];
  1694.         $teamIds = []; 
  1695.         $userId = $this->container->get('user.service')->getCurrentUser()->getAgentInstance()->getId();
  1697.         $savedReplyRepo = $this->entityManager->getRepository(SavedReplies::class)->findAll();
  1699.         foreach ($savedReplyRepo as $sr) {
  1700.             if ($userId == $sr->getUser()->getId()) {
  1701.                 //Save the ids of the saved reply.
  1702.                 array_push($savedReplyIds, (int)$sr->getId());
  1703.             }
  1704.         }
  1706.         // Get the ids of the Group(s) the current user is associated with.
  1707.         $query = "select * from uv_user_support_groups where userInstanceId =".$userId;
  1708.         $connection = $this->entityManager->getConnection();
  1709.         $stmt = $connection->prepare($query);
  1710.         $stmt->execute();
  1711.         $result = $stmt->fetchAll();
  1713.         foreach ($result as $row) {
  1714.             array_push($groupIds, $row['supportGroupId']);
  1715.         }
  1717.         // Get all the saved reply's ids that is associated with the user's group(s).
  1718.         $query = "select * from uv_saved_replies_groups";
  1719.         $stmt = $connection->prepare($query);
  1720.         $stmt->execute();
  1721.         $result = $stmt->fetchAll();
  1723.         foreach ($result as $row) {
  1724.             if (in_array($row['group_id'], $groupIds)) {
  1725.                 array_push($savedReplyIds, (int) $row['savedReply_id']);
  1726.             }
  1727.         }
  1729.         // Get the ids of the Team(s) the current user is associated with.
  1730.         $query = "select * from uv_user_support_teams";
  1731.         $connection = $this->entityManager->getConnection();
  1732.         $stmt = $connection->prepare($query);
  1733.         $stmt->execute();
  1734.         $result = $stmt->fetchAll();
  1736.         foreach($result as $row) {
  1737.             if ($row['userInstanceId'] == $userId) {
  1738.                 array_push($teamIds, $row['supportTeamId']);
  1739.             }
  1740.         }
  1742.         $query = "select * from uv_saved_replies_teams";
  1743.         $stmt = $connection->prepare($query);
  1744.         $stmt->execute();
  1745.         $result = $stmt->fetchAll();
  1747.         foreach ($result as $row) {
  1748.             if (in_array($row['subgroup_id'], $teamIds)) {
  1749.                 array_push($savedReplyIds, (int)$row['savedReply_id']);
  1750.             }
  1751.         }
  1753.         $qb = $this->entityManager->createQueryBuilder();
  1754.         $qb->select('DISTINCT sr')
  1755.         ->from(SavedReplies::class, 'sr')
  1756.         ->Where('sr.id IN (:ids)')
  1757.         ->setParameter('ids', $savedReplyIds);
  1758.         
  1759.         return $qb->getQuery()->getResult();
  1760.     }
  1762.     public function getPriorities()
  1763.     {
  1764.         static $priorities;
  1765.         if (null !== $priorities)
  1766.             return $priorities;
  1768.         $qb = $this->entityManager->createQueryBuilder();
  1769.         $qb->select('tp')->from(TicketPriority::class, 'tp');
  1771.         return $priorities = $qb->getQuery()->getArrayResult();
  1772.     }
  1774.     public function getTicketLastThread($ticketId)
  1775.     {
  1776.         $qb = $this->entityManager->createQueryBuilder();
  1777.         $qb->select("th")->from(Thread::class, 'th')
  1778.                 ->leftJoin('th.ticket','t')
  1779.                 ->andWhere('t.id = :ticketId')
  1780.                 ->setParameter('ticketId',$ticketId)
  1781.                 ->orderBy('th.id', 'DESC');
  1783.         return $qb->getQuery()->setMaxResults(1)->getSingleResult();
  1784.     }
  1786.     public function getlastReplyAgentName($ticketId)
  1787.     {
  1788.         $qb = $this->entityManager->createQueryBuilder();
  1789.         $qb->select("u.id,CONCAT(u.firstName,' ', u.lastName) AS name,u.firstName")->from(Thread::class, 'th')
  1790.                 ->leftJoin('th.ticket','t')
  1791.                 ->leftJoin('th.user', 'u')
  1792.                 ->leftJoin('u.userInstance', 'userInstance')
  1793.                 ->andwhere('userInstance.supportRole != :roles')
  1794.                 ->andWhere('t.id = :ticketId')
  1795.                 ->andWhere('th.threadType = :threadType')
  1796.                 ->setParameter('threadType','reply')
  1797.                 ->andWhere('th.createdBy = :createdBy')
  1798.                 ->setParameter('createdBy','agent')
  1799.                 ->setParameter('ticketId',$ticketId)
  1800.                 ->setParameter('roles', 4)
  1801.                 ->orderBy('th.id', 'DESC');
  1803.         $result = $qb->getQuery()->setMaxResults(1)->getResult();
  1804.         return $result ? $result[0] : null;
  1805.     }
  1807.     public function getLastReply($ticketId, $userType = null) 
  1808.     {
  1809.         $queryBuilder = $this->entityManager->createQueryBuilder();
  1810.         $queryBuilder->select("th, a, u.id as userId")
  1811.             ->from(Thread::class, 'th')
  1812.             ->leftJoin('th.ticket','t')
  1813.             ->leftJoin('th.attachments', 'a')
  1814.             ->leftJoin('th.user','u')
  1815.             ->andWhere('t.id = :ticketId')
  1816.             ->andWhere('th.threadType = :threadType')
  1817.             ->setParameter('threadType','reply')
  1818.             ->setParameter('ticketId',$ticketId)
  1819.             ->orderBy('th.id', 'DESC')
  1820.             ->getMaxResults(1);
  1822.         if (!empty($userType)) {
  1823.             $queryBuilder->andWhere('th.createdBy = :createdBy')->setParameter('createdBy', $userType);
  1824.         }
  1825.         
  1826.         $threadResponse = $queryBuilder->getQuery()->getArrayResult();
  1827.         
  1828.         if (!empty($threadResponse[0][0])) {
  1829.             $threadDetails = $threadResponse[0][0];
  1830.             $userService = $this->container->get('user.service');
  1831.             
  1832.             if ($threadDetails['createdBy'] == 'agent') {
  1833.                 $threadDetails['user'] = $userService->getAgentDetailById($threadResponse[0]['userId']);
  1834.             } else {
  1835.                 $threadDetails['user'] = $userService->getCustomerPartialDetailById($threadResponse[0]['userId']);
  1836.             }
  1837.             
  1838.             $threadDetails['reply'] = html_entity_decode($threadDetails['message']);
  1839.             $threadDetails['formatedCreatedAt'] = $this->timeZoneConverter($threadDetails['createdAt']);
  1840.             $threadDetails['timestamp'] = $userService->convertToDatetimeTimezoneTimestamp($threadDetails['createdAt']);
  1842.             if (!empty($threadDetails['attachments'])) {
  1843.                 $entityManager = $this->entityManager;
  1844.                 $uvdeskFileSystemService = $this->container->get('uvdesk.core.file_system.service');
  1846.                 $threadDetails['attachments'] = array_map(function ($attachment) use ($entityManager, $uvdeskFileSystemService) {
  1847.                     $attachmentReferenceObject = $this->entityManager->getReference(Attachment::class, $attachment['id']);
  1848.                     return $uvdeskFileSystemService->getFileTypeAssociations($attachmentReferenceObject);
  1849.                 }, $threadDetails['attachments']);
  1850.             }
  1851.         }
  1853.         return $threadDetails ?? null;
  1854.     }
  1856.     public function getSavedReplyContent($savedReplyId, $ticketId)
  1857.     {
  1858.         $ticket = $this->entityManager->getRepository(Ticket::class)->find($ticketId);
  1859.         $savedReply = $this->entityManager->getRepository(SavedReplies::class)->findOneById($savedReplyId);
  1860.         $emailPlaceholders = $this->getSavedReplyPlaceholderValues($ticket, 'customer');
  1862.         return $this->container->get('email.service')->processEmailContent($savedReply->getMessage(), $emailPlaceholders, true);
  1863.     }
  1865.     public function getSavedReplyPlaceholderValues($ticket, $type = "customer")
  1866.     {
  1867.         $variables = array();
  1868.         $variables['ticket.id'] = $ticket->getId();
  1869.         $variables['ticket.subject'] = $ticket->getSubject();
  1871.         $variables['ticket.status'] = $ticket->getStatus()->getCode();
  1872.         $variables['ticket.priority'] = $ticket->getPriority()->getCode();
  1873.         if($ticket->getSupportGroup())
  1874.             $variables['ticket.group'] = $ticket->getSupportGroup()->getName();
  1875.         else
  1876.             $variables['ticket.group'] = '';
  1878.         $variables['ticket.team'] = ($ticket->getSupportTeam() ? $ticket->getSupportTeam()->getName() : '');
  1880.         $customer = $this->container->get('user.service')->getCustomerPartialDetailById($ticket->getCustomer()->getId());
  1881.         $variables['ticket.customerName'] = $customer['name'];
  1882.         $variables['ticket.customerEmail'] = $customer['email'];
  1883.         $userService = $this->container->get('user.service');
  1884.       
  1885.         $variables['ticket.agentName'] = '';
  1886.         $variables['ticket.agentEmail'] = '';
  1887.         if ($ticket->getAgent()) {
  1888.             $agent = $this->container->get('user.service')->getAgentDetailById($ticket->getAgent()->getId());
  1889.             if($agent) {
  1890.                 $variables['ticket.agentName'] = $agent['name'];
  1891.                 $variables['ticket.agentEmail'] = $agent['email'];
  1892.             }
  1893.         }
  1894.         
  1895.         $router = $this->container->get('router');
  1897.         if ($type == 'customer') {
  1898.             $ticketListURL = $router->generate('helpdesk_customer_ticket_collection', [
  1899.                 'id' => $ticket->getId(),
  1900.             ], UrlGeneratorInterface::ABSOLUTE_URL);
  1901.         } else {
  1902.             $ticketListURL = $router->generate('helpdesk_member_ticket_collection', [
  1903.                 'id' => $ticket->getId(),
  1904.             ], UrlGeneratorInterface::ABSOLUTE_URL);
  1905.         }
  1907.         $variables['ticket.link'] = sprintf("<a href='%s'>#%s</a>", $ticketListURL, $ticket->getId());
  1909.         return $variables;
  1910.     }
  1912.     public function isEmailBlocked($email, $website) 
  1913.     {
  1914.         $flag = false;
  1915.         $email = strtolower($email);
  1916.         $knowlegeBaseWebsite = $this->entityManager->getRepository(KnowledgebaseWebsite::class)->findOneBy(['website' => $website->getId(), 'isActive' => 1]);
  1917.         $list = $this->container->get('user.service')->getWebsiteSpamDetails($knowlegeBaseWebsite);
  1919.         // Blacklist
  1920.         if (!empty($list['blackList']['email']) && in_array($email, $list['blackList']['email'])) {
  1921.             // Emails
  1922.             $flag = true;
  1923.         } elseif (!empty($list['blackList']['domain'])) {
  1924.             // Domains
  1925.             foreach ($list['blackList']['domain'] as $domain) {
  1926.                 if (strpos($email, $domain)) {
  1927.                     $flag = true;
  1928.                     break;
  1929.                 }
  1930.             }
  1931.         }
  1933.         // Whitelist
  1934.         if ($flag) {
  1935.             if (isset($email, $list['whiteList']['email']) && in_array($email, $list['whiteList']['email'])) {
  1936.                 // Emails
  1937.                 return false;
  1938.             } elseif (isset($list['whiteList']['domain'])) {
  1939.                 // Domains
  1940.                 foreach ($list['whiteList']['domain'] as $domain) {
  1941.                     if (strpos($email, $domain)) {
  1942.                         $flag = false;
  1943.                     }
  1944.                 }
  1945.             }
  1946.         }
  1948.         return $flag;
  1949.     }
  1951.     public function timeZoneConverter($dateFlag)
  1952.     {
  1953.         $website = $this->entityManager->getRepository(Website::class)->findOneBy(['code' => 'Knowledgebase']);
  1954.         $timeZone = $website->getTimezone();
  1955.         $timeFormat = $website->getTimeformat();
  1957.         $activeUser = $this->container->get('user.service')->getSessionUser();
  1958.         $agentTimeZone = !empty($activeUser) ? $activeUser->getTimezone() : null;
  1959.         $agentTimeFormat = !empty($activeUser) ? $activeUser->getTimeformat() : null;
  1961.         $parameterType = gettype($dateFlag);
  1962.         if($parameterType == 'string'){
  1963.             if(is_null($agentTimeZone) && is_null($agentTimeFormat)){
  1964.                 if(is_null($timeZone) && is_null($timeFormat)){
  1965.                     $datePattern = date_create($dateFlag);
  1966.                     return date_format($datePattern,'d-m-Y h:ia');
  1967.                 } else {
  1968.                     $dateFlag = new \DateTime($dateFlag);
  1969.                     $datePattern = $dateFlag->setTimezone(new \DateTimeZone($timeZone));
  1970.                     return date_format($datePattern, $timeFormat);
  1971.                 }
  1972.             } else {
  1973.                 $dateFlag = new \DateTime($dateFlag);
  1974.                 $datePattern = $dateFlag->setTimezone(new \DateTimeZone($agentTimeZone));
  1975.                 return date_format($datePattern, $agentTimeFormat);
  1976.             }          
  1977.         } else {
  1978.             if(is_null($agentTimeZone) && is_null($agentTimeFormat)){
  1979.                 if(is_null($timeZone) && is_null($timeFormat)){
  1980.                     return date_format($dateFlag,'d-m-Y h:ia');
  1981.                 } else {
  1982.                     $datePattern = $dateFlag->setTimezone(new \DateTimeZone($timeZone));
  1983.                     return date_format($datePattern, $timeFormat);
  1984.                 }
  1985.             } else {
  1986.                 $datePattern = $dateFlag->setTimezone(new \DateTimeZone($agentTimeZone));
  1987.                 return date_format($datePattern, $agentTimeFormat);
  1988.             }    
  1989.         }         
  1990.     }
  1992.     public function fomatTimeByPreference($dbTime,$timeZone,$timeFormat,$agentTimeZone,$agentTimeFormat)
  1993.     {
  1994.         if(is_null($agentTimeZone) && is_null($agentTimeFormat)) {
  1995.             if(is_null($timeZone) && is_null($timeFormat)){
  1996.                 $dateTimeZone = $dbTime;
  1997.                 $timeFormatString = 'd-m-Y h:ia';
  1998.             } else {
  1999.                 $dateTimeZone = $dbTime->setTimezone(new \DateTimeZone($timeZone));
  2000.                 $timeFormatString = $timeFormat;
  2001.             }
  2002.         } else {
  2003.             $dateTimeZone = $dbTime->setTimezone(new \DateTimeZone($agentTimeZone));
  2004.             $timeFormatString = $agentTimeFormat;
  2005.         }
  2006.         $time['dateTimeZone'] = $dateTimeZone;
  2007.         $time['timeFormatString'] = $timeFormatString;
  2008.         return $time;
  2009.     }
  2010.     
  2011.     public function isTicketAccessGranted(Ticket $ticket, User $user = null, $firewall = 'members')
  2012.     {
  2013.         // @TODO: Take current firewall into consideration (access check on behalf of agent/customer)
  2014.         if (empty($user)) {
  2015.             $user = $this->container->get('user.service')->getSessionUser();
  2016.         }
  2018.         if (empty($user)) {
  2019.             return false;
  2020.         } else {
  2021.             $agentInstance = $user->getAgentInstance();
  2022.     
  2023.             if (empty($agentInstance)) {
  2024.                 return false;
  2025.             }
  2026.         }
  2028.         if ($agentInstance->getSupportRole()->getId() == 3 && in_array($agentInstance->getTicketAccessLevel(), [2, 3, 4])) {
  2029.             $accessLevel = $agentInstance->getTicketAccessLevel();
  2031.             // Check if user has been given inidividual access
  2032.             if ($ticket->getAgent() != null && $ticket->getAgent()->getId() == $user->getId()) {
  2033.                 return true;
  2034.             }
  2035.             
  2036.             if ($accessLevel == 2 || $accessLevel == 3) {
  2037.                 // Check if user belongs to a support team assigned to ticket
  2038.                 $teamReferenceIds = array_map(function ($team) { return $team->getId(); }, $agentInstance->getSupportTeams()->toArray());
  2039.                 
  2040.                 if ($ticket->getSupportTeam() != null && in_array($ticket->getSupportTeam()->getId(), $teamReferenceIds)) {
  2041.                     return true;
  2042.                 } else if ($accessLevel == 2) {
  2043.                     // Check if user belongs to a support group assigned to ticket
  2044.                     $groupReferenceIds = array_map(function ($group) { return $group->getId(); }, $agentInstance->getSupportGroups()->toArray());
  2046.                     if ($ticket->getSupportGroup() != null && in_array($ticket->getSupportGroup()->getId(), $groupReferenceIds)) {
  2047.                         return true;
  2048.                     }
  2049.                 }
  2050.             }
  2052.             return false;
  2053.         }
  2055.         return true;
  2056.     }
  2058.     public function addTicketCustomFields($thread, $requestCustomFields = [], $filesCustomFields = [])
  2059.     {
  2060.         $ticket = $thread->getTicket();
  2061.         $skipFileUpload = false;
  2062.         $customFieldsCollection = $this->entityManager->getRepository(CommunityPackageEntities\CustomFields::class)->findAll();
  2063.         foreach ($customFieldsCollection as $customFields) {
  2064.             if(in_array($customFields->getFieldType(), ['select', 'checkbox', 'radio']) && !count($customFields->getCustomFieldValues()))
  2065.                 continue;
  2066.             elseif('file' != $customFields->getFieldType() && $requestCustomFields && array_key_exists($customFields->getId(), $requestCustomFields) && $requestCustomFields[$customFields->getId()]) {
  2068.                 if(count($customFields->getCustomFieldsDependency()) && !in_array($ticket->getType(), $customFields->getCustomFieldsDependency()->toArray()))
  2069.                     continue;
  2071.                 $ticketCustomField = new CommunityPackageEntities\TicketCustomFieldsValues();
  2072.                 $ticketCustomField->setTicket($ticket);
  2073.                 //custom field
  2074.                 $ticketCustomField->setTicketCustomFieldsValues($customFields);
  2075.                 $ticketCustomField->setValue(json_encode($requestCustomFields[$customFields->getId()]));
  2077.                 if(in_array($customFields->getFieldType(), ['select', 'checkbox', 'radio'])) {
  2078.                     //add custom field values mapping too
  2079.                     if(is_array($requestCustomFields[$customFields->getId()])) {
  2080.                         foreach ($requestCustomFields[$customFields->getId()] as $value) {
  2081.                             if($ticketCustomFieldValues = $this->entityManager->getRepository(CommunityPackageEntities\CustomFieldsValues::class)
  2082.                                 ->findOneBy(['customFields' => $customFields, 'id' => $value]))
  2083.                                 $ticketCustomField->setTicketCustomFieldValueValues($ticketCustomFieldValues);
  2084.                         }
  2085.                     } elseif($ticketCustomFieldValues = $this->entityManager->getRepository(CommunityPackageEntities\CustomFieldsValues::class)
  2086.                             ->findOneBy(['customFields' => $customFields, 'id' => $requestCustomFields[$customFields->getId()]]))                                                        
  2087.                         $ticketCustomField->setTicketCustomFieldValueValues($ticketCustomFieldValues);
  2088.                 }
  2090.                 $this->entityManager->persist($ticketCustomField);
  2091.                 $this->entityManager->flush();
  2092.             } elseif($filesCustomFields && array_key_exists($customFields->getId(), $filesCustomFields) && $filesCustomFields[$customFields->getId()] && !$skipFileUpload) {
  2093.                 $skipFileUpload = true;
  2094.                 //upload files
  2095.             
  2096.                 $path = '/custom-fields/ticket/' . $ticket->getId() . '/';
  2097.                 $fileNames = $this->fileUploadService->uploadFile($filesCustomFields[$customFields->getid()], $path, true);
  2099.                 if(!empty($fileNames)) {
  2100.                     //save files entry to attachment table
  2101.                     try {
  2102.                         $customFieldsService = null;
  2104.                         try {
  2105.                             if ($this->userService->isfileExists('apps/uvdesk/custom-fields')) {
  2106.                                 $customFieldsService = $this->get('uvdesk_package_custom_fields.service');
  2107.                             } else if ($this->userService->isfileExists('apps/uvdesk/form-component')) {
  2108.                                 $customFieldsService = $this->get('uvdesk_package_form_component.service');
  2109.                             }
  2110.                         } catch (\Exception $e) {
  2111.                             // @TODO: Log execption message
  2112.                         }
  2114.                         $newFilesNames = !empty($customFieldsService) ? $customFieldsService->addFilesEntryToAttachmentTable([$fileNames], $thread) : [];
  2116.                         foreach ($newFilesNames as $value) {
  2117.                             $ticketCustomField = new CommunityPackageEntities\TicketCustomFieldsValues();
  2118.                             $ticketCustomField->setTicket($ticket);
  2119.                             //custom field
  2120.                             $ticketCustomField->setTicketCustomFieldsValues($customFields);
  2121.                             $ticketCustomField->setValue(json_encode(['name' => $value['name'], 'path' => $value['path'], 'id' => $value['id']]));
  2122.                             $this->entityManager->persist($ticketCustomField);
  2123.                             $this->entityManager->flush();
  2124.                         }
  2125.                     } catch (\Exception $e) {
  2126.                         // @TODO: Log execption message
  2127.                     }
  2128.                 }
  2129.             }
  2130.         }
  2131.     }
  2133.     // return attachemnt for initial thread
  2134.     public function getInitialThread($ticketId)
  2135.     {
  2136.         $firstThread = null;
  2137.         $intialThread = $this->entityManager->getRepository(Thread::class)->findBy(['ticket'=>$ticketId]);
  2138.         foreach ($intialThread as $key => $value) {
  2139.             if($value->getThreadType() == "create"){
  2140.                 $firstThread = $value;
  2141.             }
  2142.         }
  2143.         return $firstThread;
  2144.     }
  2145. }